Download I n t r o d u c c i ó n a l o s L e n g u a j e s d e P r o g r a m a c i ó n

Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
La importancia del uso de Buenas prácticas en la escritura
de programas.
Limpieza, Legibilidad o Claridad del Código
Respetar los estándares establecidos.
Documentación del Código.
Programando correctamente
Estructura correcta de un programa.
Ejemplo de un programa en C, siguiendo estas normas.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Buenas Prácticas en la escritura de Programas.
¿ Cuándo un programa esta bien escrito ?
¿ Qué estilo de programación utilizamos ?
¿ Cuándo se escribe un programa, es necesario seguir
alguna guía ?
¿ Es importante que los programadores entiendan
código de otros programadores ?
¿ Es necesario la documentación de un programa ?
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
¿ Cuándo un programa esta bien escrito ?
Estándares de escritura de programas en ciertos lenguajes de
programación en particular.
Normas de programación, recomendables para la escritura de
todos nuestros programas en lenguaje de programación C.
Estilo.
Indentación.
Anchos de código.
Espacios y Llaves.
Notación, convención y consistencia de nombres.
Todos los lenguajes poseen su manual de Referencia.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Estilo
El estilo de programación se refiere a la forma en que se da
formato al código fuente (programa).
Una buena pauta en el estilo de programación es crear código
legible y consistente.
Pensar antes de Programar.Los programadores deben tomar decisiones de diseño y
pensar en la solución mas óptima de desarrollo de código,
en papel.
Escribir código es la parte fácil, con una correcta
planificación si utilizas la sintaxis correcta del lenguaje.
Ahorro en horas, hasta días, y hasta semanas con una
planificación previa de desarrollo, “la gran idea”.
Siempre cerca papel y lápiz para cuando llegue la
“inspiración”.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Estilo
Ejemplo.- Se necesita un algoritmo que encuentre el numero
máximo de un conjunto de enteros.
Para encontrar el máximo de un conjunto de enteros positivos.
Se basa en recorrer una vez cada uno de los elementos,
comparándolo con un valor concreto (el máximo entero
encontrado hasta ahora). En el caso de que el elemento actual
sea mayor que el máximo, se le asigna su valor al máximo.
El algoritmo escrito de una manera más formal, tendría el
siguiente aspecto:
ALGORITMO Máximo
ENTRADAS: Un conjunto no vacío de enteros C.
SALIDAS: El mayor número en el conjunto C.
máximo ← -∞
PARA CADA elemento EN el conjunto C, HACER
SI valor_del_elemento > máximo, HACER
máximo ← valor_del_elemento
DEVUELVE máximo
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Indentación.
Es mover un bloque de texto hacia la derecha insertando
espacios o tabuladores para separarlo del texto adyacente.
Esta norma se utiliza para mejorar la legibilidad del código.
Raramente los compiladores o intérpretes consideran los
espacios en blanco entre las sentencias de un programa.
Siempre genera discusiones entre los programadores, sobre
como o donde usar la indentación.
En ciertos lenguajes de programación (Ej. Python, Haskell y
Occam), la indentación se utiliza para delimitar la estructura
del programa, permitiendo establecer bloques de código.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Ejemplo de Indentación en el Lenguaje C.
El siguiente ejemplo muestra por pantalla las tablas de
multiplicar
∉
Sin Indentación:
∉
Con Indentación:
#include <stdio.h>
#include <stdio.h>
int main ()
{
int i, j;
for (i=0;i<=10;i++)
for (j=0;j<=10;j++)
printf("%i x %i = %i\n", i, j, i*j);
return 0;
}
int main ()
{
int i, j;
for (i=0;i<=10;i++)
for (j=0;j<=10;j++)
printf("%i x %i = %i\n", i, j, i*j);
return 0;
}
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Anchos de Código.
El ancho máximo de código es de 78 a 80 caracteres, en C es
de 78 caracteres.
Si alguna línea del código lo supera, ¿ se hace algo ?.
Se pueden añadir tabulaciones o espacios hasta que queden
correctamente alineados.
Ejemplo. A continuación, la definición de una función con sus nombre
sus parámetros largos también.
No se sigue la norma
nuevo_programa_función_con_nombre_largo(parametro1_enorme;
parametro2_enorme);
Se sigue la norma
nuevo_programa_función_con_nombre_largo(parametro1_enorme;
parametro2_enorme);
Introducción a los Lenguajes de Programación.
¿Características
de un Buen
Programa?.
Ejemplo de Ancho de Código en el Lenguaje C.
•
El siguiente ejemplo se define una estructura de tipo número
complejo.
∉
Sin Ancho de Código:
#include <stdio.h>
#define N 10
typedef struct {
double real; /* Parte Real*/
double imag; /* Parte Imaginaria */
} COMPLEJO;
COMPLEJO SumarComplejos (COMPLEJO a[],
int n);
∉
Con Ancho de Código:
#include <stdio.h>
#define N 10
typedef struct {
double real; /* Parte Real*/
double imag; /* Parte Imaginaria */
} COMPLEJO;
COMPLEJO SumarComplejos(COMPLEJO a[],
int n);
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Espacios y Llaves.
Se puede o no, añadir espacios adicionales, antes de la
apertura de un paréntesis y después de una coma (,)
separadora de parámetros. Ejemplo.
Con espacios.
función (parametro1, otra _ función (), parametro2);
Sin espacios
función(parametro1,otra_función(),parametro2);
La apertura y el cierre de llaves en los bloque de programas
también siguen un estilo. Lo mejor es verlo con un ejemplo.
Las condiciones que sólo ejecuten una instrucción pueden
ponerse con o sin llaves, aunque es preferible su uso
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Ejemplo de Espacios y Llaves en el Lenguaje C.
El ejemplo muestra como se elige el menor de tres números.
El segundo ejemplo se muestras la escritura una sola sentencia
sin espacios ni llaves y con estos.
∉
Uso de llaves en C.
float a, b, c, menor;
a=2; b=4; c=1;
if (a < b) {
if (a < c)
menor = a;
else
menor = c;
} else {
if (b < c)
menor = b;
else
menor = c;
}
∉
Una sentencia sin Llaves:
if(NumDiasMes=28)
printf(“El año es bisiesto”);
∉
Una sentencia con Llaves:
if (NumDiasMes = 28 ){
printf (“El año es bisiesto”);
}
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Notación, Convención y Consistencia de Nombres.
Definir la notación de las variables, objetos, métodos y
funciones.
Es importante seguir una buena convención de nombres para
los símbolos de los programas.
Es importante que las variables se nombren de manera
consistente.
Estándares de Notaciones.
Notación Hungara.
Notación PascalCasing.
Notación CamelCasing.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Notación Húngara.
Esta notación es usada por los programadores de Microsoft, y
en particular por la programación de su Sistema Operativo.
También se utilizo en la versiones antiguas de Visual Basic.
Esta notación es un sistema normalmente usado para crear los
nombres de las variables.
El nombre de la notación proviene del hecho de que su inventor
Charles Simonyi nació en Hungría.
Consiste en prefijos en minúsculas que se añaden a los
nombres de las variables, y que indican su tipo y ámbito
Ejemplos.
intEdad: Esta variable representa la Edad de una persona y es del tipo int.
prStrNombre: Esta variable representa un Nombre con valor por referencia (pr) y del
tipo string.
gStrConexion: Esta variable representa un parámetro global del tipo String con
información de Conexión.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Notación PascalCasing.
Es similar a la notación Húngara pero sin el prefijo de tipo.
Los identificadores y nombres de variables, métodos y
funciones están compuestos por múltiples palabras juntas,
iniciando cada palabra con letra mayúscula.
Ejemplo.
MuestraNombre: Esta variable esta conformada por dos palabras cada una empieza
con letra mayúscula, representa el nombre de un método que muestra un nombre.
•
Notación CamelCasing.
Este tipo de notación es común en en lenguaje de
programación JAVA.
Es similar a la notación PascalCasing con la excepción que la
letra inicial del identificador no debe estar en mayúscula.
Ejemplo.
salvaRut: Esta variable esta conformada por dos palabras, la primera toda en
minúscula y la segunda empezando con letra mayúscula, recupera un rut.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Ejemplo del Uso de Notación de variables en el Lenguaje C.
∉
Definiendo nombres de una variable tipo real para
representar el el nombre de la función que suma
los números complejos siguiendo las 3 notaciones
mostradas anteriormente, en Lenguaje C.
∉
Notacion Hungara.
∉
∉
Notacion PascalCasing
∉
∉
double realSumarComplejos;
double SumarComplejos;
Notacion CamelCasing
∉
double sumarComplejos;
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
¿ Qué es limpieza, Legibilidad o Claridad en el Código ?
Usar un estilo de indentación consistente y una buena
convención o notación para nombrar variables.
El uso correcto de las palabras algunas reservadas del
Lenguaje, veremos un par de palabras reservadas del Lenguaje
C.
const:
Define un elemento constante.
El uso de esta palabra es una practica que permite al
compiladores identificar muchos mas errores. Esto
avisará al usuario si esta intentando ejecutar alguna
operación incorrecta
#DEFINE: Se debe usar esta macro para que definan los
datos en vez de usarlos directamente en el código.
ENUM: Se debe usar si se tiene una lista de posibles valores
para una variable
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Palabras reservadas en el Lenguaje C.
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
¿ Qué es limpieza, Legibilidad o Claridad en el Código ?
No usar más paréntesis de los necesarios.
No escribir sobre código, ya existente y hacerlo inmantenible.
Reescribir código y hacerlo mantenible y extensible.
Comentar el código lo justo y necesario, ejemplo, no escribir
que hace una función, a no ser estrictamente necesario.
Introducción a los Lenguajes de Programación.
¿Características
•
•
•
de un Buen
Programa?.
Palabras reservadas en el Lenguaje C.
auto
double
int
struct
break
else
long
switch
case
enum
register
typedef
char
extern
return
union
const
float
short
unsigned
continue
for
signed
void
default
goto
sizeof
volatile
do
if
static
while
Ejemplo de #DEFINE en lenguaje C.
#DEFINE MAX_NUMERO_ALUMNOS
100
#DEFINE MAX_TAMAÑO_PAGINA_ALTO
333
#DEFINE MAX_TAMAÑO_PAGINA_ANCHO
295
Ejemplo de ENUM en lenguaje C.
typedef enum {
NINGUM_DATO,
DATO_GENERICO,
PROCEDIMIENTO_GENERICO,
DATO_GENERICO_SA
}TipoDatos;
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Documentación
La documentación tiene que ver con los comentarios
explicatorios y aclaratorios, que establecemos en nuestro
código para futura referencia.
Muchas veces podemos olvidar podemos olvidar la finalidad de
algún proceso, con una complicada codificación.
Los comentarios nos ayudan a recordar los puntos claves de
cada parte de nuestro código
Se puede establecer una convención para documentar nuestros
códigos Pero a continuación una buena practica de
documentación
La documentación del código de nuestros programas se puede
dividir en 3 niveles.
Modulo.- Información general programa.
Procedimiento.- Información de funciones no relevantes.
Variable.- Información de variables, no necesaria
comúnmente
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Documentación
Módulo
En la cabecera del archivo se escribe un cuadro con los
siguientes datos:
Datos generales: Autor, fecha, versión
Control de versiones (Histórico)
Descripción General
Describir detalles de las variables globales
Ejemplo:
//-----------------------------------------------------------------------//
NOMBRE: CRaton
//
DESCRIPCION: Clase para controlar el ratón, utilizando la API DInput
//-----------------------------------------------------------------------//
AUTOR: Raziel A. Valle Miranda -AYUDANTE -
//
FECHA: 29/09/2006 -=- Versión 2.7
//-----------------------------------------------------------------------//
//
HISTORICO:
1.3: Arreglo los problemas que tenia el boton central...
//------------------------------------------------------------------------
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Documentación
Procedimiento
Cuando sea necesario documentar funciones, procedimientos o
métodos debería incluirse lo siguiente:
Nombre y Objetivo del procedimiento
Parámetros (breve descripción)
Resultado
Incluso como funciona el algoritmo y un breve ejemplo de uso
Ejemplo:
//-----------------------------------------------------------------------//-----------------------------------------------------------------------//
NOMBRE: Raiz
//
DESCRIPCION: Devuelve la raiz cuadrada de un número
//
PARÁMETROS: int X: Número al que le queremos calcular la raiz
//
NOTA: El algoritmo solo sirve para números >=0 desde 0 hasta 65355
//------------------------------------------------------------------------
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Documentación
Variable.
A nivel de variables de deben comentar aquellas que pueden
crear cierta duda o ambigüedad.
No es recomendable comentar todas las variables ya que
seguramente la mayoría serán obvias.
Descripción
Unidades.
Valores aceptados o por defecto.
Ejemplo:
//-----------------------------------------------------------------------//-----------------------------------------------------------------------//
NOMBRE: SumaComplejos
//
DESCRIPCION: Suma 2 números complejos
//
PARÁMETROS: necesita la parte real e imaginaria del número complejo
//------------------------------------------------------------------------
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Programando Correctamente.
Entonces siguiendo la pautas anteriores, todo programa escrito
por nosotros debe cumplir con las siguientes características y
no solo para programar en Lenguaje C.
Integridad.- Corrección de cálculos
Claridad.- Facilidad de Lectura de nuestro programa.
Sencillez.- La claridad y corrección de un programa lo
hacen sencillo
Eficiencia.- Relacionada con la velocidad de ejecución y la
correcta utilización de memoria.
Modularidad.- Dividir el programa en subtareas, (en c se
implementan como funciones).
Generalidad.- Nuestros programas deben ser lo mas
general posibles.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Estructura de un buen programa.
Todo programa escrito en C consta de una o más funciones,
una de las cuales se llama main.
El programa siempre comenzará por la ejecución de la función
main. Cada función debe contener:
Una cabecera de la función, que consta del nombre de la
función, seguido de una lista opcional de argumentos
encerrados con paréntesis.
Una lista de declaración de argumentos, si se incluyen estos en
la cabecera.
Una sentencia compuesta, que contiene el resto de la función.
Introducción a los Lenguajes de Programación.
¿Características
•
de un Buen
Programa?.
Estructura de un buen programa.
#include <stdio.h>
#include <conio.h>
/*#include del sistema:Se deben especificar todos los ficheros de cabecera (ficheros con
extensión .h) correspondientes a las librerías de funciones utilizadas.
extern void salida(void);
/* extern variables globales externas: Variables globales que voy a definir en otros módulos que voy a
usar en este módulo. A salida le hemos asignado el tipo de almacenamiento extern, pues tiene que
ser accedida desde otro archivo distinto de aquel en que es definida; por tanto, ha de ser una
función externa. */
#define CIERTO 1
#define FALSO 0
/* #define definición de macros y constantes simbólicas.*/
typedef struct {
int dia;
int mes;
int ano;
}FECHA;
/* typedef definición de tipos: me sirve para crear un tipo distinto de los preestablecidos de
partida.*/
int suma (int , int);
/* Implementación de las funciones: Se implementan todas las funciones del módulo incluida la función
main().*/
extern void salida(void)
{
printf("¡Hola!");
return; /* salimos de la función, y volvemos al lugar donde se le llamó sin devolver
nada.*/
Introducción a los Lenguajes de Programación.
¿Características
de un Buen
Programa?.
Ejemplo de un programa escrito en C.
//***PROGRAMA: Ejemplo de Buenas Practicas de programacion.
//***Programa para calcular la suma de un conjuntos de complejos
//***FECHA: 29/Sept/2006
//***Autor: Raziel Valle.
#include <stdio.h>
#define N 10
typedef struct {
double real; /* Parte Real*/
double imag; /* Parte Imaginaria */
} COMPLEJO;
COMPLEJO SumarComplejos(COMPLEJO a[], int n);
void main(void)
{
COMPLEJO v[N]; /* vector de complejos */
int n;
/* número de elementos */
int i;
/* contador */
COMPLEJO suma; /* suma de los complejos */
/*** Pido el número de elementos ***/
do {
printf("Cuantos elementos quieres introducir? ");
scanf("%d",&n);
if (n>N) {
printf("Este programa no soporta tantos elementos\n");
}
} while (n>N);
/*** Pido los n elementos ***/
for(i=0; i<n; i++) {
printf("Parte real del elemento %d: ",i+1);
scanf("%lf",&v[i].real);
printf("Parte imaginaria del elemento %d: ",i+1);
scanf("%lf",&v[i].imag);
}
/*** Calcula la suma de todos los complejos ***/
suma=SumarComplejos(v,n);
/*** Salida de resultados ***/
printf("La suma es: (%lf,%lf)\n",suma.real, suma.imag);
}
/**************** F U N C I O N E S ****************************************/
/*
Función SumarComplejos
Descripción: Calcula la suma de un vector de complejos
Argumentos:
a vector de complejos
n número de elementos válidos del vector
Valor retornado:
suma complejo resultados
Advertencias:
En caso de error, por ejemplo el número de elementos es menor
que 1,
la función devuelve el complejo (0,0);
*/
COMPLEJO SumarComplejos(COMPLEJO a[], int n)
{
COMPLEJO ret; /* valor a retornar */
int i;
/* contador */
ret.real=0;
ret.imag=0;
for(i=0; i<n; i++) {
ret.real += a[i].real;
ret.imag += a[i].imag;
}
return ret;
}