Instalar Google Chrome en Fedora 11

Esto solo lo he probado en Fedora 11, no se si funciona en las demás distribuciones que no están basadas en Debian. En la actualidad Google nos brinda una version Alpha de su bowser en linux, pero la distribuye en un paquete para distribuciones basadas en Debian, como Ubuntu. Buscando en internet encontré algunos foros que te ayudaban a instalar este paquete en cualquier distribución, tambien sugerían utilizar herramientas para convertir el paquete para poder ser usado.

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 .

Programa del Banco

Código en C++

#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;
}

Programa de Tickets

Código en C++

#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;
}

Programa de Notas

Código en C++

#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;
}

Tamaños de los Tipos de Datos por Plataformas

Cuando en C, se dice que un objeto es de un tipo, se quiere decir que ese objeto pertenece a un conjunto específico de valores con los cuales se pueden realizar un conjunto de operaciones también determinadas. Existen cinco tipos básicos: carácter, entero, coma flotante, coma flotante de doble precisión y void.

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.

Type	Size	Range
Integral Types
short int , or signed short int	16 bits	-32768 to 32767
unsigned short int	16 bits	0 to 65535
int or signed int	32 bits	-2147483648 to 2147483647
unsigned int	32 bits	0 to 4294967295
long int , or signed long int (OpenVMS)	32 bits	- 2147483648 to 2147483647
long int , or signed long int (Digital UNIX)	64 bits	- 9223372036854775808 to 9223372036854775807
unsigned long int (OpenVMS)	32 bits	0 to 4294967295
unsigned long int (Digital UNIX)	64 bits	0 to 18446744073709551615
signed __int64 (Alpha)	64 bits	-9223372036854775808 to 9223372036854775807
unsigned __int64 (Alpha)	64 bits	0 to 18446744073709551615
Integral Character Types
char and signed char	8 bits	-128 to 127
unsigned char	8 bits	0 to 255
wchar_t	32 bits	0 to 4294967295
Floating- Point Types (range is for absolute value)
float	32 bits	1.1 x 10 -38 to 3.4 x 10 38
double	64 bits	2.2 x 10 -308 to 1.7 x 10 308
long double (OpenVMS Alpha)	128 bits	3.4 x 10 -49321 to 1.2 x 10 49321
long double (OpenVMS VAX, Digital UNIX)	Same as double	Same as double

Triángulo de Pascal en C.

Se construye de la siguiente manera: Se empieza por el “1″ de la cumbre. De una línea a la siguiente se conviene escribir los números con un desfase de media casilla. Así, las casillas (que no se dibujan) tendrán cada una dos casillas justo encima, en la línea anterior. El valor que se escribe en una casilla es la suma de los valores de las dos casillas encima de ella. El valor cero no se escribe. Por ejemplo, en la última línea dibujada, el cuarto valor es 84 = 28 + 56, suma del tercer y cuarto valor de la línea anterior. Se observa, y no es difícil demostrarlo, que la capa exterior está formada de unos, la segunda capa de los naturales en orden creciente, que los números no hacen más que subir de una línea a la siguiente y que existe un eje de simetría vertical que pasa por el vértice.

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;
}

Fases o Etapas de la Compilación

La compilación es el proceso de traducción de programas fuente a programas objeto. El programa objeto obtenido de la compilación ha sido traducido normalmente al código común del lenguaje de máquina.

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.

Desarrollo Manejado por Rasgos (FDD)

El Desarrollo Manejado por Rasgos (FDD por su sigla en inglés de Feature-Driven Development) fue desarrollado por Jeff De Luca y el viejo gurú de la Orientación a Objetos Peter Coad. Como las otras metodologías adaptables, se enfoca en iteraciones cortas que entregan funcionalidad tangible. En el caso del FDD las iteraciones duran dos semanas. El FDD tiene cinco procesos. Los primeros tres se hacen al principio del proyecto.

• 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

Análisis y Diseño

El análisis y diseño es el proceso previo a la codificación de un sistema. En el análisis se determinan los requerimientos de lo que el sistema debe hacer; en el diseño se bosquejan los detalles de la solución. Para esto, se recopilan y analizan los elementos para entender el problema y representarlo de alguna manera, plasmando las ideas, objetivos, metas y actores que intervienen en el proyecto. El diseño es un espejo del análisis que ya se aterriza en la arquitectura, plataforma y componentes. El análisis y diseño se documenta de acuerdo con la metodología seleccionada.

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.

Ingeniería de Software

El proceso de ingeniería de software se define como “un conjunto de etapas parcialmente ordenadas con la intención de logra un objetivo, en este caso, la obtención de un producto de software de calidad” [Jacobson 1998]. El proceso de desarrollo de software “es aquel en que las necesidades del usuario son traducidas en requerimientos de software, estos requerimientos transformados en diseño y el diseño implementado en código, el código es probado, documentado y certificado para su uso operativo”. Concretamente “define quién está haciendo qué, cuándo hacerlo y cómo alcanzar un cierto objetivo” [Jacobson 1998].

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.