Lo que hice fue descomprimir el paquete y ver los archivos que traía. Me di cuenta que dentro estaba organizado en las carpetas donde iba en el sistema operativo. Solo coloque los archivos donde estaban en el paquete y actualice las librerias que me faltaban. Aquí les dejo un How-To para que se les sea mas fácil.

1- Descargar la version actual de la pagina de Google. (http://dev.chromium.org/getting-involved/dev-channel)

2- Descomprimir el paquete .deb, solo vas a necesitar el archivo que se llama data.tar.lzma, los demas los puedes borrar.

3- Buscar dentro del archivo data.tar.lzma una carpeta llamada “.“, la cual dentro tiene 3 carpetas (etc, opt, usr).

4- Descomprimir estas carpetas en sus respectivos lugares en el Filesystem, osea, el contenido de la carpeta etc en /etc, el de opt en /opt y el de usr en /usr.

5- Descargar las librerias faltantes. (http://chromium.googlecode.com/issues/attachment?aid=4895306054695780390&name=chrome-fix.tar.gz) ** Solo si no puedes correr el browser con el comando “google-chrome” en una terminal. **

6- Si tuviste que descargar las librerias, descomprime el paquete chrome-fix.tar.gz en /opt/google/chrome/ y ejecuta el comando su sh launch-chrome.sh y estas listo.

7- Si bajaste el plugin de Flash o cualquier otro, el comando para abrir Chrome con estos instalados es google-chrome –enable-plugins .

#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
typedef struct {string nombre; string apellido; int cuenta; float balance;} Client;

int Buscar (string nombre, string apellido, Client clientes[], int cuentas )
{ while(cuentas>=0)
{if (clientes[cuentas].nombre==nombre && clientes[cuentas].apellido==apellido)
{return cuentas;}
cuentas–-;
}
return -1;
}

int id(Client clientes[], int& cuentas)
{string nombre, apellido;
cout<<”\nNuevo cliente\n”;
cout<<”\n Nombre:\t”;
cin>>nombre;
cout<<” Apellido:\t”;
cin>>apellido;
if(Buscar(nombre, apellido, clientes, cuentas) >= 0)
{cout<<”\n ** Este cliente ya existe **\n”;
return 0;}
clientes[cuentas].nombre = nombre;
clientes[cuentas].apellido = apellido;
clientes[cuentas].cuenta = cuentas;
cout <<” Cuenta #:\t”<<clientes[cuentas].cuenta<<”\n”;
clientes[cuentas].balance = 0.0;
cout <<” Balance:\t$”<<clientes[cuentas].balance<<”\n”;
cuentas++;
return 1;
}

int Busqueda(Client clientes[], int cuentas)
{ int e;
string nombre, apellido;
cout<<”\nBusqueda de estudiante:\n”;
cout<<”\n Nombre:\t”;
cin>>nombre;
cout<<” Apellido:\t”;
cin>>apellido;
e=Buscar(nombre, apellido, clientes, cuentas);
if(e==-1)
{cout<<”\n ** No se encuentra el cliente **\n”;
return -1;}
cout<<” Cuenta #:\t”<<clientes[e].cuenta<<”\n”;
cout<<” Balance:\t$”<<clientes[e].balance<<”\n”;
return e;
}

void Print(Client clientes[], int cuentas)
{
cout<<”\n Nombre:\t”<<clientes[cuentas].nombre<<”\n”;
cout<<” Apellido:\t”<<clientes[cuentas].apellido<<”\n”;
cout<<” Cuenta #:\t”<<clientes[cuentas].cuenta<<”\n”;
cout<<” Balance:\t$”<<clientes[cuentas].balance<<”\n”;
}

int main(int argc, char *argv[])
{
Client clientes[500];
char y;
int x;
int cuentas=0;

while(!0){
cout<<”\n\n\t1)Nuevo cliente\n\t2)Buscar cliente\n\t0)Salir\n”;
cout<<”>”;
cin>>x;

if(x==0)
break;

switch(x){
case (1):
id(clientes, cuentas);
cuentas++;
break;
case (2):
int e;
float money;
e = Busqueda(clientes, cuentas);
if ( e == -1)
break;
cout << “\n\t1)Depositar\n\t2)Retirar\n\t0)Salir\n–> “;
cin >> y;
switch (y){
case 1:
cout << “\n Cantidad a depositar: “;
cin >> money;
clientes[e].balance += money;
Print(clientes,e);
break;
case 2:
cout << “\n Cantidad a retirar: “;
cin >> money;
if(money > clientes[e].balance)
{ cout << “\n ** No hay balance suficiente **\n”;
break; }
clientes[e].balance -= money;
Print(clientes,e);
break;
case 0:
break;
default:
cout << “\n\n ** Opcion no valida \n**”;
}
break;
default:
cout << “\n\n Opcion No Valida\n”;
break; } }
return EXIT_SUCCESS;
}

