Ayudas para el desarrollo de programas

Vladimir Támara Patiño

2006. Dominio público.

Capítulo 1  Repaso de C, C++, PHP y Java

• LOGRO: Repasa conceptos de lenguajes imperativos
• LOGRO: Realiza programas en C, C++, PHP o Java

1.1  Introducción a tipos, expresiones y asignaciones

• INDICADOR: Define estado, conoce el esquema de ejecución de un programa en un lenguaje imperativo
• INDICADOR: Repasa tipos en C, C++, PHP y Java
• INDICADOR: Repasa expresiones
• INDICADOR: Repasa asignación

1.1.1  Un programa de ejemplo

C

#include <stdio.h>
    
int
main(int argc, char *argv[])
{  
  int k;
  printf("Por favor ingrese un número: ");
  scanf("%i",&k);
  k=k+1;
  printf("El sucesor del número que ingresó es: %i",k);
}

$ cc -c lee-esc-ent.c
$ cc -o lee-esc-ent-C lee-esc-ent.o
$ ./lee-esc-ent-C

C++

#include <iostream>
using namespace std;
    
int
main()
{  
        int k;
        cout << "Por favor ingrese un número: ";
        cin >> k;
        k=k+1;
        cout << "El sucesor del número que ingresó es: " << k << "\n";
 return 0;
}

$ c++ -c lee-esc-ent.cpp 
$ c++ -o lee-esc-ent-CPP lee-esc-ent.o
$ ./lee-esc-ent-CPP

PHP

Por favor ingrese un número:
<?php
        fscanf(STDIN, "%d\n", $k);
        $k=$k+1;
        echo "El sucesor del número que ingresó es: $k\n";
?>

$ php lee-esc-ent.php

Java

import java.io.*;

public class LeeEscEnt {
        public static void main(String args[]) {
                int k;

                System.out.print("Por favor ingrese un número: ");

                try {   
                        k=leeEntero();
                        k=k+1;
                        System.out.println("El sucesor es: "+k);
                }
                catch (IOException ioe) {
                        System.out.println("Error de E/S: " + ioe);
                }
        }

        static int leeEntero() throws IOException {
                int n=0;
                int sgn=1;

                int l=System.in.read();

                while(l!= -1 && (char)l==' ') {
                        l=System.in.read();
                }
                if (l=='-') {
                        sgn=-1;
                } else if (l=='+') {
                        sgn=1;
                }

                while(l != -1 &&  (char)l>='0' && (char)l<='9') {
                        n=n*10+(l-(int)'0');
                        l=System.in.read();
                }

                return n*sgn;
        }

}

$ export PATH=$PATH:/usr/local/jdk1.3.1-linux/bin/
$ javac LeeEscEnt.java
$ java LeeEscEnt

Sobre la compilación y ejecución

1.1.2  Tipos básicos

---

Tipo	C99	C++	PHP	Java
Booleanos	bool	bool	(bool) o (boolean)	boolean
Caracter	char			char
Enteros	small, int, long,	los mismos de C	(int) o (integer)	byte, short, int,
	long long			long, char
Punto flotante	float, double	float, double	(float)	float, double
Cadena	char *	char *, string	(string)	String

---

#include <stdbool.h>

1.1.3  Introducción a la declaración de variables

int i;
int j=3, k;

$i=3;
$i=$i+2.5;
$i="1"+$i;
$i="x";

1.1.4  Introducción a la asignación

1.1.5  Lecturas recomendadas

1.1.6  Ejercicios para afianzar teoría

1. Construya tablas de precedencia de operadores para tipos enteros en los 4 lenguajes (los de C y C++ son los mismos).
   
   
2. Construya tablas de precedencia de operadores para tipos booleanos en los 4 lenguajes.
   
   
3. Hay operadores de incremento prefijos y posfijos en los 4 lenguajes, ¿como es la sintaxis y cual es la diferencia entre ellos?x.

1.1.7  Ejercicios de programación

1. Implemente y ejecute en cada uno de los 4 lenguajes un programa que solicite al usuario 2 valores enteros y presenta la suma, la resta, la multiplicación, el cociente del primero entre el segundo y el residuo.

1.2  Introducción a estructuras de control

• INDICADOR: Maneja condicionales en C, C++, PHP y Java
• INDICADOR: Emplea y entiende ciclos en C, C++, PHP y Java

1.2.1  Condicionales

if (exprb) {
     bloque
}

if (exprb) :
     bloque
endif

if (exprb) {
     bloque₁
} else {
     bloque₂
}

if (exprb) :
     bloque₁
else :      bloque₂
endif

if (exprb₁) :
     bloque₁
elseif (exprb₂) :
     bloque₂
else :
     bloque₃
endif

---

Tipo de operador	Sintaxis	Asociatividad
Relacionales	expr1 < expr2	na
	expr1 > expr2
	expr1 <= expr2
	expr1 >= expr2
Igualdad	expr1 == expr2	na
	expr1 != expr2
	expr1 === expr2
	expr1 !== expr2
Conjunción (y)	exprb1 && exrpb2	Izquierda a derecha
Disyunción (o)	exprb1 || exrpb2	Izquierda a derecha

---

"3" == 3
"3" === 3

switch (expr) {
   case const₁:
     bloque₁
   case const₂:
     bloque₂
   ···
   case const_n:
     bloque_n
   default:
     bloque_n+1
}

1.2.2  Ciclos

while (exprb) {
     bloque
}

while (exprb) :
     bloque
endwhile

for (inst₁; exprb; inst₂) {
     bloque
}

for (inst₁; exprb; inst₂) :
     bloque
endfor

do {
     bloque
} while (exprb);

Alteraciones al control de flujo

• break que obliga una salida del ciclo.
• continue que obliga a un salto a la guarda del ciclo. En PHP a continuación de continue puede ponerse un número que indica la cantidad de ciclos que deben saltarse.

1.2.3  Lecturas recomendadas

1.2.4  Ejercicios para afianzar teoría

1. Que imprimirá cada una de las siguientes porciones de código cuando se ejecuten:

   •   while (1)
              printf("B");
       printf("C");
     

   • while (1) {
              printf("B");
       printf("C"); }
     

   •   while (0)  
              printf("B");
       printf("C");
     

   •   while (0) {
              printf("B");
       printf("C"); }
     

1.2.5  Ejercicios de programación

1. Escriba en C++ un programa que pida al usuario un entero e imprima la tabla de multiplicar de ese entero (es decir el resultado de multiplicar ese entero por los números de 1 a 10).
   
   
2. Escriba un programa en C que pregunte enteros al usuario hasta que él/ella introduzca el entero 5, después el programa debe presentar la suma de todos los enteros digitados (excepto el 5).
   
   
3. Desde un interprete de comandos ejecute el programa arithmetic y observe la funcionalidad, después implemente su propia versión de ese programa en el lenguaje de programación que prefiera. Ayuda: En C y C++ puede generarse un número aleatorio entre 0 y 10, incluyendo al comienzo #include <stdlib.h> y empleando la expresión rand()%11. En PHP use rand(0,10). En Java lo mismo se logra importando al comienzo import java.lang.* y usando Math.round(Math.random()*11). Otra opción es implementar (en su lenguaje de programación) las siguientes funciones sugeridas en [3]:

   static unsigned long int next = 1;
   
   int rand(void)   // RAND_MAX assumed to be 32767
   {
          next = next * 1103515245 + 12345;
          return (unsigned int)(next/65536) % 32768;
   }
   
   void srand(unsigned int seed)
   {
          next = seed;
   }
   

1.3  Vectores y funciones

• INDICADOR: Emplea vectores y apuntadores
• INDICADOR: Emplea y define funciones

1.3.1  Arreglos

int v[20];

v[3]=4;
printf("%i",v[19]);

$v[3]=4;
$v['casa']='carro';
print_r($v);

int c[10][4][8];

v[20]=4;

float af[3]={2.4, -3.2, 11.0};

$af = array( 'a' => 'abeja', 'd' => 'danta', 'e' => 'elefante');

$af = array( 1, 3, 10, 17);

Uso de arreglos multidimensional en C y C++

int m[3][3]={{1,2,3}, {4,5,6}, {7,8,9}};

m[0][0]=11;
m[2][1]=15;

int m[9]={1,2,3, 4,5,6, 7,8,9};

m[0*3+0]=11;
m[2*3+1]=15;

double saca(double mat[][5], int i, int j) {
 /* PRE: 0<=i, 0<=j<=4, mat[i][j] está localizado */
 return mat[i][j];
}

double saca_2(double mat[], int m, int n, int i, int j) {
  /* PRE: 0<=i<=m, 0<=j<=n mat tiene al menos m*n posiciones */
 return m[i*n+j];
}

Uso de arreglos en PHP

1. foreach($af as $v) {
     echo "$v, ";
   }
   

   Recorre todas las posiciones del arreglo $af y en cada iteración asigna a $v el valor de una posición del vector $af. De forma que si el vector $af es 'x' => 1, 'y' => 2, 'z' => 'm' presentará 1, 2, m,
   
   

2. foreach($af as $i => $v) {
     echo "$i ~ $v, ";
   }
   

   Recorre todas las posiciones del arreglo $af, en cada iteración asigna a $k la llave y a $v el valor de una posición del vector $af. Con el vector del ejemplo anterior la salida sería

   x~1, y~2, z~m
   

list($a, $b, $c)=$af;

$af[]='caiman';

list($indice, $valor)=each($af);

1.3.2  Funciones

import java.io.*;

public class SimpMain {

        public static void main(String args[]) {
                int i;
                System.out.println("Cantidad de argumentos ="+args.length);
                for (i=0; i<args.length; i++) {
                        System.out.println("args["+i+"]="+args[i]);
                }
        }
}

#include <iostream>

int 
main(int argc, char *argv[]) {
        int i;
        cout << "argc=" << argc << "\n";
 cout << "sizeof(argv)/sizeof(argv[0])=" << sizeof(argv)/sizeof(argv[0]) << "\n";
        for (i=0; i<argc; i++) {
                cout << "argv[" << i << "]=" << argv[i] << "\n";
        }
        return 0;
}

<?php
echo "argc=$argc\n";
        foreach($argv as $k => $v) {
                echo "argv[$k]=$v\n";
        }
?>

1.3.3  Lecturas recomendadas

1.3.4  Ejercicios para afianzar teoría

1. Revise la documentación del programa /usr/games/banner típico en sistemas tipo Unix, úselo y después revise las fuentes de ese programa en su implementación para OpenBSD (En un sistema OpenBSD las fuentes pueden estar en /usr/src/games/banner). ¿Para que son las opciones -d y -t que este programa puede recibir por línea de comandos? ¿Para que son los enteros del arreglo asc_ptr ?
   
   
2. Busque en Internet un programa corto en Java que emplee arreglos y en el que se defina al menos dos funciones y expliquelo.

1.3.5  Ejercicios de programación

1. En el lenguaje que prefiera haga una función que reciba como parámetros un vector vec, su longitud lvec y un entero n, y retorne la cantidad de veces que n aparece en vec.
   
   
2. En el lenguaje que prefiera haga una función que reciba como parámetros dos vectores de caracteres junto con sus longitudes y retorne 1 si ambos vectores son iguales o cero si no lo son.

1.4  Retomando detalles de expresiones

• INDICADOR: Reconoce y emplea expresiones

1.4.1  Comentarios

1.4.2  Conversión de tipos

Tipos en C, C++ y Java

Tipos en PHP

1.4.3  Más sobre expresiones

• Usar espacios antes y después de operandos.
• Usar una forma natural para las expresiones.
• Emplear paréntesis para resolver ambigüedad.
• Dividir expresiones complejas.
• Tener cuidado con los efectos laterales (en expresiones con operadores de asignación o llamadas a funciones).

Enteros

---

Lenguaje	Constante	Equivale a
Todos	014	(int)12
Todos	0x12	(int)18
C y C++	20u	(unsigned int)20
C y C++	100ul	(unsigned long int)100

---

---

Significado	Java	C y C++
Máximo entero	Integer.MAX_VALUE	INT_MAX
Mínimo entero	Integer.MIN_VALUE	INT_MIN
Máximo entero largo	Long.MAX_VALUE	LONG_MAX
Mínimo entero largo	Long.MIN_VALUE	LONG_MIN

---

Números de punto flotante

• .5
• -0.3e-3
• 3e4

---

Significado	Java	C y C++
Máximo flotante	Float.MAX_VALUE	FLT_MAX
Mínimo valor positivo flotante	Float.MIN_VALUE	FLT_MIN
Máximo double	Double.MAX_VALUE	DBL_MAX
Mínimo valor positivo double	Double.MIN_VALUE	DBL_MIN

---

Caracteres

---

Secuencia de escape	Significado	ASCII
\b	espacio atrás (BS)	8
\t	tabulador	9
\n	Cambio de línea (Line Feed, LF)	10
\r	Retorno de carro (Carriage Return, CR)	13
\f	Cambio de página (Form Feed FF)	12
\"	Comilla (útil en cadenas)	34
\'	Apostrofe (útil en caracteres)	39
\\	Backslash	92

---

---

Secuencia de escape	Significado	ASCII
\v	tabulador vertical	11
\a	Alerta audible o visual	7
\?	Interrogante	63

---

Cadenas

"Dios es " "amor"

Otros operadores

• -e₁ Inverso aditivo.
• e₁ * e₂ Multiplicación.
• e₁ / e₂ División de e₁ entre e₂. Si ambos operandos son enteros da el cociente entero, si alguno es flotante da la división en flotantes. Si e₂ es cero en C y C++ el comportamiento varia de una plataforma a otra, en Java si es división entera genera la excepción ArithmeticException, pero si es división flotante puede dar NaN o infinito (bien positivo o bien negativo).
• e₁ % e₂ Residuo de la división entre e₁ y e₂, en el caso de C y C++ ambos deben ser enteros y el comportamiento si e₂ es 0 depende de la plataforma. Debe darse igualdad entre e₁ /e₂*e₂ + e₁% e₂ y e₁. En Java si e₁ y e₂ son enteros y e₂ es cero genera la excepción ArithmeticException, en Java también opera entre flotantes.
• e₁ + e₂ Suma.
• e₁ - e₂ Resta.

