domingo, 21 de noviembre de 2010

Respuestas del examen ordinario (Ptos Extras)

Hola compañeros!, En esta entrada contestare las respuestas del examen que presentamos el viernes, espero que les sea de utilidad.
La verdad no recuerdo las preguntas exactamente como eran pero expongo de lo que me acuerdo.


La primera era algo de que a = falsa, y b = verdadera, si a -> b ¿Es verdadera o falsa?


El símbolo -> significa implicación en lógica por lo tanto la tabla de verdad de implicación es:




Aquí podemos ver que la respuesta es verdadera






Luego venia una de que pusiéramos el diagrama de flujo de iteración



Otra pregunta decía ¿como compilar un programa en C con Linux?
gcc x.c
./a.out



Después nos preguntaba ¿Que es mantisa?


La mantisa debe cumplir la condición de: 1= mantisa < 2
Por lo tanto la parte entera siempre sera 1 y solo sera guardada en el numero la parte decimal justificada a la derecha.




En otra pregunta nos pedía decir ¿Que son punteros?


Tipo de datos dinámica que es una variable que hace referencia a una región de memoria, cuyo valor es la dirección de memoria.




Después ¿Cuales son las partes fundamentales del Objeto?
estado+comportamento+identidad.


En otra pregunta nos pedía decir ¿Que es un lenguaje multiparadigma?


Un lenguaje de programación multiparadigma soporta mas de un paradigma de programación, con el objetivo de utilizar el mejor paradigma para cada trabajo.


¿que hace el self en python?
Permite acceder a las propiedades y métodos de un objeto en concreto, es necesario incluir self como primer parámetro de los métodos definidos en una clase.


En el área de lenguajes de programación, ¿Que es Mercury?
Es un Lenguaje lógico


¿Que es una estructura?
Contiene varios tipos de datos, que son útiles para crear en una misma estructura varios tipos de datos, son como una clase pero sin métodos, ya que solo almacena datos.



Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

Reporte POO

Hola! Este es mi Reporte sobre los 3 programas de diferentes lenguajes sobre la programación orientada a objetos.


Python
Para empezar voy a poner este programa que hice, que me ayudo a comprender las clases y objetos.
Un ejemplo de objeto puede ser un tinaco, en donde tendríamos atributos como la marca, el numero de mangueras conectadas, la presión etc..., el método seria cuando va a tirar agua y cuando se detiene.


En Python las clases se definen con la palabra class y luego el nombre con mayúscula al inicio después dos puntos, después de aquí va el cuerpo de la clase.

#!/usr/bin/python

class Tinaco:
    def __init__(self, agua):
        self.agua = agua
        print "Tenemos", agua, "galones de agua"
        
    def lava(self):
        if self.agua &gt; 0:
            print "Saca agua! :)"
        else:
            print "No hay agua! :("
        
    def bana(self):
        if self.agua &gt; 0:
            self.agua -= 1
            print "Quedan", self.agua, "galones de agua"
        else:
            print "Ya no hay :(..."
            
mi_tinaco = Tinaco(5)
print mi_tinaco.agua
mi_tinaco.lava()
mi_tinaco.bana()
mi_tinaco.bana()
mi_tinaco.bana()
mi_tinaco.bana()
mi_tinaco.bana()
mi_tinaco.lava()
print mi_tinaco.agua

El método __init__. hace que inicialice el proceso.
Para crear un nuevo objeto escribo el nombre después lo igualo a la clase y el parámetro.
Solo necesitamos un parámetro porque el otro (self) lo referencia automaticamente.


Después hago consultas hasta que el tinaco quede vació.
Captura de pantalla del programa.


Java
Este programa basado en uno que hicimos en asesorías de programación el verano pasado, se declaran 4 botones en los puntos cardinales que al momento de picarles cambia de color el BorderLayout del centro 

// librerias usadas en este programa
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.JLabel;
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.Color;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

// aqui comienza nuestra clase
public class Direccion implements ActionListener {