#include <cstdlib>
#include <iostream>

using namespace std;

int Venta(int sits[],int precio[], int x, int& venta)
{
int cantidad, total;
cout<<”\n Cantidad de taquillas: “;
cin>>cantidad;
if ( cantidad > sits[x])
{ cout<<”\n ** No hay suficientes taquillas **\n”;
return -1; }
sits[x] -= cantidad;
total = cantidad * precio[x];
venta += total;
return cantidad;
}

int main(int argc, char *argv[])
{
int sits[4];
int precio[4];
int e, ventas = 0;
int x;

sits[0] = 50; sits[1] = 100; sits[2] = 250; sits[3] = 65;
precio[0] = 1500; precio[1] = 900; precio[2] = 500; precio[3] = 100;

while(!0){

cout<<”\n Asientos Disponibles/Precios\n\n”;
cout<<” V.I.P.:\t”<< sits[0]<<” / $”<< precio[0]<< “\n”;
cout<<” Palco:\t”<< sits[1]<<” / $”<< precio[1]<< “\n”;
cout<<” Grada:\t”<< sits[2]<<” / $”<< precio[2]<< “\n”;
cout<<” Blicher:\t”<< sits[3]<<” / $”<< precio[3]<< “\n”;
cout<<”\n Total de Ventas:\t$”<< ventas<< “\n”;
cout<<”—————————–”;

cout << “\n\n Venta de Tickets\n\n\t1)V.I.P.\n\t2)Palco\n\t3)Grada\n\t4)Blicher\n\t0)Salir\n”;
cout << “>”;
cin >> x;

if(x == 0)
break;

switch(x){
case (1):
e=Venta(sits, precio, 0, ventas);
if (e==-1)
break;
cout<<”\n “<<e<<” taquillas V.I.P.\tTotal: $”<<e * precio[0]<< “\n”;
break;
case (2):
e=Venta(sits, precio, 1, ventas);
if (e==-1)
break;
cout<<”\n “<<e<<” taquillas Palco\tTotal: $”<<e * precio[1]<<”\n”;
break;
case (3):
e=Venta(sits, precio, 2, ventas);
if ( e==-1)
break;
cout<<”\n “<<e<<” taquillas Grada\tTotal: $”<<e * precio[2]<<”\n”;
break;
case (4):
e=Venta(sits, precio, 3, ventas);
if ( e == -1)
break;
cout<<”\n “<<e<<” taquillas Blicher\tTotal: $”<<e * precio[3]<<”\n”;
break;
default:
cout<<”\n\n Opcion No Valida\n”;
break; }
}
return EXIT_SUCCESS;
}

#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
typedef struct {string nombre; string apellido; int Esp; int Mat; int Soc; int Cn; int Ing; int Cleto;} Alumno;
int Buscar (string nombre, string apellido, Alumno Est[], int y )// La idea es de Danny.
{
while(y>=0)
{
if (Est[y].nombre==nombre && Est[y].apellido==apellido)
{return y;}
y–;
}
return -1;
}
int RegAlum (Alumno Est[], int& y)
{
int e;
string nombre, apellido;
cout<<”\n Nombre:\t”;
cin>>nombre;
cout<<” Apellido:\t”;
cin>>apellido;
e=Buscar(nombre, apellido, Est, y);
if(e>=0)
{cout<<”\n ** Este alumno ya existe **\n”;
return 0;}
Est[y].nombre = nombre;
Est[y].apellido = apellido;
y++;
return 1;
}