• ~e₁ negación de los bits de e1, por ejemplo la negación del número binario 110010 es 001101.
• e₁ << e₂ corre bits de e₁ a la izquierda e₂ posiciones. Introduce ceros. Corresponde a multiplicar e₁ por 2^e₂. Por ejemplo 39 << 2 equivale a correr 100111 2 bits a la izquierda para obtener 10011100 que en decimal es 156.
• e₁ >> e₂ corre bits de e₁ a la derecha e₂ posiciones. Si e₁ es positivo corresponde al cociente de dividir e₁ entre 2^e₂13. Por ejemplo (unsigend char)39 >> 2 corresponde a correr 00100111 dos bits a la derecha es decir 00001001 que en decimal es 9.
• e₁ & e₂ realiza conjunción (y) entre bits de e₁ y de e₂. Por ejemplo la conjunción entre los números binarios 100111 y 110010 es 100010.
• e₁ ^ e₂ realiza disyunción exclusiva (o exclusivo, xor) entre bits de e₁ y de e₂. Por ejemplo la disyunción exclusiva entre los números binarios 100111 y 110010 es 010101.
• e₁ | e₂ realiza disyunción (o) entre bits de e₁ y de e₂. Por ejemplo la disyunción entre los números binarios 100111 y 110010 es 110111.

1.4.4  Más sobre asignación

int k;
printf("%d\n",(k=3));

---

Operador	Equivale a
e1 *= e2	e1 = (e1) * (e2)
e1 /= e2	e1 = (e1) / (e2)
e1 %= e2	e1 = (e1) % (e2)
e1 += e2	e1 = (e1) + (e2)
e1 -= e2	e1 = (e1) - (e2)
e1 <<= e2	e1 = (e1) << (e2)
e1 >>= e2	e1 = (e1) >> (e2)
e1 &= e2	e1 = (e1) & (e2)
e1 ^= e2	e1 = (e1) ^ (e2)
e1 |= e2	e1 = (e1) | (e2)

Table 1.1: Operadores de asignación además de =

---

i=1, j=0
i=1, j=1

#include <stdio.h>

void main()
{

  int i=0,j;

  j=i++;
  printf("i=%d, j=%d\n",i,j);

  i=0;
  j=++i;
  printf("i=%d, j=%d\n",i,j);

}

1.4.5  Variables predefinidas en PHP

• $_POST Arreglo de datos recibidos por método POST del protocolo HTTP desde un formulario.
• $_GET Arreglo de datos recibidos por método GET del protocolo HTTP desde un formulario.
• $_GLOBALS Arreglo de variables globales. Sus llaves son los nombres de variables globales y sus valores los valores de cada variable.
• $_SERVER Establecida por el servidor web, incluye información sobre el ambiente de ejecución.
• $_COOKIE Variables establecidas por el programa con cookies de HTTP.
• $_FILES Información dada por el protocolo HTTP cuando en un formulario se envian archivos.
• $_ENV Variables de ambiente del usuario que inició el interprete (si se trata del interprete del servidor web, será el ambiente del servidor web).
• $_REQUEST Variables recibidas por el protocolo HTTP por cualquiera de los métodos GET, POST y COOKIE.
• $_SESSION Variables registradas como variables de sesión. Estas permiten mantener el estado entre la ejecución de un script y la de otro tras peticiones de cambio de script (o de volver a cargar) por parte de un usuario de un navegador.

Manteniendo estado Cookies y sesiones

• Cookies: que mantienen el estado en el computador del cliente. Se trata de una característica del protocolo HTTP¹⁴ que permite al servidor enviar al cliente en el encabezado de una página una solicitud para almacenar o devolver un valor asociado a un nombre. Al almacenar un valor debe especificarse en cuanto tiempo expira. El navegador va llevando el estado de cookies y lo salva una vez se cierra dejando toda la información de cookies en un archivo --en el caso de mozilla y firefox es un archivo con nombre cookies.txt en el directorio .firefox o mozilla del usuario.
• Variables de sesión: que tipicamente mantiene parte del estado en el servidor y emplean una identificación única por usuario (almacenada normalmente en un cookie). El estado es salvado en un archivo temporal (usualmente en el directorio /tmp.)

<?php
$r="";
if (isset($_COOKIE['hola'])) {
        $r.="Ya definido en ".$_COOKIE['hola']."<br>";
        if (setcookie('hola', $_COOKIE['hola']+1, time()+60*60*24*30)) {
                $r.="incrementando<br>";
        }
        else {
                $r.="falló incremento<br>";
        }
}
else {
        $r.="inicializando en 0<br>";
        setcookie('hola', 0, time()+60*60*24*30);
}

?>
<html>
<body>
<?php echo $r; ?>
</body>
</html>

<html>
<body>
<?php
session_start();
if (isset($_SESSION['hola'])) {
        echo "Ya definido en ".$_SESSION['hola']."<br>";
        $_SESSION['hola']++;
        echo "incrementando<br>";
}
else {
        echo "inicializando en 0<br>";
        $_SESSION['hola']=0;
}

?>
</body>
</html>

1.4.6  Lecturas recomendadas

1.4.7  Ejercicios para afianzar teoría

1. Repasa conversión de una base a otra. a) Indique a que valor en decimal corresponden cada una de las siguientes expresiones: 0x22F, 0237 mostrando explícitamente como realiza la conversión. b) Escriba en hexadecimal y en octal el número decimal 124 (incluya el procedimiento de conversión).
   
   
2. Es posible convertir rápidamente entre las bases 2, 8 y 16, pues un dígito en hexadecimal corresponde a 4 dígitos en binario y un dígito en octal corresponde a 3 dígitos en binario. Convierta el número binario 11001101 a octal y a hexadecimal. Convierta 0xF23 a binario. Convierta 0273 a binario y después a hexadecimal.
   
   
3. En un sistema OpenBSD en plataforma x86, revise el archivo /usr/include/sys/limits.h y después escriba en decimal los rangos de los siguientes tipos: char, short, int, unsigned int, long.

1.4.8  Ejercicios de programación

1. En el lenguaje Java escriba una función que reciba dos vectores de enteros, cada uno debe tener sólo unos y ceros y cada uno representa un número binario. La función debe implementar la multiplicación de los dos números en binario y debe retornar la respuesta como un vector de enteros.
   
   
2. Este ejercicio es tomado de [13] (1-6). Pruebe la siguiente porción de código con todos los compiladores que pueda y consigne sus resultados en una tabla:

   n=1;
   printf("%d %d\n",n++,n++);
   

1.5  Apuntadores y referencias

• INDICADOR: Emplea apuntadores en C y C++, referencias en C++ y PHP y tipos referencia en Java

1.5.1  Apuntadores y referencias

• Memoria del programa: donde se mantienen las instrucciones del programa
• Memoria de datos: donde se mantienen variables, objetos y datos localizados dinámicamente
• Pila: donde se mantiene temporalmente información de funciones
• Memoria de datos constantes: donde se mantienen constantes definidas del programa

#include <stdio.h>

int main() {
        char c='A';
        char *a=&c, *b;

        printf("a como apuntador es %p\n",(void *)a);
        printf("a como entero es %u\n",(unsigned int)a);
        printf("Tanto c como el caracter apuntado por a son: %c \n",*a);

        *a='X';

        printf("El valor de c después de modificar *a es %c: \n",c);

        return 0;
}

• *apuntador que permite usar y modificar la información de la dirección de memoria indicada por el apuntador.
• &lvalue que en este caso es la dirección en memoria del lvalue.

• Pasar una variable por referencia a una función para que una variable de la función llamadora sea modificada por la función llamada.
• Localizar memoria dinámica. Por ejemplo localizar vectores en tiempo de ejecución.
• Iterar sobre elementos de vectores (con los operadores aritméticos + y -)
• Calcular ``distancia'' entre elementos de un vector.
• Vectores de apuntadores (por ejemplo el parámetro argv de la función main).
• Enlazar estructuras de datos como listas, árboles y grafos.
• Hacer funciones más genéricas empleando apuntadores a funciones y apuntadores a void.

#include <iostream>

using namespace std;

void inicializa(int &x) {
        x=20;
}

int main() 
{
        int y=0;
 int &z=y;
        inicializa(y);  
        cout << " el valor de y es " << y << 
                " y su dirección es " << (&y) <<"\n";
        cout << " el valor de z es " << z << 
                " y su dirección es " << (&z) <<"\n";
        return 0;
}

 el valor de y es 20 y su dirección es 0xcfbc38bc
 el valor de z es 20 y su dirección es 0xcfbc38bc

import java.io.*;

public class Referencias {
        public static void main(String args[])
        {
                int k;
                int[] mv=new int[20];
                inivect(mv,5);

                for (k=0; k<mv.length; k++) {
                        System.out.print("mv[k]="+mv[k]+",  ");
                }
        }

        public static void inivect(int[] v, int val)
        {
                int i;
                for (i=0; i<v.length; i++) {
                        v[i]=val;
                }
        }
}

$a = 1;
$b =& $a; // Tanto $a como $b referencia la misma memoria que tiene un 1
$b = 2;
echo "a es $a\n" // Imprimirá 2

$v = array(1=>'x', 2=>'y', 3=>'z');
$w =& $v; // w y v referencian el mismo arreglo.
$z = $w;  // z referencia una copia de lo que había en w
$z[1]='uno';
print_r($z);  // imprimirá (1=>'uno', 2=>'y', 3=>'z');
print_r($v);  // imprimirá (1=>'x', 2=>'y', 3=>'z');
$w[1]='cero';
print_r($v);  // imprimirá (1=>'cero', 2=>'y', 3=>'z');

function inc(&$n) 
{
 $n++;
}

$v=5;
inc($v);
echo $v; // imprimirá 6

1.5.2  Lecturas recomendadas

1.5.3  Ejercicios para afianzar teoría

1. Tras revisar [3], enumere y describa los especificadores de formato de la función printf (Ayuda: son los mismos de la función fprintf).
   
   
2. Elija una plataforma (procesador y compilador) y con un programa en C o C++ determine los tamaños de los siguientes tipos: int *, char *, void *, double * (Ayuda: use el operador sizeof el cual puede aplicarse bien a una variable o bien a un tipo, por ejemplo sizeof(int) da el tamaño en bytes de un dato tipo int mientras que si x es una variable (o una expresión) sizeof(x) corresponde al tamaño del tipo de x, si se trata de un vector estático declarado global o localmente sizeof da la cantidad de posiciones con el que fue declarado).
   
   
3. ¿Hay equivalentes a malloc y free en Java? ¿Cómo se localiza memoria dinámica en Java y cómo se libera?

1.5.4  Ejercicios de programación

1. Escriba equivalentes en C y en Java para el programa que emplea referencias en C++ (Ayuda: En C use apuntadores, en Java consulte sobre la clase java.lang.Integer).

1.6  Declaración, tipos y clases

• INDICADOR: Declara variables y constantes
• INDICADOR: Emplea TADs y clases

1.6.1  Declaración

<?php
 $a=1;
 $b=10;
 function f() 
 {
  global $b;
  $a=5;
  $b=5;
  echo "GLOBALS['a'] es ".$GLOBALS['a']."\n";
 }

 f();
 echo "a es $a\n";
 echo "b es $b\n";
?>

GLOBALS['a'] es 1
a es 1
b es 5

$b=0;
$a='b';
$$a=2;
echo $b;

1.6.2  Constantes

const int K=5;

enum { K= 5,
J=3 };

    /**
     * The <code>double</code> value that is closer than any 
     * other to <i>pi</i>, the ratio of the circumference of a 
     * circle to its diameter. 
     */
    public static final double PI = 3.14159265358979323846;

define("dbEngine","postgres7");
echo "el valor de la constante dbEngine es".dbEngine;

#define PI 3.14159265358979323846

• #include <stdio.h> inserta el contenido del archivo /usr/include/stdio.h (o en una de las rutas donde se buscan librerías estándar).
• #define CONV 2.5 define la macro CONV que es remplazada en toda parte de las fuentes donde aparezca (excepto si hace parte de una cadena) por 2.5.
• #define MAX(X,Y) ((X)>(Y)) ? (X) : (Y) define la macro MAX que recibe dos elementos comparables con > y retorna el mayor.

• #if CONV==2.5
  int x;
  #else
  #error CONV no es 2.5
  #endif
  

  preprocesa la línea int x sólo cuando la macro CONV es 2.5, en otro caso detiene la compilación sacando el mensaje de error CONV no es 2.5.

1.6.3  Tipos abstractos de datos y clases

class Pareja {

        public:
        int x;
        int y;

        int suma() {
                return x+y;
        }

        int resta() {
                return x-y;
        }
};

#include <iostream>

int main() 
{
        Pareja p;
        p.x=1;
        p.y=2;

        cout << "suma: " << p.suma() << "\n";
        cout << "resta: " << p.resta() << "\n";

        return 0;
}

<?php
class Pareja {
        var $x;
        var $y;

        function suma() 
 {
  return $this->x+$this->y;
        }

        function resta() 
 {
  return $this->x-$this->y;
        }
};

$p=new Pareja();
$p->x=1;
$p->y=2;

echo "suma: ".$p->suma()."\n";
echo "resta: ".$p->resta()."\n";
?>

1.6.4  Tipos

1.6.5  Ejercicios para afianzar teoría

1. Las fuentes de las librerías estándar de Java pueden estar empaquetadas en el directorio de su distribución de Java en el archivo src.jar. Descomprima tales fuentes desde un directorio donde tenga permiso de escritura con jar xvf /usr/local/jdk1.3.1-linux/src.jar (remplazando la ruta por la apropiada para su plataforma). Después revise la implementación de la clase java/lang/Math.java y transcriba la declaración de la constante E allí escrita.
2. Escoja una de las clases Integer, Double, Float y Bool (del paquete java.lang) y traduzca una parte de la documentación (ver [1]).

1.6.6  Ejercicios de programación