    // todo el codigo va aqui adentro

    public void actionPerformed(ActionEvent e) {
 String cmd = e.getActionCommand();

 if (cmd.equals("NORTE")) { //si se cumple la condicion, cambia el color
     this.principal.setBackground(Color.GREEN);
 }

 if (cmd.equals("SUR")) {
     this.principal.setBackground(Color.BLUE);
 }

 if (cmd.equals("ESTE")) {
     this.principal.setBackground(Color.RED);
 }

 if (cmd.equals("OESTE")) {
     this.principal.setBackground(Color.YELLOW);
 }
 return;
    }

    private JPanel principal;
    public Direccion(JPanel p) { // constructor de Botones
 this.principal = p;
    }

    // el metodo principal
    public static void main(String[] args) {
 JFrame f = new JFrame(); // creamos la ventana nueva

 f.setSize(800, 600); // tamaño
 f.setLocation(100, 200); // posicion
 f.setTitle("Puntos cardinales"); // nombre

 // que pasa cuando lo cierro
 f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

 // paneles
 JPanel pBorder = new JPanel();
 JPanel p = new JPanel(); // panel del fondo
 Direccion yo = new Direccion(pBorder);
 pBorder.setLayout(new BorderLayout());
 p.setLayout(new GridLayout());
 pBorder.setBackground(Color.WHITE); //color del inicio


 JButton norte = new JButton("Norte"); //creo botones
 JButton sur = new JButton("Sur");
 JButton este = new JButton("este");
 JButton oeste = new JButton("Oeste");

 pBorder.add(norte, BorderLayout.NORTH); //los agrego al panel
 pBorder.add(sur, BorderLayout.SOUTH);
 pBorder.add(este, BorderLayout.WEST);
 pBorder.add(oeste, BorderLayout.EAST);
 pBorder.add(new JLabel("Colorsitos"), BorderLayout.CENTER);


 //agrego los listeners
 norte.addActionListener(yo);
 norte.setActionCommand("NORTE");
 sur.addActionListener(yo);
 sur.setActionCommand("SUR");
 este.addActionListener(yo);
 este.setActionCommand("ESTE");
 oeste.addActionListener(yo);
 oeste.setActionCommand("OESTE");

 //agrego el panel pBorder al principal
 p.add(pBorder);

 // hacer que este panel sea el contenido de la ventana
 f.setContentPane(p);

 // hacer que la ventana sea visible
 f.setVisible(true);

 // salir del programa
 return;
    } // termina main

} // termina la clase Direccion

Capturas de pantalla





C++
Este es un programa que tiene una clase de Cambio en donde se tienen funciones para realizar cambios en monedas, ya había realizado uno parecido pero en python sin clases, ahora este esta orientado a objetos.


#include <iostream>

using std::cout;
using std::endl;
using std::cin;

//clase Cambio
class Cambio {
public:
 double rescambio;
 float agarrame(void);
 void dolar(float pesos);
 void euro(float pesos);
 void libras(float pesos);
};

void Cambio :: dolar(float pesos){
 rescambio = pesos / 12.95;
 cout << "El cambio a dolares es:" << endl;
 cout << rescambio << endl;
 return;
}

void Cambio :: euro(float pesos){
 rescambio = pesos / 16.44;
 cout << "El cambio a euros es:" << endl;
 cout << rescambio << endl;
 return;
}

void Cambio :: libras(float pesos){
 rescambio = pesos / 20.36;
 cout << "El cambio a libras es:" << endl;
 cout << rescambio << endl;
 return;
}

float Cambio :: agarrame(void){
 float pesos;
 cout << "Dime los pesos" << endl;
 cin >> pesos;
    return pesos;
} 