int InsNota (string nombre, string apellido, Alumno Est[], int y)
{
int e;
e=Buscar(nombre,apellido,Est,y);
if (e==-1){cout<<”\n** No se encuentra el estudiante. **\n\n\n”;return 1;}
cout<<”\nInserte la nota de Espanol:”;
cin>>Est[e].Esp;
cout<<”Inserte la nota de Matematicas:”;
cin>>Est[e].Mat;
cout<<”Inserte la nota de Ciencias Sociales:”;
cin>>Est[e].Soc;
cout<<”Inserte la nota de Ciencias Naturales:”;
cin>>Est[e].Cn;
cout<<”Inserte la nota de Ingles:”;
cin>>Est[e].Ing;
cout<<”Inserte la nota de en las Materias de Cleto:”;
cin>>Est[e].Cleto;
return 0;
}
int Imp (string nombre, string apellido, Alumno Est[], int y)
{
int e;
e=Buscar(nombre,apellido,Est,y);
if (e==-1){cout<<”\n ** No se encuentra el estudiante. **\n”;return 1;}
//cout<<”\nNombre: “<<Est[e].nombre<<”\n”;
//cout<<”Apellido: “<<Est[e].apellido<<”\n”;
cout<<”\nNota en Espanol: “<<Est[e].Esp<<”\n”;
cout<<”Nota en Matematica: “<<Est[e].Mat<<”\n”;
cout<<”Nota en Ciencias Sociales: “<<Est[e].Soc<<”\n”;
cout<<”Nota en Ciencias Naturales: “<<Est[e].Cn<<”\n”;
cout<<”Nota en Ingles: “<<Est[e].Ing<<”\n”;
cout<<”Nota en las Materias de Cleto: “<<Est[e].Cleto<<”\n”;
return 0;
}

int main(int argc, char *argv[])
{
Alumno Est[1000];

string nombre,apellido;
int x=!0,y=0;
while (x!=0)
{
cout<<”\n\nPresione la opcion deseada:\n\n\t1)Nuevo Alumno\n\t2)Buscar Alumno\n\t3)Ingreso de notas\n\t0)Salir\n”;
cout<<”>”;
cin>>x;

switch(x)
{
case (1):RegAlum(Est, y);break;
case (2):
cout<<”Ingrese el Nombre del Estudiante:”;
cin>>nombre;
cout<<”Ingrese el Apellido del Estudiante:”;
cin>>apellido;
Imp (nombre,apellido,Est,y);break;
case (3):
cout<<”Ingrese el Nombre del Estudiante:”;
cin>>nombre;
cout<<”Ingrese el Apellido del Estudiante:”;
cin>>apellido;
InsNota (nombre,apellido,Est,y);break;
default: cout<<”** Opcion Incorrecta **”;break;

}
}
return EXIT_SUCCESS;
}

Los demás tipos se basan en alguno de estos tipos básicos. El tamaño y el rango de estos tipos de datos varían con cada tipo de procesador y con la implementación del compilador de C.

Código en C.

#include <stdio.h>
#include <stdlib.h>
//Función que Calcula el Factorial.
double fac (int n)
{
int i = 1;
double r;
double f=1;
while (i<=n)
{
r=((f)*(i));
f=r;
i++;
}
return f;
}
// Función que crea el Triángulo de Pascal. Recibe el número de filas
// que desea que tenga el triángulo.
void pasc (int n)
{
int i=0,j=0;
double x;
while (i<n)
{ j=0;
while (j<=i)
{
x=0.0;
x=fac(i)/(fac(j)*fac(i-j));
printf(“%g “,x);
j++;
}
printf(“\n”);
i++;
}

}
// Función que recive el numero de filas por la linea comando.
int main(int argc, char *argv[])
{
int num = atoi (argv[1]);
pasc(num);
return 0;
}

Para conseguir el programa máquina real se debe utilizar un programa llamado montador o enlazador (linker). El proceso de montaje conduce a un programa en enguaje máquina directamente ejecutable. Existen diversas fases de compilación o también llamadas etapas de la compilación:

1. Programa Fuente
2. Compilador
3. Programa Objeto
4. Linker
5. Ejecutable en Lenguaje Máquina

Programa fuente: Programa escrito en un lenguaje de alto nivel (texto ordinario que contiene las sentencias del programa en un lenguaje de programación). Necesita ser traducido a código máquina para poder ser ejecutado.