1. En lenguaje C implemente el algoritmo de ordenamiento quicksort presentado en [13]. Impleméntelo en un módulo que tenga un archivo encabezado en el prototipo de la función. Después haga un programa para probarlo, preferiblemente usando check (ver guía sobre pruebas).
2. Haga un programa que haga pruebas de regresión a la siguiente clase escrita en Java (Ayuda: idee su propio mecanismo de hacer pruebas de regresión o emplee una herramienta como JUnit):

   /**
    * Mathematical functions related with Wavelets
    * Sources in the public domain. 2004. No warranties.
    * @author Vladimir Tamara. 2000
    **/
   
   import java.lang.*;
   
   /**
    * Mathematical functions related with Wavelets
    * @author Vladimir Tamara
    **/
   public class WavMath
   {
   
       static double ZERO_JAVA=1.0E-12; // Numbers whit absolute value less are 0
       
     /**
      * Decides if a given integer is power of 2
      * @param n Integer to test
      **/
     static public boolean isPowerTwo(int n)
     {
       int i;  /* Counter (0..31) */
       int p2; /* p2=2^i */
   
       for (i=0,p2=1;i<31;i++,p2<<=1)
         { 
           if (n==p2)
             { return true; }
         }
       
       return false;
     }
   
   
     /**
      * Decides if a given integer is power of 2
      * @param n Integer to test
      **/
     static public boolean isPowerTwo(long n)
     {
       int i;  /* Counter */
       long p2; /* p2=2^i */
   
       for (i=0,p2=1;p2<n;i++,p2<<=1) {
       }
       
       return p2==n;
     }
   
     /**
      * Calculates integer part of a logarithm in base 2
      **/
     static public int log_2(int n)
     {
       int i;  /* Counter (0..31) */
       int p2; /* p2=2^i */
   
       for (i=0,p2=1;i<31;i++,p2<<=1)
         { 
           if (n<p2)
             { return i-1; }
         }
       
       return i-1;
     }
   }
   

3. Investigue como puede separarse una clase en C++ para que la declaración quede en un encabezado (.h) mientras que la definición de las funciones de la misma quede en un archivo .c Modifique el ejemplo presentado en este capítulo para que siga las convenciones que propuso y pruebelo.

1.7  Estructuras de Datos

• INDICADOR: Emplea cadenas
• INDICADOR: Emplea estructuras
• INDICADOR: Emplea memoria dinámica

1.7.1  Cadenas

int v[]={1, 2, 4};  /* Creará un arreglo de tamaño 3 */
char cad2[5]={'x', 'y', 'z', 'a', 'b'}; /* Tamaños deben coincidir */

char cad2[]="esperanza";
char cad3[4]="mano";

• double strtof(const char *nptr, char **endptr) que convierte la cadena apuntada por nptr a flotante. Salta espacios que pueda haber al comienzo y retorna en endptr (si este no es NULL) el resto de cadena que sigue al flotante reconocido¹⁶. Esta función reconoce signo al comienzo, puede reconocer números en hexadecimal si comienzan con 0x y las cadenas especiales NaN, INF e INFINITY (ver 1.4.3). Otras funciones análogas pero que retornar double y long double son strtod y strtold respectivamente.
• long strtol(const char *nptr, char **endptr, int base) que convierte la cadena apuntada por nptr a entero largo, salta espacios al comienzo, supone que el número está escrito en la base indicada (entre 2 y 36) y retorno el resto de la cadena que sigue al entero en endptr (a menos que sea NULL.) Son funciones análogas pero para otros tipos: strtoll, strtoul y strtoull.

#include <string>
#include <iostream>

using namespace std;

int main() {

        string x;
        x="hola"; // Asignación de literal
        x+=" mundo"; // Operador + es concatenación
        cout << "x=" << x <<"\n";  // Operador << 
        cout << "x.length()=" << x.length() <<"\n";  // Longitud (o size)
        x.insert(2,"ar");
        cout << "x.length()=" << x.length() <<"\n";  // Longitud (o size)

        return string("hola").length();
}

1.7.2  Estructuras y clases

struct ec {
        int e;
        char c;
};

struct ec;

void ejec() {
        struct ec x;

        x.e=5;
        x.c='A';

        printf("x.e es %d, x.c es %c\n", x.e, x.c);
}

1.7.3  Memoria dinámica

String s;
s=new String("Dios nos ama");

• void *calloc(size_t nmemb, size_t size) localiza un vector de tamaño size, donde cada elemento es de nmemb bytes, e inicializa todos los bytes en 0.
• void *malloc(size_t size) localiza un área de memoria de size bytes, cada byte con un valor inicial arbitrario.
• void *realloc(void *ptr, size_t size) reasigna área de memoria dinámica apuntad por ptr para que su nuevo tamaño sea size bytes. ptr debe ser NULL (y realloc se comporta como malloc) o un apuntador retornado por alguna de estas 3 funciones para localizar memoria. Si el nuevo tamaño es mayor que el anterior, copia la información al comienzo de la nueva área. Si el nuevo tamaño es menor que el anterior, copia sólo los primeros size bytes.

        int *i=new int(5);
        double *vd=new double[20];
...
        delete i;
        delete[] vd;

        int *i;
        double *vd;

        try {
                i=new int(5);
                vd=new double[20];
...
                delete i;
                delete[] vd;
        }
        catch(bad_alloc) {
                cout<<"No hay memoria suficiente";
        }

#include<new>
...
        int *i=new(nothrow) int(5);
 if (i==NULL) {
  cout <<"No puede localizarse espacio para i";
  ...
 }

1.7.4  Apuntadores a funciones

float sgn(float x) 
{
         if (x>0) {
          return 1;
         } 
         else if (x==0) {
          return 0;
         }
         else {
          return -1;
         }
}

float (*apfun)(float)=sgn;

float apder(float (*f)(float), float x, float h)
{
        assert(h>0);
        return ((f(x+h)-f(x))/h);
}

int main()
{
        float d=apder(sgn, 10.0, 0.5);
        printf ("Aproximación a derivada en x=10.0 es %f\n", d);
        return 0;
}

1.7.5  Estructuras de datos

struct sNodoLista {
        /*@shared@*/void *d;
        /*@shared@*/struct sNodoLista *sig;
        /*@shared@*/struct sNodoLista *prev;
};

struct sLista {
        int n; /* Cantidad de nodos */
        int c; /* Posición del nodo actual */
        /*@shared@*/NodoLista *head; /* Primer elemento */
        /*@shared@*/NodoLista *cur;  /* Elemento actual */
};

class NodoLista {
        var d;     /* Información */
 var sig;   /* Referencia al siguiente */
 var prev;  /* Referencia al anterior */
};
class Lista {
        var n; /* Cantidad de nodos */
        var c; /* Posición del nodo actual */
        var cabeza;  /* Referencia al primer elemento */
        var actual;  /* Referencia al elemento actual */
};

1.7.6  Lecturas recomendadas

1.7.7  Ejercicios para afianzar teoría

1. Consulte funciones para operar con cadenas en C (Ayuda: string.h).
   
   
2. Consulte operadores y métodos para operar con cadenas usando el tipo string en C++.
   
   
3. Consulte métodos para operar con cadenas en Java.
   
   
4. En la implementación del TAD Lista mencionado en esta guía, revise la función lista_inv que chequea el invariante de una lista. ¿Qué convención se emplea para una lista vacía en los campos n y c ? ¿Que debe cumplir el apuntador sig del último nodo de la lista? -

1.7.8  Ejercicios de programación

1. Implemente en C el algoritmo de búsqueda binaria descrito en el capítulo 2 de [13]. Pruebelo para buscar una cadena en un vector de cadenas.
   
   
2. En C pruebe la función qsort para ordenar un vector de enteros. El vector debe ser localizado dinámicamente (recuerde liberar la memoria al terminar).
   
   
3. Use el TAD Lista mencionado en esta guía en un programa que reciba enteros por entrada estándar (hasta recibir el entero 0) y los vaya agregando a una lista. Después debe imprimirlos en el mismo orden en el que los recibió (Nota: No olvide liberar memoria al final de su programa).

1.8  Librerías

• INDICADOR: Emplea bibliotecas estándares
• INDICADOR: Maneja fuentes organizadas en diversos archivos

1.8.1  Uso de bibliotecas estándar

Java

• java.applet para hacer applets (binarios de Java ejeuctables desde un navegador).
• java.awt que permite hacer aplicaciones gráficas.
• java.beans que facilita creación de componentes.
• java.io que maneja entrad y salida.
• java.lang con clases básicas (e.g String).
• java.math permite hacer aritmética entera de precisión arbitraria.
• java.net que permite operar con sockets y en redes.
• java.rmi para hacer llamadas a métodos remotos.
• java.security con funciones relacionadas con seguridad.
• java.sql API para acceso a bases de datos SQL.
• java.text Claes e interfaces para manejar textos, fechas, números y mensajes independiente del lenguaje.
• java.util Compresores, descompresores, arreglos que pueden cambiar de tamaño, pila, lista, calendario.
• org.omg.CORBA implementación de Corba para Java (Corba permite intercomunicar en red programas, independientemente del lenguaje de programación de cada programa).
• javax.accessibility
• javax.naming permite acceder servicios de nombres.
• javax.swing Componentes gráficos livianos que funcionan igual en todas las plataformas.
• javax.sound.midi secuenciador y sintetizador MIDI.

1. dar el nombre de la clase precedido del paquete, por ejemplo java.lang.System, o más en concreto: java.lang.System.println("gracias");
2. al comienzo del archivo en el que se usa la clase importarla, por ejemplo con

   import java.lang.System;
   

   también es posible importar todas las clases de un paquete de manera simultanea, por ejemplo:

   import java.lang.+;
   

3. El caso de las clases del paquete java.lang es especial porque estás son importadas de forma automática por el compilador.

C

• <assert.h> Para chequear aserciones con assert cuando no está definido el símbolo NDEBUG.
• <complex.h> Aritmética de números complejos. Puede usarse los tipos double complex, float complex y long double complex. y funciones como creal, conj, cimag, carg, csqrt, cpow, cabs, clog, cexp, ctanh, csinh, ccosh, catanh, casinh, cacosh, ctan, csin, ccos, catan, casin, cacos . Cada una de estas funciones recibe y/o retorna complex double o double, también hay funciones análogas que operan con float y long double, con los mismos nombres de estas pero con los sufijos f y l respectivamente).
• <ctype.h> Con funciones para manejo de caracteres que dependen de la localización²¹. Por ejemplo para decidir si un caracter pertenece a un grupo: isalnum, isalpha, iscntrl, isdigit, isgraph, islower, isupper, isprint, ispunct, isspace, isxdigit; y para hacer conversiones tolower, toupper.
• <errno.h> Macros relacionados con reporte de errores, así como la variable errno que es usada por diversas funciones de la librería estándar para reportar errores. Si después de llamar una función su valor es 0 no hubo error, otros códigos representa errores. En el caso de OpenBSD algunos códigos y símbolos definidos son: 1 EPERM operación no permitida, 2 ENOENT no existe archivo o directorio, 3 ESRCH No existe el proceso, 4 EINTR Llamada a función interrumpida.
• <float.h> características de la implementación de números flotantes.
• <iso646.h> macros que expanden a secuencias de caracteres reservadas en C (utiles por ejemplo si no logran generarse ciertos caracteres con el teclado):

  ---

  Símbolo	Secuencia de caracteres
  and	&&
  and_eq	&&=
  bitand	&
  bitor	|
  compl	| ~
  not	| !
  not_eq	| !=
  or	| ||
  or_eq	| |=
  xor	| ^
  xor_eq	| ^

  ---