int main (int argc, char** args){
 Cambio cambiame;
 int selecciona;
 float pesos1;
 cout << "Selecciona que cambio deseas realizar:" << endl;
 cout << "1) Cambio a dolares" << endl;
 cout << "2) Cambio a euros" << endl;
 cout << "3) Cambio a libras" << endl;
 cin >> selecciona;
 
 switch (selecciona) {
  case 1:
   pesos1 = cambiame.agarrame();
   cambiame.dolar(pesos1);
   break;
   
     case 2:
   pesos1 = cambiame.agarrame();
   cambiame.euro(pesos1);
   break;
   
  case 3:
   pesos1 = cambiame.agarrame();
   cambiame.libras(pesos1);
   break;
   
 
  default:
   cout << "leea bien las intrucciones :)";
 }
 
 return 0;
}



Esto es todo de mi Reporte de programación orientada a objetos.
Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

Video: Como instalar y Compilar en GO!...

Hola compañeros hice un video de como instalar GO! en ubuntu.






Aqui les dejo las instrucciones

Primero tienes que poner en el terminal.

gedit ~/.bashrc

Se te abre un archivo al cual le tienes que poner estas lineas.

export GOROOT=$HOME/go
export GOOS=linux
export GOARCH=386
export GOBIN=$HOME/bin
export PATH=$PATH:$GOBIN

Nota que en la tercera linea, puede ser cambiado según la arquitectura de tu procesador,  si es amd64 o arm, para mi computadora era el 386.

Guardas el archivo y pones esto en el terminal

source ~/.bashrc 

Ahora creamos un directorio

mkdir $GOBIN
Ahora vas  instalar Mercurial que es el cliente para controlar las versiones.

 sudo apt-get install mercurial

Instalas estos paquetes.

sudo aptitude install bison gcc libc6-dev ed
Descargas  

hg clone -r release https://go.googlecode.com/hg/ $GOROOT
luego compilas lo descargado

cd $GOROOT/src
./all.bash
Al finalizar deberá decir

— cd ../test
0 known bugs; 0 unexpected bugs


 Ojo, la manera de compilar cambia segun la arquitectura que escogiste.
amd64 = 6.
386 = 8.
arm = 5.



Programa de ejemplo (Es el mismo de mi entrada de semana 3) 


package main

import "fmt"

func main() {
        cadena := "Esta..es..una..prueba..GO!"
        fmt.Printf("La cadena: \n%s\nTiene una longitud: %d\n", cadena, len([]byte(cadena)))

    var a int
    var b int
    var c int
   
    b = 0
    c = 1   

    fmt.Printf("Ahora va la serie fibo :)...\n")   

    for n := 0; n < 20; n++ {
        a = b + c
        c = b
        b = a
        fmt.Printf("%d ,", a)
    }
}


Si tienen algún comentario acerca de mi publicación, espero me lo hagan saber ya que estoy abierto a cualquier error.

Modelo Orientado a Objetos (Ptos Extra)

Como sabemos y hemos visto en clase, la programacion orientada a objetos es un paradigma de programación que su principal objetivo es representar por medio de objetos agrupando datos y metodos para describir las caracteristicas y su comportamiento

Ventajas de utilizar una programacion orientada a objetos

  • Reutilizacion de codigo
  • Sistemas mas complejos
  • Sistemas al mundo real
  • Creacion de programas visuales
  • Contruir prototipos




Para comprender mejor la programacion orientada a objetos voy a escribir un breve resumen de los conceptos basicos de este paradigma.

  1. Objeto
  2. Clase
  3. Mensaje
  4. Metodo
  5. Interfaz
  6. Herencia




El Objeto:
Es una unidad, esta engloba las mismas caracteristicas y comportamiento que se necesitan para procesar la informacion. Cada uno de estos tiene datos y funciones. por lo tanto un programa se hace con solo uno o varios objetos.


Ejemplo:


-Carro Bochito
   Características:
      4 llantas pequeñas
      Motor VMW
     Caja de cambios 5 velocidades
     Color rojo
     2 Espejos