Compilador: Programa encargado de traducir los programas fuentes escritos en un lenguaje de alto nivel a lenguaje máquina y de comprobar que las llamadas a las funciones de librería se realizan correctamente.

Programa (o código) objeto: Es el programa fuente traducido (por el compilador) a código máquina. Aún no es directamente ejecutable.

Linker (montador o enlazador): Es el programa encargado de insertar al programa objeto el código máquina de las funciones de las librerías (archivos de biblioteca) usadas en el programa y realizar el proceso de montaje, que producirá un programa ejecutable .exe. Las librerias son una colección de código (funciones) ya programado y traducido a código máquina, listo para utilizar en un programa y que facilita la labor del programador.

Programa Ejecutable: Traducción completa a código máquina, realizada por el enlazador, del programa fuente y que ya es directamente ejecutable.

Características generales del compilador de C.

• El lenguaje C es un lenguaje muy potente y eficiente de nivel medio: combina elementos de lenguajes de alto nivel con la funcionalidad del lenguaje ensamblador. Es adecuado para la programación de sistemas.
• Es un lenguaje de propósito general (puede utilizarse para desarrollar sistemas operativos, gestores de bases de datos, etc).
• El código de C es muy portable: se puede adaptar el software escrito para un tipo de computadora a otra computadora sin hacer muchos cambios.
• El lenguaje C es un lenguaje estructurado: permite seccionar y esconder (mediante subrutinas y variables locales) del resto del programa toda la información e instrucciones necesarias para realizar una determinada tarea.
• El lenguaje C sólo tiene 32 palabras clave, (BASIC por ejemplo tiene 159).
• Suele incluir potentes librerías de funciones que aumentan su potencia.
• El lenguaje C es compilado, no interpretado. Un intérprete lee el código fuente de un programa línea a línea y las traduce online para que la CPU las pueda interpretar, pero no genera ningún programa objeto. Un compilador lee el programa entero, lo traduce y genera un código objeto directamente ejecutable y entendible por el microprocesador.

• Desarrollar un Modelo
• Construir una Lista Global de los Rasgos
• Planear por Rasgo
• Diseñar por Rasgo
• Construir por Rasgo

Los últimos dos se hacen en cada iteración. Cada proceso se divide en tareas y se da un criterio de comprobación. Los desarrolladores entran en dos tipos:

• Dueños de clases
• Programadores jefe

Los programadores jefe son los desarrolladores más experimentados. A ellos se les asignan rasgos a construir. Sin embargo ellos no los construyen solos. Sólo identifican qué clases se involucran en la implantación de un rasgo y juntan a los dueños de dichas clases para que formen un equipo para desarrollar ese rasgo. El programador jefe actúa como el coordinador, diseñador líder y mentor, mientras los dueños de clases hacen gran parte de la codificación del rasgo.

http://www.featuredrivendevelopment.com

El análisis de sistemas implica determinar las necesidades del cliente y /o usuario para poder especificar los requerimientos que sirvan como base para el desarrollo de un sistema o software siendo el “que” de un sistema informático.

En el análisis y diseño de sistemas se utiliza la metodología de lenguaje de modelado unificado (UML), técnica de recopilación de información y de especificación de requerimientos.

El proceso de desarrollo de software requiere por un lado un conjunto de conceptos, una metodología y un lenguaje propio. A este proceso también se le llama el ciclo de vida del software que comprende cuatro grandes fases: concepción, elaboración, construcción y transición. La concepción define le alcance del proyecto y desarrolla un caso de negocio. La elaboración define un plan del proyecto, especifica las características y fundamenta la arquitectura. La construcción crea el producto y la transición transfiere el producto a los usuarios.

Actualmente se encuentra en una etapa de madurez el enfoque Orientado a Objetos (OO) como paradigma del desarrollo de sistemas de información. El Object Management Group (OMG) es un consorcio a nivel internacional que integra a los principales representantes de la industria de la tecnología de información OO. El OMG tiene como objetivo central la promoción, fortalecimiento e impulso de la industria OO. El OMG propone y adopta por consenso especificaciones entorno a la tecnología OO. Una de las especificaciones más importantes es la adopción en 1998 del Lenguaje de Modelado Unificado o UML (del inglés Unified Modeling Language) como un estándar, que junto con el Proceso Unificado están consolidando la tecnología OO.