• <limits.h> que define límites y parámetros de los tipos enteros.
• <locale.h> para manejar localización. La localización la conforman detalles de un idioma o una cultura como: símbolo del punto decimal, separador de miles, símbolo monetario, formato de fechas. Se establece con la función setlocale cuyo primer parámetro puede ser el valor de uno de los símbolos: LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME, y el segundo puede ser la cadena "C" para indicar una localización por defecto, "" para indicar la localización del sistema o una cadena como "es_CO" para indicar localización de Colombia.
  
  
• <math.h> que declara tipos y funciones matemáticas. isfinite, isinf, isnan, isnormal, signbit, acos, asin, atan, atan2, cos, sin, tan, acosh, asinh, atanh, cosh, sinh, tanh, exp, exp2, expm1, frexp, ilogb, ldexp, log, log10, log1p, log2, logb, modf, scalbn, cbrt, fabs, hypot, pow, sqrt, erf, erfc, lgamma, tgamma, ceil, floor, nearbyint, rint, round, lround, trunc, fmod, remainder, remquo, copysign, nan, nextafter, fdim, fmax, fmin, fma.
  
  
• <setjmp.h> Saltos no locales, con setjmp puede ``marcarse'' un sitio del programa al cual puede después saltarse con longjmp (incluso desde otra función, pero cuidando que la pila podría ser modificada).
• <signal.h> para manejar señales (en sistemas tipo Unix).
• <stdarg.h> para manejar argumentos en funciones cuyo número de parámetros es variable (e.g printf).
• <stddef.h> tipos y constantes básicas (e.g NULL.
• <stdio.h> Tipos , macros, variables y funciones de entrada/salida. Entre las variables están stderr, stdin y stdout que son archivos que representan error estándar, entrada estándar y salida estándar. Entre las funciones definidas hay algunas para manejar archivos a alto nivel remove, rename, tmpfile, tmpnam, otras para acceder a archivos fclose, fflush, fopen, freopen, setbuf, setvbuf; operaciones para manejar archivos tipo texto fprintf, fscanf, printf, scanf, snprintf, sprintf, sscanf, vfprintf, vfscanf, vprintf, vscanf, vsnprintf, vsprintf, vsscanf, fgetc, fgets, fputc, fputs, getc, getchar, gets, putc, putchar, puts, ungetc; para manejar archivos binarios fread, fwrite, fgetpos, fseek, fsetpos, ftell, rewind; para manejar errores clearerr, feof, ferror, perror.
• <stdlib.h> utilidades generales como las funciones de conversión (ver 1.7.1); generación de números seudo-aleatorios rand, srand; manejo de memoria calloc, free, malloc, realloc; comunicación con ambiente abort, atexit, exit, getenv, system; funciones para buscar y ordenar bsearch, qsort; funciones de aritmética entera abs, labs, llabs, div, ldiv, lldiv; manejo de caracteres multibyte mblen, mbtowc, wctomb, mbstowcs, wcstombs.
• <string.h> para manejo de cadenas y zonas de memoria con operaciones para copiar y mover memcpy, memmove, strcpy, strncpy; concatenar strcat, strncat; comparar memcmp, strcmp, strcoll, strncmp, strxfrm; búsqueda memchr, strchr, strcspn, strpbrk, strrchr, strspn, strstr, strtok, memset, strerror, strlen.
• <tgmath.h> que define las mismas funciones de math.h y complex.h pero haciéndolas genéricas para los tipos float, double, long double y sus análogos complex.
• <time.h> con estructuras, tipos, macros y funciones para manipular tiempo clock, difftime, mktime, mkxtime, time; para convertir asctime, ctime, gmtime, localtime, strftime, strfxtime, zonetime.
• <wchar.h> que facilita el uso de cadenas de caracteres amplios y multibyte fwprintf, fwscanf, swprintf, swscanf, vfwprintf, vfwscanf, vswprintf, vswscanf, vwprintf, vwscanf, wprintf, wscanf; así como manejo de archivos fgetwc, fgetws, fputwc, fputws, fwide, getwc, getwchar, putwc, putwchar, ungetwc; funciones de conversión wcstod, wcstof, wcstold, funciones sobre cadenas wcscpy, wcsncpy, wcscat, wcsncat, wcscmp, wcscoll, wcsncmp, wcsxfrm, wcschr, wcscspm, wcslen, wcspbrk, wcsrchr, wcsspn, wcsstr, scstok, wmemchr, wmemcmp, wmemcpy, wmemmove, wmemset; para conversión de tiempo wcsftime, wcsfxtime; para interoperar con multibytes (teniendo en cuenta el estado de cadenas multybyte) btowc, wctob, mbsinit, mbrlen, mbrtowc, wcrtomb, mbsrtowcs, wcsrtombs.
• <wctype.h> para clasificar y convertir caracteres amplios iswalnum, iswalpha, iswcntrl, iswdigit, iswgraph, iswlower, iswprint, iswpunct, iswspace, iswupper, iswxdigit, iswctype, wctype, tpwlower, towupper, towctrans, wctrans.

C++

• std::printf que hace explicito que se desea llamar la función printf de la biblioteca estándar de C++.
• agregar al comienzo del programa using namespace std, que hace que en el espacio de nombres globales se incluyan los nombres del espacio std (ver 1.7.1).

#include <cstddef>

• Soporte al lenguaje
  • Tipos <cstddef>
  • Propiedades de la implementación <limits> , <climits> , <cfloat>
  • Inicio y terminación <cstdlib>
  • Manejo de memoria dinámica <new>
  • Identificación de tipos <typeinfo>
  • Manejo de excepciones <exception>
  • Otro soporte en tiempo de ejecución <cstdarg> , <csetjmp> , <ctime> , <csignal> , <cstdlib> .
  
  
  
• Diagnósticos
  • Clases de excepciones <stdexcept>
  • Aserciones <cassert>
  • Códigos de error <cerrno>
  
  
  
• Utilidades generales
  • Utilidades para componentes <utility> (comparaciones, parejas)
  • Funciones <functional> que define algunos operadores como funciones para facilitar el uso de iteradores.
  • Memoria <memory> , para definir localizadores de memoria.
  • Funciones de memoria de <cstdlib>
  • Fechas y tiempo <ctime>
  
  
  
• Cadenas
  • Plantilla para cadenas de cualquier tipo <string> , las instancia en particular para char (ver 1.7.1) y para wchar_t.
  • Secuencias terminadas en el caracter nulo ('\0' ) <cctype> <cwctype> , <cstring> , <cwchar> , <cstdlib> .
  
  
  
• Internacionalización
  • <locale> y <clocale> .
  
  
  
• Contenedores
  • Secuencias <deque> , <list> , <queue> , <stack> , <vector> .
  • Cotenedores asociativos <map> , <set> , <bitset> .
  
  
  
• Iteradores
  • <iterator> que permite usar o definir iteradores para diversas clases usando por ejemplo operadores (los hay de acceso aleatoria, bidireccionales y hacia adelante).
  
  
  
• Algoritmos
  • <algorithm> que implementa operaciones que no modifican secuencias (e.g find, for_each, find_if, find_end, count, equal, search) , algunas que modifican (copy, transform, swap, replace, fill, generate, remove, unique, reverse, rotate, random_shuffle, partition) y operaciones relacionadas con ordenamiento (sort, stable_sort, partial_sort, nth_element, binary_search, merge), conjuntos (includes, set_union, set_intersection, set_difference), montículos (push_heap, pop_heap, make_heap, sort_heap), mínimos y máximos (min, max, min_element, max_element, lexicographical_compare) y permutaciones (next_permutation, prev_permutation).
  • <cstdlib>
  
  
  
• Biblioteca numérica
  • <complex> números complejos
  • <numeric> operaciones numéricas generalizadas
  • <cmath> , <cstdlib> funciones mátematicas heredadas de C
  
  
  
• Entrada/Salida
  • <iostream> Objetos de entrada/salida estándar
  • <ios> Clases básicas de e/s
  • <streambuf> buffers para flujos
  • <istream> , <ostream> , <iomanip> manipuladores y formateadores.
  • <sstream> , <cstdlib> flujos a cadenas
  • <fstream> , <cstdio> , cwchar flujos a archivos

1.8.2  Bibliotecas no estándar

Caso C

• Cada archivo fuente es pasado por el preprocesador, el preprocesador remplaza las macros²⁴ por su valor; incluye los archivos indicados con #include²⁵, deja sólo las porciones apropiadas de los #if que pueda haber, de requerirlo imprime mensajes de error especificados con #error y hace cambios a la forma de compilación de acuerdo a los #pragma que haya.
• Cada archivo fuente después de preprocesado es compilado, es decir es traducido a código objeto.
• Todos los códigos objetos que conforman el programa son encadenados u junto con las librerías apropiadas, para generar un ejecutable. Debe haber un sólo código objeto (así como fuente) en el que se defina la función main.

cd prog/skalib-*
package/install

/* Ejemplo de uso de rutina md5 de biblioteca stdcrypt de skalibs.
 * Dominio público. 2004. Sin garantías. */

#include <stdio.h>
#include "stdcrypto.h"

int printhex(unsigned char *m, int len) 
{
        int i;
        for (i=0; i<len; i++) {
                printf("%x ",(m[i]));
        }
}

int main() 
{
        MD5Schedule ctx;

        char mens[]="Jesús es el camino, la verdad y la vida";
        unsigned char digest[16];

        md5_init(&ctx);
        md5_update(&ctx, mens, strlen(mens));
        md5_final(&ctx, digest);

        printf("mens=\"%s\"\n", mens);
        printhex(digest,15);
        printf("\n");
 
        return 0;
}

gcc -o ejmd5 -I prog/skalibs/include ej_md5.c -L prog/skalibs/library/ -lstdcrypto -lstddjb

• -o ejmd5 que indica el archivo de salida.
• -I prog/skalibs/include que indica una ruta donde buscar archivos encabezados (por defecto busca en /usr/include).
• -L prog/skalibs/library que indica una ruta donde buscar librerías
• -lstdcrypto y -lstddjb que indican encadenar con las bibliotecas libstdcrypto.a (ubicada en prog/skalibs/library).

Caso C++

#include "Readline.hpp"

using namespace readlinecpp;
int main() 
{
           string theline;
           string prompt = "prompt: ";
           bool breakout;
           Readline reader;

           do
           {
               theline = reader.readline( prompt, breakout );
               if( breakout ) break;
               if( theline.empty() ) continue;
               if( theline == "history" )
               { // sample of implementing simple commands (map<string,functor> is prolly better)
                   cout << "History:"<<endl;
                   reader.save_history( std::cout );
                   // or: 
                   //   std::copy( reader.history().begin(), reader.history().end(), std::ostream_iterator<string>(cout,"\n") );
                   continue;
               }
               reader.add_history( theline );
           } while(1);
}

g++ -o ejemplo -Isrc -Lsrc -lreadline_cpp ejemplo.cpp

LD_LIBRARY_PATH=src ./ejemplo

1.8.3  Lecturas recomendadas

• En el caso de Java puede encontrar la documentación de las bibliotecas para cada versión de Java en http://java.sun.com/reference/api/index.html.
• En el caso de C++ puede consultar el borrador de la especificación [borrcp] o en Internet alguna de las guías disponibles como En el caso de C pueden consultarse las mismas referencias de C++ (pues la librería estándar de C está incluida en la de C++) o el borrador del estándar [3] o en Internet http://www-ccs.ucsd.edu/c/ o más fácil en un sistema tipo Unix con man (e.g man stdio). Pueden verse los códigos de error con man errno.

1.8.4  Ejercicios para afianzar teoría

1. Traduzca la documentación de la clase Double de java.lang

1.8.5  Ejercicios de programación

1. En Java como puede lograr que una función retorne a la función llamadora un valor flotante y a la vez un valor booleano? Implemente un ejemplo (Ayuda: referencias y tipo Double o Bool).
   
   
2. Con las ayudas de esta guía compile y ejecute los ejemplos de uso de librerías no estándar.

1.9  Herencia, interfaces

• INDICADOR: Define y usa clases que heredan de otras clases

1.9.1  Herencia

C++

class Persona {

        private:
        string id;

        protected:
        string nombres;
        string apellidos;

        public:
        Persona(string id, string nombres, string apellidos);
        string sacaApellidos();
        void cambiaNombres(string nombres);
        string nombreCompleto();
};

Persona::Persona(string id, string nombres, string apellidos)
{
        this->id=id;
        this->nombres=nombres;
        this->apellidos=apellidos;
}

void
Persona::cambiaNombres(string nombres)
{
        this->nombres=nombres;
}

string
Persona::sacaApellidos()
{
        return this->apellidos;
}


string
Persona::nombreCompleto()
{
        return nombres+" "+apellidos;
}

        Persona p("111", "Pablo", "Ramirez");
        Persona *p2=new Persona("1121", "Angela", "Gonzáles");

        p2->cambiaNombres("Marta");
        s=p.sacaApellidos();
        s[0]='X';
        cout << s <<"\n";
        cout << p.sacaApellidos() <<"\n";
        cout << p2->nombreCompleto()<<"\n";

class Estudiante:public Persona {
        string carne;
        public:
        Estudiante(string id, string nombres, string apellidos, string carne):
                Persona(id,nombres,apellidos) {
                this->carne=carne;
        }
        string sacaCarne() {
                return carne;
        }

        string nombreCompleto();
};
 
string
Estudiante::nombreCompleto() {
        return nombres+"-"+apellidos;
}

Java

• En Java al pasar un objeto como argumento de una función o al retornarlo el objeto pasa por referencia.
• En Java cada clase puede heredar a lo sumo de una clase, aunque puede implementar una o más interfaces. Una interfaz corresponde a una clase abstracta en la que todos los métodos son virtuales puros.
• En Java cada miembro público debe precederse en su declaración con la palabra reservada public. Las clases e interfaces pueden ser públicas o no (igualmente precediéndolas con public), lo que indica que pueden usarse desde otros archivos (todas los paquetes son públicos).

import java.lang.*;

class Persona {

        String id;
        String nombres;
        StringBuffer apellidos;

        public Persona(String id, String nombres, String apellidos)
        {
                this.id=id;
                this.nombres=nombres;
                this.apellidos=new StringBuffer(apellidos);
        }

        public StringBuffer sacaApellidos()
        {
                return apellidos;
        }

        public void cambiaNombres(String nombres)
        {
                this.nombres=nombres;
        }

        public String nombreCompleto()
        {
                return nombres+" "+apellidos;
        }
};


class Estudiante extends Persona {
        String carne;

        public Estudiante(String id, String nombres, String apellidos, String carne)
        {
                super(id,nombres,apellidos);
                this.carne=carne;
        }

        public String sacaCarne()
        {
                return carne;
        }

        public String nombreCompleto()
        {
                return nombres+"-"+apellidos;
        }
};

public class Herencia {

        public static void main(String[] args)
        {
                Persona p=new Persona("111", "Pablo", "Ramirez");
                Persona p2=new Persona("1121", "Angela", "Gonzáles");
                Estudiante e=new Estudiante("088", "Tomas", "Guerrero", "c22");

                StringBuffer s;

                p2.cambiaNombres("Marta");
                s=p.sacaApellidos();
                s.append(" Cordoba");
                System.out.println(s);
                System.out.println(p.sacaApellidos());
                System.out.println(p2.nombreCompleto());
                System.out.println(e.nombreCompleto());
                System.out.println(e.sacaCarne());
        }

}

1.9.2  Ejercicios de programación

1. Escriba un programa en el que se definan las clases Persona y Estudiante presentadas en esta sección, así como una nueva clase derivada EstudiantePers, la nueva clase debe tener una función para escribir los datos de un estudiante en un archivo plano (digamos void escribe(char *nomarchivo);) y otra para leerlos de un archivo plano (por ejemplo void lee(char *nomarchivo);. En el programa que haga pruebe las funciones introducidas.
   
   
2. Investigue el uso de interfaces en Java y escriba un programa corto que las use.

1.10  Lo propio de C++

• INDICADOR: Define y usa constructores y destructores
• INDICADOR: Emplea sobrecarga de funciones y de operadores

/**
 * Objeto genérico. Imitando Java.
 * @author Dominio público. 2006. vtamara@pasosdejesus.org
 **/

#ifndef OBJETO_HPP
#define OBJETO_HPP

class Objeto {
        public:
        virtual Objeto *clonar()=0;
        /** Retorna una cadena con una representación presentable del objeto 
        * como cadena.
        * Localiza memoria para la nueva cadena con new.  Es responsabilidad 
        * de la función llamadora liberarla.
        * Lanza una excepción si no logra localizar memoria.
        */
        virtual char *aCadena()=0;
};
#endif

class Entero: public Objeto {
        private:
                int e;
        public:
                Entero(int n);
                int valor();
                Objeto *clonar();
  char *aCadena();
};

/**
 * Entero descendiente de Objeto genérico.
 * @author Dominio público. 2006. vtamara@pasosdejesus.org
 **/

#include <algorithm>
#include <cassert>
using namespace std;

#include "Entero.hpp"

Entero::Entero(int n)
{
        e=n;
}
int Entero::valor()
{
        return e;
}
Objeto *Entero::clonar()
{
        Entero *n=new Entero(e);

        return (Objeto *)n;
}
char *Entero::aCadena()
{
        double ld= e==0 ? 0 : log10((double)abs(e));
        int l = (int)(ld+1);
        char *s;
 l = (e<0) ? l+1 : l;
 s = new char[l+1];
        snprintf(s, l+1, "%d", e);
        return s;
}

1.10.1  Constructoras

Entero e;
Entero v[100];

Entero(int n=0);

Entero x=(Entero)9;

inline Entero(const Entero &x):e(x.e) { };

inline Entero(const Entero &x) { e=x.e; }

Entero un_cinco()
{
        Entero x(5);
        return x;
}

int main()
{
        Entero e=un_cinco();
        Entero f=e;
        cout << f.valor() <<"\n"; //Imprimirá 5
        return 0;
}

Entero *ref_cinco()
{
        Entero x(5);
        return &x;
}

1.10.2  Destructoras

~Entero() {};

Entero c=3;

1.10.3  Sobrecarga

int suma(int x, int y) 
{ 
        return x+y;
}
float suma(float x, float y)
{
        return x+y;
}

cout << suma(0.0, 0.0);
cout << suma(0, 0);

cout << suma(0, 0.0);

1.10.4  Operadores

 new  delete    new[]     delete[]                             
+    -    *    /    %    ^    &    |    ~                     
!    =    <    >    +=   -=   *=   /=   %=  
^=   &=   |=   <<   >>   >>=  <<=  ==   !=                    
<=   >=   &&   ||   ++   --   ,    ->*  ->                    
()   []        

a.operator-();

operator+(a);

Operadores unarios

Entero operator-();

Entero operator-();
{
        return Entero(-e);
}

Entero operator-(const Entero a&) 
{
        return Entero(-a.valor());
}

friend Entero operator+(const Entero &);

Entero operator-(const Entero &a) 
{
        return Entero(-a.e);
}

Operadores binarios

void operator+(Entero &a, Entero b)   //a por referencia, b por copia
{
        a.poner(a.valor()+b.valor());
}

Entero x(9);
Entero y(5);
x+y;
cout << x.valor(); // Presentará 14

friend Entero operator+(const Entero &x, const Entero &y);
friend Entero operator+(const Entero &x, const int &y);
friend Entero operator+(const int &x, const Entero &y);

Entero operator+(const Entero &x, const Entero &y)
{
 return Entero(x.e+y.e);
}

Llamada de función

int operator()(float x);

int Entero::operator()(float x)
{               
        e+=(int)x;
        return e;
}

Entero x(99);
int rx=x(3.0);
assert(rx==102 && rx.valor==102);

Operadores de asignación

Entero &Entero::operator=(const Entero &f)
{
        e=f.e;
        return (*this);
}

Entero a(99);
Entero b,c;
b=c=a;
assert(a.valor()==99 && b.valor()==99 && c.valor()==99);

Entero &Entero::operator=(const int &i)
{
        e=i;
        return (*this);
}

Entero b;
b=5;
assert(b.valor()==5);

Operador de subindexado

Entero &Entero::operator[](const int &i)
{
        return (*this);
}

Operadores relacionados con memoria

Entero *operator->() { return this; } 
Entero operator*() { return *this; } 
Entero *operator&() { return this; } 

void *operator new(size_t s) {
        return ::operator new(s);
}
void operator delete(void *p, size_t s) {
        ::operator delete(p);
}
void *operator new[](size_t s) {
        return ::operator new[](s);
}
void operator delete[](void *p, size_t s) {
        ::operator delete(p);
}

Operadores de incremento/decremento prefijo y posfijo

1.10.5  Streams

friend std::istream &operator>>(std::istream &is,
                                Entero &e);
                friend std::ostream &operator<<(std::ostream &os,
                                const Entero &e);

std::istream &operator>>(std::istream &is, Entero &e)
{
        return is >> e.e;
}

std::ostream &operator<<(std::ostream &os, const Entero &e)
{
        return os << e.e;
}

Entero r(5);
cout << r; // 5 a sálida estándar
cin >> r; // espera entero de entrada estándar

// requiere inclusión de <fstream>
fstream fs("numeros.txt", ios_base::out);  
y=-25;
fs << y; // 5 al archivo numeros.txt
fs.close();

fstream flee("numeros.txt", ios_base::in);
flee >> x; // 5 sale de numeros.txt hacía x
flee.close();

// requiere inclusión de <sstream>
stringstream sst(stringstream::in | stringstream::out);
sst << y << " " << 19; // -25 19 al flujo cadena sst
sst >> x; // -25 sale de sst y va a x
sst << y << " " << 19; // 19 -25 19 en sst
sst >> y; // 19 sale de ssy va a y en sst queda -25 19
assert(x==-25 && y==19);

sst >> y; // -25 a y en sst queda 19
sst >> x; // 19 a x sst queda vacío
assert(x==19 && y==25);

x=15;
sst << x; // 15 de x a sst
string cx;
sst >> cx; // 15 de sst a cx, sst queda vacío
sst << cx; // 15 de cx a sst, sst queda con 15
sst >> y; // 15 de sst a y, sst queda vacío
assert(x==15 && y==15);

---

Bandera	Efecto si está activada
ios_base::boolalpha	Presenta objetos bool como nombres (true, false).
ios_base::dec	Formato de entrada/salida de enteros en decimal.
ios_base::fixed	Valores flotantes y notación de punto fijo.
ios_base::hex	Formato de entrada/salida de enteros en hexadecimal.
ios_base::internal	Salida es llenada en el punto entero par a aumentarla hasta el ancho del campo field.
ios_base::left	la salida es llenada al final para aumentarla hasta el ancho del campo field.
ios_base::oct	Formato de entrada/salida en base octal.
ios_base::right	la salida es llenada al comienzo para aumentarla hasta el ancho del campo field.
ios_base::scientific	emitir valores de punto flotnate en notación científica.
ios_base::showbase	emitir valores enteros precedidos por la base numérica.
ios_base::showpoint	emitir valores de punto flotante incluyendo siempre el punto decimal.
ios_base::showpos	emitir números no negativos precedidos de un signo más (+).
ios_base::skipws	saltar espacios en blanco al comienzo en ciertas operaciones de ingreso.
ios_base::unitbuf	descargar la salida después de cada operación de inserción.
ios_base::uppercase	emitir letras en mayúsculas que remplacen letras ciertas letras mayúsculas.

---

cout.setf ( ios_base::hex, ios_base::basefield );  
cout.setf ( ios_base::showbase );                  
cout << 100 << endl;  //0x64
cout.unsetf ( ios_base::showbase );               
cout << 100 << endl; //64
cout.unsetf ( ios_base::hex); 

cout << 100 << endl << oct << 100 << endl;

cout.width(10);
cout<<77;

cout<<setw(10)<<77;

string cadena;
cout << "Una cadena: ";
getline(cin, cadena);

string num;
Entero me;
cout << "Un entero: ";
getline(cin, num);
istringstream ist(num);
ist >> me;
cout << "Fue "<< me << endl;

1.10.6  Excepciones

Espacios de nombres

1.10.7  Lecturas recomendadas

• Secciones ``Special member functions'' y ``Overloading'' del borrador del estándar de C++ ??.
• Secciones `Constructors,' `Destructors,' `Assignment operators,' `Operator overloading,' `Friends,' `Input/output via <iostream> and <cstdio>,' `Exceptions and error handling' y `Const correctness' de ??.
• Sección sobre Entrada y Salida de ??.

1.10.8  Ejercicios de programación

1. Implemente una clase complejo que represente números complejos y de manera que el siguiente código funcione:

   complejo c;  // Corresponde a 0.0 + 0.0i
   complejo x=3.0;  // Corresponde a 3.0 + 0.0i
   complejo y(4.0, 5.0);  // Corresponde a 4+5i
   complejo w(y);  // Corresponde a 4+5i
   x.suma(y);  //x debe quedar con la suma de x antes con y (i.e 7+5i)
   

   
   
   
2. Implemente tantos operadores como le resulte posible para la clase Entero. El siguiente código debería funcionar:

   Entero x;  
   assert(x==0);
   x=8;
   assert(x<9 && x>7);
   

   
   
   
3. A la clase complejo que implementó, agreguele operadores sobre flujos para ingreso y emición de complejos con la sintaxis: (5.3, 2.1). Sugerencias: (1) Identifique los elementos léxicos importantes `(' `,' `)'. (2) busquer las diversas operaciones que pueden implementarse sobre la clase string.

1

Aunque los 4 lenguajes tienen convenciones propias en cuanto a identificadores (por ejemplo Java soporta Unicode, mientras que PHP, C y C++ no), es común a todos considerar identificadores válidos cadenas alfanuméricas (i.e números y letras del alfabeto en inglés) iniciadas con letra o con _ . En PHP toda variable debe comenzar con el caracter `$'. Tal como lo sugiere [13] ``emplee nombres descriptivos para variables globales y nombres cortos para variables locales.''

2

En Java tras crear un arreglo no hay forma de cambiar el tamaño

3

Note que de acuerdo a [3] (sección 6.5.4) en C99 el tamaño de un arreglo que se reciba como parámetro de una función (bien con o sin tamaño) NO puede obtenerse con ayuda de sizeof --tiene que mantenerse en una variable o constante.

4

La dirección de retornó será la dirección que sigue a la instrucción en la que se hace la llamada.

5

static indica que la función puede llamarse sin crear objetos de la clase.

6

public indica que una función puede ser llamada desde otras clases.

7

A esta operación de conversión en inglés se le llama casting.

8

Los paréntesis permiten cambiar la precedencia o el orden de evaluación de una expresión.

9

Al escribir constantes en hexadecimal emplee los dígitos 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E, F.

10

Al escribir constantes en octal emplee los dígitos 0,1,2,3,4,5,6,7.

11

En C y C++ también puede emplearse Unicode con el tipo wchar_t (definido en el encabezado stddef.h), los caracteres de este tipo llevan el prefijo L, por ejemplo L'\x192'.

12

En C y C++ puede ponerse como prefijo L para especificar una cadena de caracteres amplios (wchar_t).

13

Si el primer operando del operador de corrimiento a la derecha es negativo pueden llenarse los bits del comienzo con 0 con 1, el comportamiento en C y C++ depende de la plataforma.

14

Es una extensión descrita en el RFC 2109.

15

Como se explica más adelante una clase puede verse como un conjunto de variables y funciones.

16

Otras funciones que implementan parte de la funcionalidad de las presentadas son atof, atoi, atol y atoll.

17

Un objeto es una instancia (i.e memoria reservada) de una clase.

18

De hecho en C++ las estructuras son funcionalmente equivalentes a las clases, excepto porque en una clase por defecto todos los miembros son privados, mientras que en una estructura por defecto todos los miembros son públicos.

19

La conversión a cadena en el caso de objetos la realiza llamando al método toString.

20

La ubicación y el nombre del archivo de clases ha cambiado de una versión a otra de Java, la información citada es para JDK 1.3 en un sistema tipo Unix.

21

Idioma y formatos (e.g de fechas, números, cantidades monetarias) establecidos en variables de ambiente como LC_LANG, LC_MESSAGES. Para el caso de Colombia el valor de estas variables debería ser es_CO. Todas pueden ponerse simultaneamente con export LC_ALL=es_CO.

22

Al incluir un encabezado como stdio.h, los tipos, funciones y clases allì declaradas se agregan al espacio de nombres global.

23

El contenido de cstddef es el mismo del encabezado estándar de C stddef.h.

24

Las macros se definen con #define, pueden tener argumentos.

25

La forma de resolver inclusiones depende del compilador. Es usual que las inclusiones de la forma #include <archivo> se resuelvan buscando el archivo en la ruta de los archivos encabezados estándar. Las inclusiones de la forma #include "archivo" se resuelven buscando el archivo en la ruta donde están las fuentes compiladas y de no encontrarse en las rutas de encabezados estándar. De esta manera es posible definir encabezados que remplacen encabezados estándar.

26

Se trata de varias librerías de dominio público, en una de las cuales (libstdcrypt) hay algunas funciones de criptografía.

27

El comentario estaba desactualizado con respecto al código, que es un error común y que vale la pena reportar a los autores del programa.

28

En sistema OpenBSD para que la configuración funcione se requiere instalar bash2, findutils gmake y modificar toc/tests/gnu_find.sh cambiando toc_find find por toc_find gfind.

29

Por defecto los miembros de una clase son privados.

30

Un objeto es una instanciación de una clase, por ejemplo si Persona es una clase, la declaración Persona p declara un objeto p que es instancia de la clase Persona.

31

Un miembro estático de una clase (digamos s) de una clase X se declara con la palabra reservada static y puede usarse sin necesidad de crear objetos de la clase con X::s.

Capítulo 2  Vistazo a ingeniería de software y a algunas herramientas

• LOGRO: Conoce áreas y etapas típicas de la ingeniería de software
• LOGRO: Conoce forma de desarrollo sugerida por Programación Extrema

2.1  Ingeniería de Software y requerimientos

• INDICADOR: Define ingeniería de software y algunas de sus áreas
• INDICADOR: Define requerimientos de software y áreas de conocimiento en ese tema
• INDICADOR: Define programación extrema y puede recolectar historias de usuario y tareas de programación

2.1.1  Teoría

1. "La aplicación de una aproximación sistemática, disciplinada y cuantificable al desarrollo, operación y mantenimiento de software; es decir, la aplicación de la ingeniería al software.
2. El estudio de aproximaciones como las descritas en (1),"

• Requerimientos
• Diseño
• Construcción
• Pruebas
• Mantenimiento
• Administración de configuraciones
• Administración de ingeniería del software
• Proceso de ingeniería del software
• Herramientas y métodos de ingeniería
• Calidad de software
• Disciplinas relacionadas

2.1.2  Requerimientos

• Requerimientos de productos y de procesos: los primeros se refieren a requerimientos del software por desarrollar, los segundos a restricciones en el desarrollo (e.g lenguaje de programación).
• Requerimientos funcionales y no funcionales: Los primeros describen una función que el programa debe ejecutar, también se llaman capacidades. Los segundos son restricciones o requerimientos de calidad e.g. desempeño, mantenibilidad, seguridad, robustez.
• Propiedades emergentes: se refiere a requerimientos que no pueden ser atribuidos a un sólo componente de un programa, sino que depende de la interrelación de todos los componentes y por tanto dependen de la arquitectura del sistema (e.g. desempeño de un sistema completo).
• Requerimientos del sistema y del software: los primeros se aplican a un sistema completo del cual el software hace una parte (por ejemplo puede haber hardware, firmware, información, personas, técnicas, servicios).

Proceso de requerimientos

Adquisición de requerimientos

Análisis de requerimientos

Especificación de requerimientos

• Documento de definición del sistema: define los requerimientos del sistema de alto-nivel desde la perspectiva del dominio. Sus lectores incluyen representantes de los usuarios/clientes del sistema. Lista requerimientos con información del marco, ambiente de operación, restricciones, suposiciones y requerimientos no funcionales.
• Especificación de requerimientos del sistema: en el caso de sistemas complejos con porciones importantes que no son software, se especifican los requerimientos del sistema completo (empleando técnicas de ingeniería) para derivar de allí los requerimientos de software.
• Especificación de requerimientos del software: establece los acuerdo entre cliente y contratante sobre los que hace y lo que no hace el producto de software

Validación de requerimientos

2.1.3  Hacía la práctica: Programación extrema y requerimientos

• Comunicación: los programadores se comunican directamente con los clientes, negocian alcances y cronograma.
• Simplicidad: Mantienen diseños simples y limpios,
• Retroalimentación: obtenida de pruebas que se realizan desde el primer día (el programador debe asegurar que los requerimientos y el diseño son susceptibles de ser puestos a prueba y debe crear pruebas automáticas de unidades y funcionales). También de usuarios a quienes se les entrega el sistema tan pronto como es posible, para implementar los cambios que sugieran.
• Coraje: Con las características presentas los programadores pueden responder con valor a requerimientos y tecnología cambiante.

2.1.4  Requerimientos

• Historias de usuarios: escritas por los clientes durante la planeación
• Tareas de programación: identificadas y asignadas por los programadores con base en las historias de usuario por implementar.
• Pruebas de aceptación: que son ejecutadas y refinadas con el cliente/usuario.

2.1.5  Lecturas recomendadas

2.1.6  Ejercicios para afianzar teoría

1. Dado que los requerimientos de software establecidos (por ejemplo en la especificación de requerimientos) llegan a servir como contrato entre cliente y desarrolladores y que en ciertos contextos es indispensable documentar todo el proceso de desarrollo de una forma estándar, pueden tener que escribirse extensos documentos, costosos de crear, leer y mantener siguiendo pautas. Un ejemplo de un estándar para especificar requerimientos del proceso empleado a manera de contrato y para consignar desarrollo del proceso de desarrollo, es el MIL-STD-498 empleado por agencias del Departamento de Defensa de EUA. Puede consultarse por ejemplo en: http://www.pogner.demon.co.uk/mil_498/.
   
   Analice este estándar e indique:
   1. En que condiciones y para que tipos de programas le parece aplicable
   2. Estime el tiempo que requiere sólo llenar las plantillas de este estándar para resolver un problema de software (sin elementos de hardware o de otra índole) de mediana complejidad. No tenga en cuenta el tiempo para llevar a cabo cada actividad, sólo para llenar las plantillas que este estándar exige para un proyecto de ese estilo.
   
   
   
2. Busque una plantilla para el documento con la especificación de requerimientos de software, indique en que casos es aplicable y estime el tiempo que requiere completarla.
   
   
3. Busque una notación formal para especificación de requerimientos y describa en que contexto es aplicable.
   
   
4. En diversos sitios de Internet se emplean Wikis para mantener información de manera colaborativa y no controlada. Revise http://www.programacionextrema.org y describa como podría mejorar la página LosRoles para cambiar el término ``Coach'' por un equivalente apropiado en español.

2.2  Pruebas de Software

• INDICADOR: Identifica metodologías para probar software y la terminología del área
• INDICADOR: Conoce ambientes para realizar pruebas de unidades útiles en el marco de programación extrema.

2.2.1  Teoría

• Niveles de pruebas
• Técnicas para probar
• Medidas relacionadas con pruebas
• Proceso de pruebas

2.2.2  Niveles de pruebas

2.2.3  Objeto de la prueba

2.2.4  Objetivos de las pruebas

2.2.5  Técnicas para probar

Basadas en intuición y experiencia del ingeniero de software

Basadas en especificación

Basadas en código

Basadas en fallas

Basadas en uso

Basadas en la naturaleza de la aplicación

Selección y combinación de técnicas

2.2.6  Medidas relacionadas con pruebas

• A partir de medidas basadas en el tamaño del programa (e.g número de líneas del código fuente) o en su estructura (e.g complejidad) pueden guiarse las pruebas.
• Para hacer pruebas más efectivas puede clasificarse el tipo de defectos y compararse con información histórica para hacer predicciones de calidad de posibles defectos. Para cada clase de falla la densidad se mide como el radio entre el número de fallas encontradas y el tamaño del programa.
• Para determinar cuando detener las pruebas puede estimarse estadísticamente la robustez del software. Existen modelos de crecimiento de robustez basados en cuenta de fallas y en tiempo entre fallas.

• Puede medirse el radio entre los elementos cubiertos con pruebas y el total de elementos (e.g porcentaje de caminos cubiertos del grafo de flujo).
• Es posible insertar fallas artificiales (semillas de fallas) buscando que estas ayuden a descubrir fallas reales. Con este procedimiento se puede evaluar la efectividad de las pruebas.
• En las pruebas de mutación el radio entre mutantes eliminados sobre total de mutantes generados puede medir la efectividad de las pruebas.

2.2.7  Proceso de pruebas

Consideraciones prácticas

Actividades de prueba

• Planeación: Incluye coordinación de personal, administración de facilidades y equipos de prueba, planeación de resultados indeseables.
• Generación de casos de prueba: depende del nivel de pruebas, y las técnicas de pruebas. Los casos de prueba deberían estar bajo el control de un software para administración de configuraciones e incluir el resultado esperado de cada prueba.
• Desarrollo del ambiente de pruebas: El ambiente debe facilitar desarrollo y control de casos de prueba, registro y recuperación de resultados esperados, scripts y otros materiales de prueba.
• Ejecución: Todo lo realizado durante las pruebas debe ser documentado. Las pruebas deben hacerse de acuerdo a procedimientos documentados usando una versión claramente definida del programa a probar.
• Evaluación de los resultados de pruebas: Podría ser realizada por un equipo evaluador formal.
• Reporte de problemas/registro de pruebas: Las actividades pueden registrarse en una bitácora que identifique cuando se realizó la prueba, quien la realizó, cual fue la base y otros datos. Los resultados no esperados pueden ser registrados en un sistema para reportar problemas.
• Seguimiento de defectos: Los defectos pueden analizarse para determinar cuando fueron introducidos, que error los causo y cuando pudieron ser observados por primera vez. El seguimiento de esta información se usa para determinar los aspecto de la ingeniería de software que necesitan mejorar y para medir la efectividad de análisis y pruebas previas.

2.2.8  Hacía la práctica: Pruebas de unidades

cc -c hash.c
cc -c prueba_hash.c
cc -o prueba_hash hash.o prueba_hash.o /usr/local/lib/libcheck.a

2.2.9  Lecturas recomendadas

2.2.10  Ejercicios para afianzar teoría

1. Revise la documentación bien de junit o bien de cppunit y describa como usaría una de estas herramientas para hacer pruebas de unidades.
   
   
2. En sistemas tipos Unix y en el caso de programas escritos en C, es posible medir cubrimiento de pruebas sobre las fuentes usando la herramienta gcov y con los flags -fprofile-arcs -ftest-coverage del compilador gcc. Consulte la documentación de este programa y explique como puede usarlo para medir cobertura de las pruebas que se sugieren en el primer ejercicio de programación (ver más adelante).

2.2.11  Ejercicios de programación

1. Es posible representar conjuntos de enteros usando bits de un entero. Esto se ha implementado en el módulo disponibles en
   http://structio.sourceforge.net/guias/ayudadesprog/conjuntos.c y http://structio.sourceforge.net/guias/ayudadesprog/conjuntos.h
   
   Descargue conjunto.h y conjunto.c de
   http://structio.sourceforge.net/guias/ayudadesprog/contrib/conjuntos.c
   
   Diseñe e implemente pruebas de unidad para ese módulo usando check.

2.3  Administración de configuraciones de Software

• INDICADOR: Conoce términos y definiciones relacionados con administración de configuraciones
• INDICADOR: Conoce y emplea CVS para controlar versiones.

2.3.1  Teoría

2.3.2  Manejo y planeación del proceso de ACS

2.3.3  Identificación de la configuración del software

2.3.4  Control de la configuración del software

2.3.5  Registro del estado de la configuración del software

2.3.6  Auditoría a la configuración de software

Manejo y distribución de entregas de software

2.3.7  Hacía la práctica: Herramientas y CVS

• Herramientas para seguir defectos, mejoras y problemas. Algunos ejemplos de este tipo de herramientas son: Bugzilla http://www.bugzilla.org/ y Scarab http://scarab.tigris.org/.
• Herramientas para el control de versiones. RCS es una herramienta para control de versiones de archivos (típicamente incluida en sistemas tipo Unix); CVS permite controlar versiones de jerarquías de directorios y sus archivos de forma distribuida como se explica más adelante; subversion busca dar la misma funcionalidad de CVS con algunas ventajas⁸
• Herramientas para la construcción y liberación de entregas.

2.3.8  CVS

1. Hay un repositorio central donde está la copia ``oficial'' más actualizada. Usted ha configurado las variables de ambiente CVSROOT y CVS_RSH con la localización del repositorio y el programa para ingresar a la máquina donde está. Las posibilidades son:
   • Si el repositorio está en la misma máquina en la que usted está trabajando por ejemplo en el directorio /var/cvs:

     export CVS_RSH=""
     export CVSROOT=/var/cvs
     

   • Si el repositorio está en un directorio en otra máquina, y la otra máquina tiene un servidor ssh o rsh y usted tiene cuenta en esa máquina (o su clave pública ssh está autorizada en alguna cuenta de esa máquina). Suponiendo que la otra máquina es purpura.micolegio.edu.co, que cuenta con ssh , que el repositorio está en el directorio /home/pepe/cvs, y que en esa máquina usted puede usar con ssh la cuenta pepe:

     export CVS_RSH=ssh
     export CVSROOT=pepe@purpura.micolegio.edu.co:/home/pepe/cvs
     

   • Si el repositorio está en un directorio de otra máquina, el protocolo pserver de CVS funciona en esa máquina y usted tiene una cuenta en esa máquina o está autorizado para usar pserver en el repositorio:

     export CVS_RSH=""
     export CVSROOT=:pserver:pepe@purpura.micolegio.edu.co:/home/pepe/cvs
     cvs login
     

   
   
   
2. Cada desarrollador debe obtener una copia de ese repositorio y dejarla en su cuenta para trabajarla. Esto es hacer un checkout, por ejemplo para obtener una copia local del módulo quimica:

   cvs checkout quimica
   

   En lugar de checkout puede emplear co. Si lo requiere puede pasar opciones generales a CVS antes de checkout (como -z3 que indica transmitir información comprimida):

   cvs -z3 co quimica
   

   
   
   
3. Cada desarrollador con alguna frecuencia debe actualizar su copia local con respecto a la del repositorio central, para mantener al día su copia con los cambios más recientes introducidos por otras personas. Esto es hacer un update (es importante que lo haga antes de comenzar a hacer cambios a su copia local). Por ejemplo puede usar:

   cvs -z3 update -Pd
   

   Note que en este comando la opción -z3 es una opción general de CVS, mientras que -Pd es particular a update (indica que no deben agregarse a la copia local directorios que estén vacíos en el repositorio).
   
   
4. Cada desarrollador trabaja en su copia personal, y cuando completa una parte del trabajo (mejor asegurándose de no introducir errores), publica la actualización junto con un comentario (en el siguiente ejemplo es ``Ortografía corregida''):

   cvs commit -m "Ortografía corregida"
   

   Eventualmente al intentar esta operación, si otro usuario realizó una actualización primero que tiene alguna diferencia con respecto a los cambios que se quieren agregar, CVS detecta el conflicto, modifica el archivo para resaltar los conflictos y permite solucionar el conflicto antes de permitir esta operación. Por ejemplo un conflicto puede verse como:

   <<<<<<1.3                                                                  
   la presion interna de un gas es directamente proporcional a su temperatura.
    -------                                                                   
   La presión interna de un gas es inversamente proporcional a la temperatura
   >>>>>>
   

   Para solucionar el conflicto elimine las líneas que CVS agregó y deje la versión más precisa (o mézclelas), para este caso sólo quedaría:

   La presión interna de un gas es directamente proporcional a la temperatura.
   

cd ~
mkdir cvs
cd cvs
export CVS_RSH=""
export CVSROOT=/home/pepe/cvs
cvs init

export CVS_RSH=""
export CVSROOT=/home/pepe/cvs

cd ~/quimica
cvs import laquimica start vendor

2.3.9  Manejo de configuraciones y programación extrema

1. Proceso de planeación: permite al cliente definir el valor de negocio de cada característica, y usa estimativos de costo dados por los programadores, para escoger lo que se necesita hacer y lo que necesita ser postergado.
2. Pequeñas entregas: El equipo de PE (Programación extrema) pone un sistema simple en producción pronto, y lo actualiza con frecuencia en un corto ciclo.
3. Metáforas: El equipo de PE usa un sistema de nombres común y un sistema común de descripción que guía el desarrollo y la comunicación.
4. Diseño simple: Un programa desarrollado con PE debe ser el más simple que cumple con los requerimientos actuales. No hay mucha construcción ``para el futuro''. Obviamente es necesario asegurar un buen diseño, que en PE se buscan refactorizando.
5. Probar: El equipo de PE se enfoca en la validación del software todo el tiempo. Los programadores desarrollan software escribiendo primero las pruebas, entonces el software que cumple los requerimientos reflejados en las pruebas. Los clientes proveen pruebas de aceptación que les permite asegurarse de que las características que necesita están.
6. Refactorizar: El equipo de PE mejor el diseño del sistema durante todo el desarrollo. Esto se hace manteniendo el software limpio sin duplicar, con alta comunicación, simple y sin embargo completo.
7. Programación en parejas: Los programadores PE escriben todo el código de producción en parejas, dos programadores trabajan juntos en una máquina.
8. Propiedad colectiva: Todo el código pertenece a todos los programadores. Esto permite que el equipo vaya a velocidad total, porque cuando algo necesita ser cambiado, puede cambiarse sin demora.
9. Integración continua: Los equipos de PE integran y manufacturan el sistema de software múltiples veces al día. Esto mantiene a todos los programadores en la misma página y permite un progreso rápido. Al integrar con más frecuencia se tiende a eliminar los problemas de integración que plagan equipo que integran con menos frecuencia.
10. Semanas de 40 horas: Los programadores cansados cometen más errores. Los equipos PE no trabajan tiempo excesivo, manteniéndose frescos, saludables y efectivos.
11. Cliente en el sitio: Un proyecto de PE es guiado por un individuo dedicado que puede determinar requerimientos, poner prioridades, contestar preguntas cuando los programadores las tienen. El efecto de estar ahí es que la comunicación mejora, con menos documentación --a menudo una de las partes más costosas de un proyecto de software.
12. Estándar de programación: Para que un equipo trabaje efectivamente en parejas, y para compartir la propiedad del código, todos los programadores necesitan escribir el código de la misma forma, con reglas que aseguren que el código se comunica claramente.

2.3.10  Lecturas recomendadas

2.3.11  Ejercicios

1. Revise la infraestructura de http://structio.sourceforge.net (se sugiere que abra una cuenta para que pueda explorarla mejor), identifique y describa las herramientas ayudas ofrecidas para realizar: (1) seguimiento de defectos, mejoras y problemas (2) control de versiones (3) manufactura, (4) liberación de entregas.
   
   
2. Usando CVS saque la versión estable de Bugzilla del repositorio CVS. Vea la sección `Initial Checkout' en http://www.bugzilla.org/download/
   
   
3. En un sistema tipo Unix cree un repositorio para CVS, importe un módulo y después extraigalo.

2.4  Calidad de software

• INDICADOR: Conoce términos y definiciones relacionados con calidad de software
• INDICADOR: Conoce y emplea técnicas para asegurar calidad del código (assert, chequeadores estáticos de código).

2.4.1  Teoría

Procesos de administración de la calidad del software

• Proceso de aseguramiento de calidad: Aseguran que el problema esta planteado de forma clara y adecuada y que los requerimientos están definidos y expresados apropiadamente. El plan de aseguramiento de calidad define los medios usados para asegurar que el software desarrollado satisface los requerimientos del usuario y que es de la más alta calidad posible dentro de las restricciones del proyecto. Este plan identifica documentos, estándares, prácticas y convenciones que gobiernan el proyecto y la forma como son chequeados y monitoreados para asegurar que son apropiados y que se cumplen.
  
  
• Proceso de verificación y validación: La verificación intenta asegurar que el producto se construye correctamente, en el sentido que los productos de salida de una actividad cumplan las especificaciones impuestas en actividades previas. La validación intenta asegurar que se construye el producto correcto. Un plan de V&V describe los recursos y sus roles y actividades, así como las técnicas y herramientas por usar.
• Procesos de revisión y auditorías
  • Revisiones de administración: Monitorear progreso, determinar estado de planes y cronogramas, confirmar requerimientos y su localización en el sistema, o evaluar la efectividad de las aproximaciones administrativas. Apoyan la toma de decisiones sobre cambios y acciones correctivas. Determinan lo adecuados que son los planes, cronogramas y requerimientos. Pueden hacerse sobre productos como reportes de auditorías, de progreso, reportes de V&V y sobre diversos tipos de planes incluyendo manejo de riesgo, administración del proyecto, administración de configuraciones de software.
  • Revisiones técnicas: Evalúa un producto de software para determinar lo apropiado que resulta para el uso que se le espera dar. Busca identificar discrepancias entre especificaciones aprobadas y estándares. Deben establecerse roles específicos: quien toma decisión, líder de revisiones, quien lleve registros, apoyo técnico para apoyar las actividades de revisión. Las siguientes entradas deben ser establecidas: establecimiento de objetivos, un producto de software específico, los planes de administración específicos, la lista de reportes asociados con el producto, el procedimiento de revisión técnica.
  • Inspecciones: su propósito es detectar e identificar anomalías en un producto de software. A diferencia de las revisiones son de unas pocas horas y centradas en porciones específicas. Incluyen al autor de un producto final o intermedio, un líder de inspección, alguien que lleve el registro, alguien que lea, y unos pocos inspectores (2 a 5). Cada miembro del grupo examina el producto de software y otros insumos para aplicar alguna técnica analítica a una pequeña porción del producto, o al producto entero enfocándose sólo en un aspecto. Cualquier anomalía encontrada es documentada y enviada al líder de inspecciones. La lista de chequeo resultante de la inspección clasifica las anomalías y es revisada por el equipo. Estas inspecciones arrojan como resultado uno de estos criterios: aceptado sin o con mínimo trabajo adicional; aceptado con verificación de trabajo adicional; más inspección es requerida.
  • Recorridos: Evalúan un producto de software, pueden hacerse para educar una audiencia en un producto de software. Buscan encontrar anomalías, mejorar producto de software, considerar implementaciones alternativas, evaluar cumplimiento de estándares y especificaciones. Es principales organizada por el ingeniero de software para dar a sus compañeros de equipo la oportunidad de revisar su trabajo, como técnica de aseguramiento.
  • Auditorías: Dan una evaluación independiente del cumplimiento de productos de software y procesos a las regulaciones, estándares, lineamientos, planes y procedimientos aplicables. La auditoría identifica instancias que no cumplen requerimientos y produce un informe el cual requiere del equipo acciones correctivas. Pueden hacerse a casi cualquier producto en cualquier etapa de desarrollo o mantenimiento.
  
  

2.4.2  Consideraciones prácticas

• Para requerimientos de calidad de software: factores que influyen (e.g dominio del sistema, requerimientos de software y sistema, componentes comerciales o estándares por usar, etc.); robustez, niveles de integridad del software
• Caracterización de defectos
• Técnicas para manejar calidad de software
  • Técnicas estáticas: examinan documentación del proyecto y software sin ejecutarlo. Pueden hacerse con o sin asistencia de herramientas que automaticen. Lectura de código.
  • Técnicas intensivas en personas: Incluyen revisiones y auditorías y otras técnicas en grupos de dos o más personas. Requieren preparación antes de reuniones, y puede hacer uso de listas de chequeo y resultados de técnicas analíticas o de pruebas.
  • Técnicas analíticas: incluyen análisis de complejidad, análisis de control de flujo y análisis de algoritmos. Métodos formales para verificar requerimientos de software y de diseños. Pruebas de corrección.
  • Técnicas dinámicas: Usualmente son técnicas para probar (aunque puede incluirse simulación, model checking y ejecución simbólica).
  • Pruebas: una organización independiente de V&V podría monitorear el proceso de pruebas. También podría realizar ``pruebas por terceros.''
• Medidas de la calidad de software. Entre las posibles están:
  • Basadas en estadísticas: permiten mostrar áreas problemáticas. Las gráficas resultantes y las ayudas visuales ayudan a quienes toman decisiones.
  • Predicción: ayuda a planear tiempo de pruebas y a predecir fallas.
  • Análisis de tendencias: indican cuando un cronograma no se ha respetado, o que cierto tipo de fallas serán más intensas a menos que se tomen acciones correctivas.

2.4.3  Hacía la práctica

Ética

De basarse en fuentes ya existentes (bien sea copiando, modificando, resumiendo o inspirándose) recuerde dar los créditos para que otras personas puedan consultar lo que usted consultó o para no incurrir en plagio.

Para copiar o modificar porciones considerables de una fuente ya existente tenga en cuenta:

1. Verifique que los términos de reproducción permitan la copia/modificación (normalmente las fuentes incluyen los términos de reproducción al comienzo de cada archivo o en un archivo separado e.g Derechos.txt, COPYING, RIGHTS).
2. Cumpla con los requisitos de los términos de reproducción, por ejemplo si es el caso transcriba y mantenga los términos de reproducción de la fuente original en la suya.
3. De el crédito al autor o autores.
4. Para que otras personas puedan consultar la fuente, cite el sitio donde puede encontrarse (e.g un URL).

En el caso de documentos, si los términos de reproducción de un documento que desee copiar o modificar no permite copia o modificación, tiene opciones legalmente válidas:

• Copiar textualmente porciones minoritarias no consecutivas[4] a manera de citas, eventualmente mejorando ortografía y anotando autores y procedencia (no se es autor de lo que se copia o se corrige ortograficamente).
• Emplear el material como referencia junto con otras fuentes para crear un documento propio del cual usted será el/la autor(a) y que tendrá como bibliografía las fuentes en las que se base.

Si está haciendo un material en la que usted es el/la autor(a), sugerimos que escriba explícitamente que usted es el/la autor(a) y:

• Esfuércese por dar crédito a las fuentes en las que se base. No copie textualmente ni haga simplemente cambios a otra fuente sin dar crédito o incurriría en plagio. El nuevo material debe ser resultado del estudio de diversas fuentes (cuyo crédito debe darse), de la organización y síntesis sistemática y de su consecuente inspiración.
• Si hace la obra bajo un contrato de trabajo, la organización contratante será propietaria de los derechos de reproducción (a menos que indique explícitamente lo contrario en un documento público). Será por tanto la organización la que pueda asignar o cambiar los derechos de reproducción de la obra. Eventualmente puede sugerir a su organización emplear términos de reproducción que promuevan dar desinteresadamente (como ceder al dominio público). Revise que no haya inconsistencias entre los derechos de reproducción, caso que podría darse si algunas porciones tienen derechos de reproducción particulares, por ejemplo como consecuencia de copiarlas de fuentes que permiten libre copia o modificación.
• Invitamos a dar desinteresadamente. A los propietarios de derechos de reproducción de obras los invitamos a emplear términos de reproducción que promuevan este valor (por ejemplo dominio público licencias BSD y MIT). Así mismo lo invitamos a difundir sus obras para que puedan llegar a quienes las necesitan por ejemplo publicándolas en Internet, y anunciándolas en diversos medios. También invitamos a realizar campañas y educar en la promoción de la ética, de la solidaridad y del respeto por los derechos morales y patrimoniales de las obras intelectuales.

Si tiempo después de haber creado o contribuido en una obra, detecta inconsistencia entre términos de reproducción o ausencia de créditos, es preferible corregirlos. Así evitará incurrir en plagio o infringir derechos de reproducción (consideramos que es errado oscurecer la verdad o mentir, además son ilegales el plagio e infringir derechos de reproducción).

Análisis estático: Verificación de programas y aserciones intermedias

if (x<0) {
        y=-x;
} 
else {
        y=x;
}

assert(x>0);
if (x<0) {
 y=-x;
} 
else {
 y=x;
}
assert(y==x);

Análisis estático: Chequeadores de código fuente

2.4.4  Lecturas recomendadas

2.4.5  Ejercicios

1. Consulte la documentación de splint y use este programa para chequear uno de sus programas en C.
   
   
2. Busque la documentación de jlint y úselo para chequear estáticamente uno de sus programas en Java. Opcional: Use antic con una fuente en C++ http://www.bugzilla.org/download/
   
   
3. Escoja uno de los programas que ha desarrollado, uno que emplee funciones y agrega a cada función algunas precondiciones y algunas poscondiciones con assert.

2.5  Mantenimiento de software

• INDICADOR: Conoce términos y definiciones relacionados con mantenimiento de software
• INDICADOR: Conoce y emplea técnicas para facilitar mantenimiento de software (assert, chequeadores estáticos de código).

2.5.1  Teoría

• Corregir fallas
• Mejorar el diseño
• Implementar mejoras
• Hacer interfaces con otros sistemas
• Adaptar el programa para pode usar diferentes facilidades de hardware, software, sistema y telecomunicaciones.
• Migrar software legado
• Retirar software

• Mantenimiento correctivo: modificaciones por reacción a productos de software, realizadas después de la entrega para corregir problemas corregidos.
• Mantenimiento adaptativo: modificación después de la entregado para mantenerlo utilizable en un ambiente cambiante.
• Mantenimiento perfectivo: modificación después de la entrega para mejorar desempeño o mantenibilidad.
• Mantenimiento preventivo: modificación después de la entrega para detectar o corregir fallas latentes antes de que se conviertan en fallas efectivas.

Aspectos claves en el mantenimiento del software

• Entendimiento limitado: Se refiere a la dificultad de hacer cambios a software no desarrollados por quien hace el cambio. Se ha estimado que entre el 40% y 60% del esfuerzo de mantener se dedica a entender el software por modificar.
• Pruebas: El costo de repetir pruebas en una pieza de software grande puede ser significativo en tiempo y dinero. Son muy importantes las pruebas de regresión en la etapa de mantenimiento para asegurar que las modificaciones no han causado efectos no intencionales.
• Análisis de impacto: Quien mantiene un programa debe tener un conocimiento de la estructura y contenido del software para realizar un análisis de impactos que identifique los sistemas y productos de software afectados por una solicitud de cambio y estimar los recursos necesitados para efectuar el cambio. La solicitud de cambio (llamada requerimiento de modificación o reporte de problema), debe ser analizada y traducida a términos de software. Los objetivos del anàlisis son:
  • Determinar el alcance de un cambio para planear e implementar el trabajo.
  • Desarrollar estimativos precisos sobre los recursos requeridos para realizar el trabajo.
  • Analizar el costo/beneficio del cambio requerido.
  • Comunicar a otros la complejidad de un cambio.
  Deben darse diversas soluciones potenciales y hacerse una recomendación sobre el mejor curso de acción. El software desarrollado con mantenibilidad en mente facilita el análisis de impacto.
• Mantenibilidad: es definida como un característica de calidad. Una de las causas principales de su ausencia es mala documentación que conlleva a la dificultad de comprensión.

• Alineamiento con objetivos organizacionales: entre los objetivos organizacionales debe estar, demostrar el retorno de inversión del mantenimiento de software.
• Equipo: se refiere a como atraer y mantener al equipo que hace mantenimiento.
• Proceso: las actividades requeridas para hacer mantenimiento son un reto administrativo.
• Aspectos organizacionales: organización o función responsable del mantenimiento (no necesariamente son quienes lo desarrollan).
• Contratación externa (outsourcing): es una opción elegida para software de misión no crítica (pues las compañías no desean perder el control del software que usan como núcleo de su negocio).

2.5.2  Proceso de mantenimiento

1. Requerimiento de modificación
2. Clasificación e identificación
3. Análisis
4. Diseño
5. Implementación
6. Pruebas del sistema
7. Pruebas de aceptación
8. Entrega
9. Vuelve a 2.

1. Análisis del problema y de modificaciones
2. Implementación de modificaciones
3. Aceptación/revisión del mantenimiento

• Transición
• Modificación
• Escritorio de ayuda para Requerimiento de modificación y reporte de problemas.
• Análisis de impacto
• Soporte de software (ayuda y recomendación a usuarios).
• Acuerdos a Nivel de Servicios¹³ y contratos de mantenimiento específicos.

• Plan del negocio (organizacional)
• Plan de mantenimiento (transición): como el mantenimiento puede durar años, primero debe hacerse un documento de conceptos con
  • El alcance del mantenimiento
  • La adaptación del proceso de mantenimiento
  • La identificación de la organización que hace el mantenimiento
  • Un estimado de los costos de mantenimiento
  El plan de mantenimiento debe especificar como los usuarios realizarán requerimientos de modificación o como reportaran problemas.
  
  
• Plan de versiones/entregas (programa): requiere de quien hace el mantenimiento:
  • Coleccionar fechas de disponibilidad de requerimientos individuales
  • Acordar con usuario el contenido de las siguientes entregas/versiones
  • Identificar conflictos potenciales y desarrollar alternativas
  • Medir el riesgo de una entrega y desarrollar un plan de emergencia en caso de que se presenten problemas
  • Informar a los inversionistas
  
  
  
• Plan de requerimientos de cambio individuales (nivel de requerimientos): s realiza durante el análisis de impactos.

2.5.3  Técnicas de mantenimiento

• Los navegadores de código ayudan a comprender el código, así como una documentación clara y concisa.
• La reingeniería se define como el examen y alteración de software para reconstituirlo de una manera nueva. Usualmente no se lleva a cabo para mejorar la mantenibilidad sino para remplazar software legado.
• Ingeniería reversa es el proceso de analizar software para identificar sus componentes e interrelaciones y para crear representaciones del software de otras maneras con niveles más altos de abstracción. Es una técnica pasiva que no modifica el software, ni que resulta en nuevo software. Los esfuerzos de este tipo de ingeniería producen: grafos de llamados, grafos de flujo de control. Otro tipo de ingeniería reversa es re-documentación, otro es recuperación del diseño. Refactorizar es una transformación a un programa para reorganizarlo sin cambiar su comportamiento, es una forma de ingeniería reversa que busca mejorar la estructura del programa. La ingeniería reversa de datos buscar recuperar esquemas lógicos a partir de bases de datos físicas.

2.5.4  Lecturas recomendadas

2.5.5  Ejercicios

1. Busque y pruebe alguna herramientas para facilitar la comprensión de código.
   
   
2. Busque y pruebe alguna herramientas para hacer ingeniería reversa.

2.6  Diseño de software

• INDICADOR: Conoce términos y definiciones relacionados con diseño de software
• INDICADOR: Conoce y emplea técnicas y herramientas para facilitar diseño de software.

2.6.1  Teoría

• Abstracción: proceso de olvidar información para que cosas diferentes puedan ser tratadas como iguales. En diseño dos formas claves son parametrización y especificación.
• Acoplamiento y cohesión: Acoplamiento es fuerza de vínculos entre módulos, cohesión es la relación entre los elementos que forman un módulo.
• Descomposición y modularización: descompone un software grande en partes independientes poniendo funcionalidades o responsabilidades en cada parte.
• Encapsular/esconder información: significa agrupar y empaquetar los elementos y detalles internos de una implementación para hacerlos inaccequibles y mejorar abstracción.
• Separación de interfaces e implementación: se trata de definir un componente especificando una interfaz pública que puede ser usada por componentes clientes, los cuales no deben preocuparse por detalles de la implementación del componente que usan sino sólo por cumplir requisitos de la interfaz.
• Suficiencia, completitud y primitivas: significa asegurar que el componente captura todas las características importantes de una abstracción y nada más.

Puntos claves en el diseño de software

• Concurrencia: Como descomponer el software en procesos, tareas e hilos de ejecución.
• Control y manejo de eventos: Como organizar datos y flujo de control, como manejar eventos temporales y reactivos con mecanismos como invocación implícita y call-backs.
• Distribución de componentes: Como distribuir software sobre el hardware, como se comunican los componentes.
• Manejo de errores y excepciones y tolerancia a fallas: Como prevenir y tolerar fallas y manejar condiciones excepcionales.
• Interacción y presentación: Como estructurar y organizar la interacción con usuarios y la presentación de información. No es especificar interfaz de usuario.
• Persistencia de datos: Como manejar información que debe perdurar.

Estructura y arquitectura de software

• Estructura general (capas, tuberías y filtros, tablero)
• Sistemas distribuidos (cliente-servidor, tres capas, broker)
• Sistemas interactivos (Controlador modelo-vista, Control de presentación-abstracción)
• Sistemas adaptables (micro-kernel, reflección)
• Otros (por ejemplo, proceso en lotes, interpretes, control de procesos, basados en reglas)

Evaluación y análisis de la calidad del diseño

• Revisiones de diseño de software: en grupo, informales o semiformales aseguran calidad de artefactos de software (revisión de arquitectura, revisiones e inspecciones de diseño, técnicas basadas en escenarios, seguimiento de requerimientos).
• Análisis estático: formal o semiformal para evaluar un diseño (análisis libre de fallas, chequeo cruzado automático).
• Simulación y prototipos: técnicas dinámicas (simulación de desempeño o prototipo de viabilidad),

• Medidas orientadas a la función del diseño: se trata de medidas que pueden computarse sobre una descomposición funcional de un diseño.
• Orientadas a objetos: pueden computarse métricas sobre un diseño representado como diagrama de clases. También hay métricas sobre el contenido interno de cada clase.

Notaciones para diseño de software

• Lenguajes de descripción de arquitectura: son textos formales, describen en términos de componentes y conectores
• Diagrama de clases y objetos: conjunto de clases y sus relaciones.
• Diagrama de componentes: representa conjunto de componentes, un componente es "una parte física y reemplazable de un sistemas que provee y cumple la realización de un conjunto de interfaces."
• Tarjetas de colaboración en responsabilidades: se usan para denotar los nombres de componentes (clases), sus responsabilidades, y los nombres de componentes que colaboran.
• Diagrama de entrega: representa nodos físico y sus relaciones, para modelar aspectos físicos de un sistema.
• Diagramas entidad-relación: se usan para representar modelos conceptuales de datos almacenados en sistemas de información.
• Lenguajes de descripción de interfaces: lenguajes como de programación usados para definir interfaces de componentes.
• Diagramas de estructuras de Jackson: describe estructuras de datos en términos de secuencia, selección e iteración.
• Gráficas de estructura: describen estructura de llamados de un programa (que módulo llama a cual).

• Diagramas de actividades: muestra el flujo de control de una actividad a otra.
• Diagramas de colaboración: interacciones que ocurren entre un grupo de objetos, donde el énfasis está en los objetos, sus enlaces y los mensajes que intercambian.
• Diagrama de flujo de datos: muestra flujo de datos entre un conjunto de procesos.
• Diagramas y tablas de decisión: representan combinaciones complejas de condiciones y acciones.
• Diagramas de flujo: representa flujo de control y las acciones asociadas por realizar.
• Diagramas de secuencia: muestran interacción entre un grupo de objetos, con énfasis en el ordenamiento de mensajes en el tiempo.
• Diagramación de transición de estados: muestran control de flujo de un estado a otro en una máquina de estados.
• Lenguajes para especificación formal: lenguajes textuales y formales para definir y abstraer rigurosamente interfaces de componentes y comportamiento, usualmente en términos de precondición y poscondición.
• Pseudo-código y lenguajes para diseño de programas: lenguajes como de programación, estructurales para describir comportamiento de un procedimiento o método.

Estrategias y métodos para diseño de software

2.6.2  Lecturas recomendadas

2.6.3  Ejercicios

1. Consulte la documentación de splint y use este programa para chequear uno de sus programas en C.
   
   
2. Busque la documentación de jlint y úselo para chequear estáticamente uno de sus programas en Java. Opcional: Use antic con una fuente en C++ http://www.bugzilla.org/download/
   
   
3. Escoja uno de los programas que ha desarrollado, uno que emplee funciones y agrega a cada función algunas precondiciones y algunas poscondiciones con assert.

1

Es común que haya requerimientos contradictorios propuestos por diversos actores. El especialista de requerimientos buscará negociar requerimientos entre los diversos interesados teniendo en cuenta otras restricciones económicas, técnicas, regulatorias.

2

Suponiendo que en cada semana no hubiera distracciones, ni otras obligaciones y que supiera que hacer con exactitud.

3

Las responsabilidades específicas de un ACS necesitan ser asignadas a entes de la organización. Así mismo deben identificarse autoridad general y canales para reportar.

4

Los recursos y cronogramas deben estar relacionados con el cronograma del proyecto y las metas establecidas. Por ejemplo los requerimientos de entrenamiento para implementar el plan o para miembros nuevos debe especificarse.

5

Las herramientas pueden ser combinación de herramientas manuales y automáticas. Pueden permitir medir para mejorar el proceso. Pueden proveer soporte para: la librería de ACS, peticiones de cambios al software y procedimientos de aprobación, tareas de cambio en el código, reportes al estado de configuración y recolección de medidas, auditoría a la configuración de software, manejo y seguimiento a la documentación, realización de la manufactura del software, manejo y seguimiento de entregas y su distribución.

6

Cuando un elemento de software hace interfaz con otro software o hardware, un cambio en uno puede afectar al otro. En la planeación de ACS deben identificarse elementos interfaces y como se manejaran y comunicaran cambios en estos.

7

que típicamente describen nuevas capacidades, problemas conocidos y requerimientos de plataforma

8

Versiones para directorios, renombramientos y permisos. Más eficiente.

9

El archivo de claves para CVS cuando se usa pserver tiene 2 o 3 campos, el primero es el nombre con el que se conectará el usuario, el segundo la clave encriptada con DES y el tercer opcional es el nombre del usuario local a nombre del cual modificará el repositorio. Este archivo puede administrarse con htpasswd, para crear el archivo con un primer usuario: htpasswd -c pepe y posteriormente para agregar otros usuarios htpasswd agustin

10

La parte teórica de esta guía es traducción de apartes de [6].

11

Usando un cálculo apropiado (i.e cálculo de Hoare) con axiomas para cada posible sentencia del lenguaje.

12

Traducido así como otras partes de esta guía de [6].

13

Del inglés Service Level Agreements (SLA).

14

Traducido así como la mayoría de la sección teórica de esta guía de [6].

15

Un componente de software es una unidad independiente, con una interfaz y dependencias, puede componerse y entregarse de manera independiente.

Bibliografía

[1]

Javatm 2 platform std. ed. v1.3.1. http://java.sun.com/j2se/1.3/docs/api/index.html.

[2]

Working paper for draft proposed international standard for information systems-- programming language c++. http://ra.dkuug.dk/jtc1/sc22/open/n2356/, 1997.

[3]

Programming languages -- c. borrador del estándar c99. http://www.open-std.org/jtc1/sc22/open/n2794/n2794.txt, 1998.

[4]

Xprogramming.com: an extreme programming resource. http://www.xprogramming.com/, 2003.

[5]

The java tutorial. http://java.sun.com/docs/books/tutorial/, 2004.

[6]

Swebok: Guía al cuerpo de conocimiento en ingeniería de software. http://www.swebook.org, 2004.

[7]

Mehdi Achour, Friedhelm Betz, Antony Dovgal, and ... Manual de php. http://www.php.net/manual/es/.

[8]

Ulf Asklund, Lars Bendix, and Torbjörn Ekman. Configuration management for extreme programming. http://www.cs.lth.se/ bendix/Publications/ABE03/CM4XP.pdf.

[9]

Rodrigo Cardoso. Verificación y Desarrollo de Programas. 1993.

[10]

Per Cederqvist. Version management with cvs. https://www.cvshome.org/docs/manual/, 2004.

[11]

Jaime Irving Dávila. Wincvs: Un taller para comenzar. http://es.tldp.org/Tutoriales/WINCVS/html/, 2002.

[12]

James Gosling, Bill Joy, Guy L. Steele, and Gilad Bracha. The Java Language Specification. http://java.sun.com/docs/books/jls/, 2000.

[13]

Brian W. Kernighan and Rob Pike. La Práctica de la Programación. 2000.

[14]

Vladimir Támara Luis Alejandro Bernal. Curso gratuito y virtual de c. http://uvirtual.ean.edu.co/vtamara/cvirt2001/, 2001.

[15]

Vladimir Támara P. Apuntadores en c. http://structio.sourceforge.net/guias/ayudadesprog/apuntadores-c.sxw, 1997.

[16]

Vladimir Támara Patiño, Igor Tamara, Jaime Irving Dávila, and Pablo Chamorro. Aprendiendo a aprender linux. http://structio.sourceforge.net/guias/AA_Linux_colegio, 2003.

[17]

Wyatt Sutherland. An xp diary. http://www.xprogramming.com/xpmag/xpdiary.htm, 2002.

[18]

Igor Támara, Gustavo Ospina, Jahir Tocancipa, and Vladimir Támara. Manual de uso de repasa. http://structio.sourceforge.net/repasa/docusuario/index.html.

[19]

Don Wells. Extreme programming: A gentle introduction. http://extremeprogramming.org/, 2003.

Index

This document was translated from L^AT_EX by H^EV^EA.