La Clase:
Es un prototipo en donde se definen las variables y metodos comunes a todos los objetos que tiene cierta clase, entonces podemos decir que una clase es una tipo plantilla para un grupo de objetos que tienen caracteristicas similares.


Ejemplo:


-Clase Vehiculo
       -Numero de Ruedas
       -Tipo de motor
       -Capacidad de Tanque
       -Numero de velocidades de la caja de cambios
       -Color




El Mensaje:
Es el modo con el que se estan comunicando los objetos entre ellos.


Ejemplo:
      -Cuando llamamos a una funcion de un objeto, esto es le manda un mensaje a este objeto.




El Metodo:
Lo que hace es procesar los mensajes del concepto anterior que estan llegando a un objeto, este es un procedimiento que pertenece al un objeto.






La Interfaz:
Las clases y los objetos, tienen partes que son publicas y otras privadas. entonces algunas veces llamamos a la parte publica de un objeto, es la unica parte del objeto visible para los demas objetos, por lo tanto es lo unico de lo que se dispone para comunicarse entre si.




La Herencia:
Concepto clave en la programación orientada a objetos, la herencia consiste en que una clase pude heredar sus variables o metodos a otras subclases, por lo tanto una subclase, aparte de atributos y metodos de el mismo, tiene atributos y metodos heredados de otra superclase.




Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

Threads de ANSI-C (Ptos Extra)

Cuando queremos hacer un programa que empieze a ejecutar varias cosas al mismo tiempo tenemos 2 opciones, Crear un nuevo proceso o crear un nuevo hilo de ejecución (thread en ingles). Lo que hace es que el sistema operativo va ejecutando pedasitos de programas por sucesiones cada cierto tiempo de manera rápida.


Un proceso de Unix es un programa en ejecución, independiente de otros procesos, cuando nosotros nos vamos a el terminal y escribimos "ps" nos da una lista de los procesos de ejecución en nuestra maquina. El proceso tiene una parte de memoria propia y esta ejecutandose simultaneamente con otros procesos, por lo tanto no es posible que otro proceso entre a la memoria de otro proceso. por lo tanto por eso unix es un sistema bueno ya que ningún programa que tenga malas intensiones pueden entrar a otro en ejecución incluso ni al propio sistema operativo.


Ahora bien, dentro de un proceso puede que haya varios hilos de ejecución ( o sea varios threads).


Por lo tanto un proceso puede estar haciendo varias cosas a la vez. estos hilos dentro del proceso comparten la misma zona de memoria, por ejemplo si un thread lee una variable, todos los demás del mismo proceso verán el valor de esta variable, por lo tanto cuando hacemos un programa con estas características es indispensable usar mutex (o sea exclusión mutua) para así podemos evitar que haya dos threads al mismo tiempo accedan a la misma estructura de datos, también si un thread se equivoca en algo y estropea la zona de memoria, todos los demás threads vean que esa memoria esta estropeada, por lo tanto un solo fallo en un thread puede fallar a los demás del mismo proceso.


Entonces si hablamos en términos de complejidad, los threads, como comparten memoria y recursos, es obligatorio usar mutex (como había puesto arriba) que son como tipo semáforos, para asi, al momento de emitir un proceso, se haga independiente del de nosotros, para no tener ningún problema, solo que si necesitamos que se comuniquen, lo que necesitariamos es programar memorias compartidas, sockets o mensajes, entre otros.


Ejemplo de como crear threads en C.


Este codigo que encontre en esta pagina es un ejemplo de como crear 2 threads que van a imprimir por la salida estandar, N veces "hola mundo" y M veces "mundo hola"
Para empezar para crear un threads necesitamos la libreria estandar pthreads.h, es parte de gnu library de Linux, nos da el acceso para todas las funciones que empiezen con pthreads_*. En este ejemplo solamente se utilizara pthread_create y pthread_join.



#include <stdio.h>
#include <pthread.h>

#define N 8
#define M 16

const char *mensaje[2] = {"Hola Mundo", "Mundo Hola"};
const int cantidad[2] = {N, M};

void imprime_mensaje(void *ptr);

int main(void)
{
 pthread_t hilo0, hilo1;
 int id0=0, id1=1;

 pthread_create(&hilo0, NULL, (void *) &imprime_mensaje, (void *) &id0); 
 pthread_create(&hilo1, NULL, (void *) &imprime_mensaje, (void *) &id1); 
 
 pthread_join(hilo0, NULL);
 pthread_join(hilo1, NULL);

 return 0;
}

void imprime_mensaje(void *ptr) {
 int i=0, id=0;

 id = *(int *) ptr;
 for(i=0; i <cantidad[id]; i++)
  printf("%s\n",mensaje[id]);
 return;
}

Para compilar lo que se hace es incluir la libreria PThread:

mac-rober:~ robertomtz$ gcc -Wall -lpthread -o holaMundo holaMundo.c


Vemos que cuando llamamos a pthread_create esta pasando como una función y necesita varios typecasts (como hable en una entrada anterior que cambia el tipo de dato) para así estar compatible con los tipos de datos que se requieren.
Se definen id0 y id1 con dos contantes, ya que es necesario para pasarle la direccion y no el valor en si.


La función pthread_join, hacen evitar que al terminal el main principal, termine con la vida de los threads. la terminación de un thread es con un return, equivalente a pthread_exit(NULL).

Para concluir, A nosotros como programadores ¿De que nos sirve todo esto?.
Para realizar software de trabajo interactivo, en segundo plano, procesamiento asíncronos, aceleración de la ejecución, y estructuración modular de los programas.

Para la explicación me base en esta y esta pagina

Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

Python como POO (Ptos Extra)

Python es totalmente copatible para la creacion de programas orientado a objetos, ya que nosotros podemos definir nuestras propias clases, heredarlas, e hacer instancias de clases que hayamos definido.


En Python las clases se definen con la palabra reservada class despues ponemos el nombre de la clase, luego dos puntos y ponemos el cuerpo de la clase, llamado tambien indentado.


Ejemplo:
class Ejemplo     #1
   pass           #2

En este ejemplo el nombre de la clase es Ejemplo, no hereda otra clase, si se fijan las clases inician con Mayúscula al igual que java.
Esta clase no se le definen atributos pero no puede estar sin nada por lo tanto ponemos la funcion pass, equivalente en otros lenguajes como C, usar {}


El metodo __init__
import math
class Complejo:
      def __init__(self, real, imaginario):
          self.real = real
          self.img = imaginario
      def abs(self):
          print math.sqrt((self.real * self real) + (self.img * self.img))

Las clases de python tienen algo semejante a un contructor: el metodo __init__, se llama luego de crear una instancia de la clase.
No se le puede llamar completamente un costructor ya que, actua como uno, pero el objeto ya se ha construido cuando se llama este metodo y ya tiene una referencia valida a la nueva instancia de la clase. es lo mas parecido a un contructor en python.


La primera variable de cada metodo es siempre la referencia a la instancia actual de la clase.
Por reglas del lenguaje, se le llama self, en el metodo __init__, self hace referencia al objeto que recien se creo, en otros metodos se refiere a la instancia cuyo metodo ha sido llamado.


Los metodos __init__ puede tomar cantidades de argumentos tambien se pueden definir con valores de defecto.


self es como si fuera la palabra reservada this en c++ o java, pero en python no es una palabra reservada, sino una convencion, esta no se especifica al invocar el metodo ya que Python lo agrega automaticamente.


Para crear un objeto en python, lo que se necesita es invocar a la clase como si fuera una funcion, con los argumentos que defina el metodo __init__ y el valor que retornara sera el objeto que recien se creo.

import math
class Complejo:
      def __init__(self, real, imaginario):
          self.real = real
          self.img = imaginario
      def abs(self):
          print math.sqrt((self.real * self real) + (self.img * self.img))

def main():
      numero = comlejo(3,4) 
      numero.abs()

if __name__ == '__main__':
     main()

En la linea 10, se crea el objeto y se inicializa haciendo el llamado al metodo __init__ pasando con los valores real=3 e imaginario =4
En la linea 11, convocamos el metod abs de la clase Complejo.


Borrado
Es importante decir que los objetos se borran automaticamente sin necesidad de liberar de forma explicita en las instancias, ya que cuando las variables a las que se asignan salen del codigo.


Operadores
Cuando utilizamos muchos operadores podemos usarlos como clases definidas, reutilizando el mismo operador pero con numeros diferentes, Python decide como usar el operador.



  • __add__(self,other)
  • __sub__(self,other)
  • __mul__(self,other)
  • __floordiv__(self,other)
  • __mod__(self,other)
  • __divmod__(self,other)
  • __pow__(self,other)
  • __and__(self,other)
  • __xor__(self,other)
  • __or__(self,other)


Ejemplo con el código anterior:
import math
class Complejo:
      def __init__(self, real, imaginario):
          self.real = real
          self.img = imaginario
      def abs(self):
          print math.sqrt((self.real * self real) + (self.img * self.img))
      def __add__(self, otro):
          print complejo(self.real + otro.real, self.img + otro.img)
      def __sub__(self, otro):
          print complejo(self.real + otro.real, self.img + otro.img)
      def mostrar(self):
          print self.real
          print self.img

def main():
      complejo1 = complejo(3,4)
      complejo2 = complejo(3,4)
      complejo3 = complejo1 + complejo2
      complejo4 = complejo1 - complejo2
      complejo3.mostrar()
      complejo4.mostrar()

if __name__ == '__main__':
     main()

Herencia

  • principal propiedad de las clases.
  • Nos permite crear nuevas clases apartir de existentes.
  • Conserva las propiedades de la clase original añadiendo nuevas.



Ejemplo de Python con clases heredadas.
class Animal:
    def __init__(self):
       print "Animal creado"
    def quiensoy(self):
       print "Animal"
    def comer(self):
       print "Estoy comiendo"

class Perro(Animal):
    def __init__(self):
       Animal.__init__(self)
       print "Perro Creado"
    def quiensoy(self):
       print "Perro"
    def ladrar(self):
       print "Woof Woof!"
def main():
     d = Perro()
     d.quiensoy()
     d.comer()
     d.ladrar()

if __name__ == '__main__':
    main()


Referencias
Python para todos, Raul Gonzalez Duque
Aprenda a Pensar como programador de Python, Allen Downey
Diapositivas de Jesse Padilla Agudelo aqui


Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

jueves, 18 de noviembre de 2010

¿Que es la programación paralela? (Lab)

La programación paralela es el uso de varios procesadores trabajando en conjunto para dar solución a una tarea en común, lo que hacen es que se dividen el trabajo y cada procesador hace una porción del problema al poder intercambiar datos por una red de interconexión o atraves de memoria.


La programacion paralela permite resolver problemas que no caben en un solo procesador y que no se resuelven en un tiempo razonable, se pueden ejecutar problemas con mayor complejidad mas rápidamente.


El rendimiento de las computadoras tradicionales secuenciales esta saturándose porque las aplicaciones de hoy en dia necesitan realizar trabajo mas complejo, por lo cual la solución es tener varios procesadores en sistemas paralelos, al así obtener ganancia de eficiencia siempre y cuando los algoritmos se diseñen adecuadamente.


Lenguajes para computadoras paralelos son flexibles para permitir una implementación eficiente y ser aun mas fáciles para programar


Dos tecnicas básicas:
pipeline:


Un pipeline es un conjunto de elementos procesadores de datos conectados en serie, en el cual la salida de un elemento esta conectado en la entrada del que sigue. los elementos de esta técnica son ejecutados en paralelo, debe haber un tipo buffer insertando los elementos.


Aplicaciones de pipelines, consiste en múltiples procesos que están ordenados de tal forma que el flujo de salida de un proceso se alimenta de la entrada del siguiente proceso.




Replicacion asincronica


Tecnología en la que una vez que los datos están escritos en el sitio de almacenamiento primario, los nuevos datos a este sitio son aceptadas, sin tener que esperar que el sitio de almacenamiento secundario o remoto termine su escritura.


Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

Modelo de objetos (Lab)

Serie de principios para saber como se modeliza al crear un programa bajo el paradigma de orientación a objetos.


Abstracción
La Abstracción es un principio en el cual se aisla toda información que no sea relevante en algún nivel de conocimiento, esto quiere decir que se separa en el caso de lenguajes orientados a objetos, según sus propiedades, esto es, el método, el objeto, clase y modulo, para así hacer a implementación del programa.


Es una descripción de especificación que se enfoca a las características de algo, solamente las propiedades esenciales y el comportamiento de un objeto.


Ejemplo practico de abstracción:

  • ¿Que características podemos abstraer de los iPods? o que es lo mismo ¿Que características semejantes tienen todos los iPods?
  • Características escenciales
  • Modelo, Memoria, Pantalla, Audifonos.... etc..


Encapsulamiento
El encapsulamento lo que hace es unir la clase con las características y sus comportamientos, o sea, las variables y metodos, para tener todo en una sola entidad, por lo tanto podemos decir que el encapsulamiento se logra gracias a la abstracción, facilita el manejo de la complejidad, ya que en las clases solo se conoce el comportamiento pero no mas detalles, es conveniente para saber que hace pero no como lo hace.


Ejemplo practico de Encapsulamiento:

  • De un iPod nosotros como usuarios conocemos su apariencia y algunas cosas de como funciona, a nosotros nos importa que se escuche bien la música, mas no nos interesa saber que hace cada una de las partes detalle a detalle del aparato.


Modularidad
Nos permite a nosotros como programadores en dividir nuestra aplicación en diferentes módulos ya sea en paquetes, clases, librerías... cada uno con sentido propio.
Esta separación hace que disminuya el grado de dificultad del problema al que se da en un programa, pues así podemos facilitar la comprensión de este.


Jerarquía
Del mismo modo que en la vida real, las clases de un programa se organizan mediante una jerarquía dando lugar a los arboles de herencia donde una clase hija puede tomar propiedades de una clase padre para así simplificar el diseño y evitar duplicar el código.

Paso de Mensajes
Un objeto puede solicitar a otro que haga acciones o que cambie su estado, implementándose al hacer llamadas a otros métodos de otros objetos, seria algo como mandar llamar funciones en lenguajes imperativos pero en este caso es a objetos.

Polimorfismo
Esto quiere decir que como su nombre lo indica tenemos un objeto y muchas formas, permite que el objeto presente diferentes comportamientos según en donde se encuentre.


Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

Lenguaje de programación fuertemente tipado

Se dice que un lenguaje de programacion fuertemente tipado es cuando no se permiten violaciones sobre los tipos de datos, esto quiere decir que, necesitamos una variable de un tipo concreto, no se puede usar como si fuera de otro tipo, solo que se haga una conversión.


La mayoría de los lenguajes que vimos en la clase de imperativos son fuertemente tipados a diferencia de los lenguajes declarativos que suelen no estar tipado.


Los lenguajes de programación algunas veces tiene otro lenguaje de tipos de datos al momento de declarar variables, lo que hace es instruir a el compilador respecto al tipo de valor que puede tomar cada variable.


int robert; //o sea, la variable roberto 
     //puede tener valores numericos enteros.


Los tipos también se necesitan que declarar en funciones ejemplo:
float Calculo(float ingreso)
{
   ingreso = ingreso + 0.75;
   return ingreso;
}

En donde se requiere que al salir de la función sea float, si ponemos.
int robert;
Calculo(robert);
float Calculo(float ingreso)
{
   ingreso = ingreso + 0.75;
   return ingreso;
}


Nos marcaría error el compilador ya que ingreso es float y necesita a fuerzas entrar y regresar un float porque sus tipos no coinciden exactamente.

¿Que hacer en estos casos?
Utilizar typcasting que convierte los tipos de datos, debemos de convertirlos explícitamente y debe de estar soportado por el compilador.

por ejemplo

Calculo((float(rober)
float Calculo(float ingreso)
{
   ingreso = ingreso + 0.75;
   return ingreso;
}

En donde indicamos a el compilador que queremos convertir la variable robert a flotante para poder así mandarla a la función.


Es importante decir que la conversión de entero a flotante es asi como en el ejemplo pero si queremos hacer el caso contrario no es admitido, ya que emitirá un error de compilación.

Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.

Punto Flotante (Lab)

Punto flotante es un método para representar números reales con orden de magnitud del valor a representar, moviéndolo a el punto decimal por medio de un exponente hacia la posición de la primera cifra significativa del valor.


Componentes
Un numero de punto flotante esta formado por:






Exponente

  • Es modificado antes de su almacenamiento
  • El numero a almacenar en la posición del exponente sera igual a e = e + 2^m-1 - 1
  • e = exponente verdadero
  • M = numero de bits del exponente
  • Se usa para no usar el bit de signo.



Mantisa

  • debe cumplir con la condición 1 = mantisa &lt; 2
  • La parte entera sera siempre 1
  • Solo se guarda al numero la parte decimal derecha.



Signo

  • La mantisa se guarda siembre en valor absoluto
  • Solo el bit signo identifica
  • 1-Negativo
  • 0-Positivo



Tipos
Short Real Number



Long Real Number


10-Byte Real Number




Podemos concluir que entre mas mantisa de parte decimal tenga, tenemos una mejor precisión de nuestro punto flotante.
Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.



Punteros (Lab)

Los punteros son variables de tipo dinámico que apuntan a una dirección de memoria de otra variable, por lo cual tenemos acceso a ella.
Declaración de un puntero
tipo de variable *nombre-puntero;


int *rober;
double *ramon;
char *cecy;


Cuando ponemos estas declaraciones decimos al compilador que le "haga espacio" a la dirección de una variables según su tipo, con la cual lo tendrá el nombre que le pusimos al puntero.


por ejemplo
int rober; //declaro y hago memoria a una variable entera
int *puntero_de_rober;  //puntero
puntero_de_rober = &rober;  // se escribe la direccion de 
//memoria donde esta la variable rober


por si no lo sabían :P cuando ponemos &rober; implica que es la dirección de la variable.


Podemos decir esquemáticamente que cada variable tiene esto:


rober
  • Dirección de rober XXXX
  • posicion de memoria ocupada por puntero_de_rober YYYY
  • valor contenido de rober
  • posicion de memoria ocupada por rober XXXX
  • implicitamente tambien el tamaño en bytes de la variable
El símbolo & dirección, puede aplicarse en variables, funciones, menos en constantes o expresiones porque estas no tienen una posición asignada.


La operación inversa de la asignación de un puntero, se puede utilizar para saber cual es el valor de la variable apuntada ejemplo:


x = rober;
x = *puntero_de_rober;

printf("%d", rober );
printf("%d", *puntero_de_rober);


Otro ejemplo


#include < stdio.h >
int main(int argc, char** args){
    char hola; //variable caracter
    char *phola; //puntero a variable
    phola = &hola; //se asigna al puntero la direccion

    for(hola ='a'; hola <='z'; hola++)
       printf("%c", *phola); //imprime el valor de la 
                            //variable apuntada
    
    return 0;
}


El for incrementa el valor de la variable, después para imprimir utilizamos el puntero, el programa imprimiría lo mismo (el abecedario) si lo escribiéramos printf("%c", hola);


Link de donde saque esta información aqui
Espero que mi explicación les sirva, si tienen algún comentario acerca de esta entrada, espero me digan ya que estoy abierto a cualquier error.