Fundamentos de Programación PDF

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL
COMPUTACIÓN E
INFORMÁTICA
MANUAL DE APRENDIZAJE
FUNDAMENTOS DE
PROGRAMACIÓN
CÓDIGO: 89001536
Profesional Técnico
FUNDAMENTOS DE PROGRAMACIÓN
TABLA DE CONTENIDO:
TAREA 01: APLICAR LOS PRINCIPIOS FUNDAMENTALES DE LA PROGRAMACIÓN. .................................. 7
ESTABLECER LOS FUNDAMENTOS DE PROGRAMACIÓN. ......................................................................................... 8
ANALIZAR LAS COMPUTADORAS Y SU PROGRAMACIÓN. ...................................................................................... 14
APLICAR LA METODOLOGÍA DE PROGRAMACIÓN. ............................................................................................... 24
CÓMO PROGRAMAR CORRECTAMENTE ............................................................................................................ 27
NOTAS IMPORTANTES SOBRE LAS VARIABLES: ................................................................................................... 29
CLASIFICAR LOS LENGUAJES DE PROGRAMACIÓN Y PROGRAMAS TRADUCTORES. ....................................................... 30
FUNDAMENTO TEÓRICO ........................................................................................................................ 33
ESTABLECER LOS FUNDAMENTOS DE PROGRAMACIÓN. ....................................................................................... 33
ANALIZAR LAS COMPUTADORAS Y SU PROGRAMACIÓN. ...................................................................................... 39
APLICAR LA METODOLOGÍA DE PROGRAMACIÓN. ............................................................................................... 45
CLASIFICAR LOS LENGUAJES DE PROGRAMACIÓN Y PROGRAMAS TRADUCTORES. ....................................................... 49
TAREA 02: ANALIZAR LA ESTRUCTURA GENERAL DE UN PROGRAMA. ................................................. 55
OPERACIONES ........................................................................................... ¡ERROR! MARCADOR NO DEFINIDO.
DEFINIR EL CONCEPTO Y PARTES DE UN PROGRAMA. .......................................................................................... 56
ELABORAR LA DOCUMENTACIÓN DE UN PROGRAMA. .......................................................................................... 57
DEFINIR EL CONCEPTO Y PARTES DE UN PROGRAMA. .......................................................................................... 58
DEFINICIÓN DE PROGRAMA .......................................................................................................................... 58
PARTES DE UN PROGRAMA.................................................................................................................... 62
ELABORAR LA DOCUMENTACIÓN DE UN PROGRAMA. .......................................................................................... 63
TAREA 03: APLICAR LA LÓGICA DE PROGRAMACIÓN. .......................................................................... 67
DEFINIR EL CONCEPTO DE UN ALGORITMO........................................................................................................ 68
CLASIFICACIÓN DE ALGORITMOS: .......................................................................................................... 68
SÍMBOLOS O FIGURAS DEL DIAGRAMA DE FLUJO Y SU SIGNIFICADO .................................................... 69
CONSTRUIR ALGORITMOS PARA RESOLVER CASOS PRÁCTICOS. .............................................................................. 71
ELABORAR DIAGRAMAS DE FLUJO. .................................................................................................................. 74
CONSTRUIR PSEUDOCODIGOS. ...................................................................................................................... 77
DEFINIR EL CONCEPTO DE UN ALGORITMO........................................................................................................ 80
CONSTRUIR ALGORITMOS PARA RESOLVER CASOS PRÁCTICOS. .............................................................................. 81
ELABORAR DIAGRAMAS DE FLUJO. .................................................................................................................. 85
CONSTRUIR PSEUDOCODIGOS. ...................................................................................................................... 88
TAREA 04: DEFINIR LOS TIPOS DE ESTRUCTURAS QUE EXISTEN EN UN PROGRAMA. ........................... 91
OPERACIONES ........................................................................................................................................ 91
CONSTRUIR ESTRUCTURAS CONDICIONALES SIMPLES. ......................................................................................... 92
ELABORAR ESTRUCTURAS DE REPETICIÓN. ........................................................................................................ 93
ANALIZAR Y DESARROLLAR ESTRUCTURAS ANIDADAS COMPLEJAS. ......................................................................... 96
DESARROLLAR CASOS PRÁCTICOS DE PROGRAMACIÓN. ....................................................................................... 98
FUNDAMENTO TEÓRICO ...................................................................................................................... 100
CONSTRUIR ESTRUCTURAS CONDICIONALES SIMPLES. ....................................................................................... 100
ELABORAR ESTRUCTURAS DE REPETICIÓN. ...................................................................................................... 103
ANALIZAR Y DESARROLLAR ESTRUCTURAS ANIDADAS COMPLEJAS. ....................................................................... 107
DESARROLLAR CASOS PRÁCTICOS DE PROGRAMACIÓN. ..................................................................................... 110
.......................................................................................................................................................... 117
TAREA 05: DEFINIR LOS TIPOS DE DATOS DE UN PROGRAMA. ........................................................... 117
TRABAJAR CON CONSTANTES Y VARIABLES. .................................................................................................... 118
DEFINIR LAS PALABRAS RESERVADAS DE UN LENGUAJE. ..................................................................................... 120
DEFINIR LAS FUNCIONES INTERNAS DE UN PROGRAMA. ..................................................................................... 122
TRABAJAR LOS TIPOS DE OPERADORES Y EXPRESIONES DE UN PROGRAMA. ............................................................ 126
ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 5


TRABAJAR CON CONSTANTES Y VARIABLES. .................................................................................................... 128
DEFINIR LAS PALABRAS RESERVADAS DE UN LENGUAJE. ..................................................................................... 134
DEFINIR LAS FUNCIONES INTERNAS DE UN PROGRAMA. ..................................................................................... 137
TRABAJAR LOS TIPOS DE OPERADORES Y EXPRESIONES DE UN PROGRAMA. ............................................................ 141
TAREA 06: UTILIZAR HERRAMIENTAS PARA EL DISEÑO Y ANÁLISIS DE ALGORITMOS. ....................... 149
OPERACIONES ...................................................................................................................................... 150
ELABORAR LOS ALGORITMOS CON EL PROGRAMA DE DISEÑO.............................................................................. 150
ANALIZAR EL PROCESO DE CONSTRUCCIÓN DE UN ALGORITMO. .......................................................................... 151
DESARROLLAR CASOS PRÁCTICOS CON EL PROGRAMA DE DISEÑO. ....................................................................... 155
ELABORAR LOS ALGORITMOS CON EL PROGRAMA DE DISEÑO.............................................................................. 157
ANALIZAR EL PROCESO DE CONSTRUCCIÓN DE UN ALGORITMO. .......................................................................... 169
DESARROLLAR CASOS PRÁCTICOS CON EL PROGRAMA DE DISEÑO. ....................................................................... 173
TAREA 07: ANALIZAR EL CONCEPTO DE FUNCIONES, PARÁMETROS Y PROCEDIMIENTOS. ................. 177
APRENDER A UTILIZAR PARÁMETROS EN UNA FUNCIÓN. .................................................................................... 178
ANALIZAR LAS NORMAS GENERALES DE USO DE PARÁMETROS. ........................................................................... 182
APRENDER A UTILIZAR PARÁMETROS EN UNA FUNCIÓN. .................................................................................... 195
ANALIZAR LAS NORMAS GENERALES DE USO DE PARÁMETROS. ........................................................................... 197
PARA DEFINIR UN PARÁMETRO DE PROCEDIMIENTO. ........................................................................................ 199
CONSTRUIR UN PROCEDIMIENTO UTILIZANDO VARIABLES LOCALES Y GLOBALES. ..................................................... 200
DEFINIR LAS VENTAJAS DE UTILIZAR PROCEDIMIENTOS Y FUNCIONES. ................................................................... 206
UTILIZAR LA RECURSIVIDAD EN EL USO DE PROCEDIMIENTOS Y FUNCIONES. ........................................................... 207

01
TAREA 01: APLICAR LOS PRINCIPIOS FUNDAMENTALES DE
LA PROGRAMACIÓN.
En esta tarea trataremos las siguientes operaciones:
 Establecer los fundamentos de programación.

 Analizar las computadoras y su programación.
 Aplicar la metodología de programación.
 Clasificar los lenguajes de programación y programas traductores.
" Culminar tus estudios es como correr en una prueba de

resistencia en la cual todos los vencedores son los que logran
llegar a la meta, así que sigue adelante que cada paso te acerca
más al final.”……. ANONIMO.
EQUIPOS Y MATERIALES:
 Computadora con microprocesadores core 2 Duo ó de mayor capacidad.

 Sistema operativo Windows.
 Acceso a internet.
 Software de maquetación y desarrollo de páginas web.
ORDEN DE EJECUCIÓN:
 Establecer los fundamentos de programación.

 Analizar las computadoras y su programación.
 Aplicar la metodología de programación.
 Clasificar los lenguajes de programación y programas traductores.

OPERACIÓN:
ESTABLECER LOS FUNDAMENTOS DE PROGRAMACIÓN.
Un programa es un conjunto de órdenes para un ordenador.
Estas órdenes se le deben dar en un cierto lenguaje, que el ordenador sea

capaz de comprender.
El problema es que los lenguajes que realmente entienden los ordenadores

resultan difíciles para nosotros, porque son muy distintos de los que nosotros
empleamos habitualmente para hablar. Escribir programas en el lenguaje que
utiliza internamente el ordenador (llamado “lenguaje máquina” o “código
máquina”) es un trabajo duro, tanto a la hora de crear el programa como
(especialmente) en el momento de corregir algún fallo o mejorar lo que se hizo.
Por eso, en la práctica se emplean lenguajes más parecidos al lenguaje

humano, llamados “lenguajes de alto nivel”. Normalmente, estos son muy
parecidos al idioma inglés, aunque siguen unas reglas mucho más estrictas.
NOTA:
Cuando buscas una aplicación que lleve a cabo una función determinada y no
consigues encontrarla, te enfrentas a un triste hecho: hay programas que
todavía no existen. Tal cual.
Puedes sentarte, llorar y esperar a que alguien programe esa aplicación... o

puedes hacerla tú mismo. ¿Cómo? Pues aprendiendo un lenguaje de
programación y creando desde cero el programa deseado.
APRENDER A PROGRAMAR
Tu ordenador es una máquina que acepta y ejecuta órdenes. Estas órdenes

pueden ser tan simples como escribir una letra en la pantalla o calcular una
suma, y pueden tener varias formas, dependiendo del lenguaje empleado. A un
ordenador no puedes decirle lo siguiente:
Ordenador, quiero que me bajes esa caja de la estantería, la roja a la derecha.
No lo entenderá. En cambio, si escribes algo así, puede que te preste atención:
010101010111010101001010111010101010111010011010100101010110011

Ceros y unos, código máquina, el único idioma que sabe hablar un PC. Para
nosotros no es práctico hablar así, con lo que recurrimos a lenguajes
artificiales, que no son más que versiones simplificadas de nuestros idiomas.
La frase inicial se parecería entonces a algo así:
caja.Bajar(EstanteriaRoja3) = Verdad;
¿Es un poco complicado?, sí. Pero es mucho mejor que escribir ceros y unos,
¿no te parece? Esos puntos, espacios, puntos y coma y paréntesis sirven para
delimitar exactamente lo que se quiere decir a la máquina, al igual que ocurre
al escribir fórmulas matemáticas. Un ejemplo con coloreado de sintaxis:
Organizadas en párrafos especiales, todas las líneas de órdenes conforman lo

que se conoce como "código fuente", las entrañas de un programa. Para
convertirlo en un programa ejecutable, el código se "compila", esto es, se
traduce a código máquina. Si no hay fallos (bugs), el programa se abrirá
normalmente.
Como los idiomas naturales, también los lenguajes de programación tienen su

léxico, sintaxis y normas de puntuación, que varían en función de la
complejidad del lenguaje. Algunos son más fáciles de leer que otros, y
entonces se les llama "de alto nivel", pues se aproximan al habla humana; los
de bajo nivel son más "robóticos".

Las máquinas solo hablan con

ceros y unos, un lenguaje
incomprensible para un humano
Para imprimir una palabra en un lenguaje de alto nivel como BASIC, basta con
escribir PRINT "Hola" (print, en inglés, quiere decir "imprimir"; la mayoría de
lenguajes usan palabras en inglés). En un lenguaje de nivel bajo, como el
Ensamblador, la cosa cambia (no te asustes por lo que vas a ver, no son
palabrotas):
SWI "OS_WriteS" EQUS "Hola" EQUB 0 ALIGN MOV PC,R14
Te estarás preguntando quién puede preferir Ensamblador frente a otros

lenguajes. Es una cuestión de rendimiento: el código de bajo nivel se ejecuta
más rápido y aprovecha más la potencia de la máquina a la cual está ligado,
mientras que un lenguaje de alto nivel es más universal; Java, por ejemplo, se
ejecuta en cualquier sistema.
Hay cientos de lenguajes de programación, y, al igual que ocurre con los

idiomas humanos, muchos tienen pocos "hablantes". Los hay que jamás han
salido de las universidades y empresas donde los crearon, mientras que los
más populares, por el contrario, se enseñan por doquier y cuentan con amplias
comunidades de usuarios.

Para crear aplicaciones de escritorio, los lenguajes más populares son C/C++,
Java, Python, Visual Basic y Delphi. Su estilo es parecido, con lo que pasar de
uno a otro requiere menos esfuerzo que hacerlo, por ejemplo, de Basic a
Ensamblador. Sobre ellos hay una infinidad de libros, cursos y foros técnicos.
CÓMO EMPEZAR.
Aprender a programar es un objetivo que se

plantea mucha gente y que no todos alcanzan.
Hay que tener claro que aprender programación
no es tarea de un día ni de una semana: aprender
programación requiere al menos varios meses y,
si hablamos de programación a nivel profesional,
varios años. No queremos con esto desanimar a
nadie: en un plazo de unos pocos días podemos estar haciendo nuestros
primeros programas y ver los primeros resultados, pero aprender a programar
es mucho más que eso. Vamos a tratar de exponer nuestra visión sobre una
forma adecuada de enfrentarnos al aprendizaje de la programación.
En primer lugar diremos que “aprender a programar” es una expresión bastante
indefinida. Existen cientos de lenguajes de programación y de variantes,
versiones, modificaciones, etc. así como distintos enfoques en cuanto a los
objetivos (programación web, aplicaciones de gestión, aplicaciones de bases
de datos, etc.). Por tanto “aprender a programar” es bastante ambigüo: es
como decir “quiero aprender a pintar”. Nos permitiría centrarnos mejor definir
un objetivo más específico: “Quiero aprender a dibujar comics estilo manga”.
El problema para los no iniciados es muchas veces que la programación es un

campo muy cambiante, donde hay una continua proliferación de versiones y
pugnas entre casas comerciales que hacen que los lenguajes cambien muy
rápidamente y nadie sepa muy bien qué es lo más conveniente aprender.
Frente a esta situación, y para todos aquellos que quieren empezar a

programar, sabiendo o no hacia qué lenguaje se van a orientar, nuestra
propuesta es que usen aprenderaprogramar.com como sitio de referencia a
través del cual poder dar los primeros pasos en programación. Una vez
adquiridos los fundamentos y sentadas las bases, será más fácil buscar
información y elegir entre las distintas plataformas y lenguajes existentes.

Vamos a reflexionar sobre lo que consideramos son opciones adecuadas y

opciones no adecuadas para las personas que quieren aprender a programar
sin tener conocimientos previos, o con unos conocimientos previos muy
limitados.
a) Aprender con un libro ó con apuntes de

forma autodidacta: no es una mala opción para
personas que quieran aprender por libre,
siempre que se encuentre un buen libro y se
tenga voluntad, base lógico-matemática y
determinación para estudiar por cuenta propia
durante un periodo de tiempo prolongado. En
cualquier caso el libro debe tratar sobre
fundamentos de la programación, con aplicación (para ver el lado práctico) a
algún lenguaje. Si estás interesado en esta vía, te recomendamos visitar la
sección “Libros” de aprenderaprogramar.com y ver los libros disponibles sobre
fundamentos de programación.
b) Realizar un curso sobre fundamentos de programación: consideramos

que no es una mala opción para personas que quieran estudiar de forma
guiada. Existe una amplia oferta de cursos impartidos de forma presencial (por
universidades, academias, centros de formación especializada, etc.), semi-
presencial u on-line (a través de internet). Es importante realizar una buena
selección del curso: que cuente con unos buenos contenidos y materiales
didácticoS. Un curso “cualquiera” descargado por internet no nos garantiza ni
unos buenos contenidos ni una buena didáctica, al contrario, puede suponer
una pérdida de tiempo. La modalidad de curso más adecuada depende de
cada uno de nosotros, y en especial el tiempo que tengamos disponible. Si
disponemos de tiempo, la opción presencial puede ser la más adecuada, ya
que nos permitirá estar en contacto con otros alumnos y poder resolver
problemas en común, realizar consultas
directas a los profesores, etc. Si nuestro tiempo
es limitado, un curso semi-presencial u on-line
puede ser lo más conveniente. Si estás
interesado en esta vía, te recomendamos
visitar la sección “Cursos” de
aprenderaprogramar.com.

c) Realizar estudios oficiales en el área de informática – programación:

es quizás la mejor vía para aquellas personas que
quieren dedicarse profesionalmente a la
informática. Esto requiere normalmente una
dedicación de varios años a tiempo completo, por lo
que es una opción que descartan muchas personas
que quieren aproximarse de una forma más libre a
la programación o que ya tienen otros trabajos.
d) Empezar a programar directamente con un lenguaje o entorno (Java,

Visual Basic, C, .NET, J2EE, SQL, etc.) recurriendo a libros, cursos, páginas
web especializadas, ayuda de los lenguajes, etc.: consideramos que es una
mala opción. Antes de empezar a programar en un lenguaje debemos tener
fundamentos de programación que nos servirán para todos los lenguajes, al
igual que para construir una casa debemos tener antes cimientos que nos
permitan continuar la construcción de forma
sólida. Empezar a programar directamente en
un lenguaje sin tener fundamentos de
programación consideramos que llevará a que
se requiera más tiempo y no se obtengan tan
buenos resultados como si se empezara con
fundamentos de programación.
e) Aprender a programar apoyándonos en un sitio web de confianza:

algunos sitios web tienen buenos
contenidos gratuitos o de pago para
aprender a programar. Este es el caso de
aprenderaprogramar.com, que pretende
constituirse en una página de confianza
para todas aquellas personas que quieran
aprender a programar. Si eliges esta web
como vía para tu aprendizaje de la programación y partes desde cero o de
unos conocimientos muy básicos, te proponemos que aprendas a utilizar esta
web para sacarle el máximo partido. Tendrás una magnífica herramienta a tu
disposición y un proceso de aprendizaje guiado. Para aprovechar al máximo lo
que te ofrecemos, merece la pena que dediques unos minutos a conocer cómo
funciona y cómo se organiza aprenderaprogramar.com. Este sitio web se rige
por unas pautas organizativas y didácticas, un funcionamiento editorial y unas
codificaciones cuyo conocimiento te permitirán ir más rápido en tu aprendizaje.

En caso de dudas, plantea tus consultas en los foros donde miembros del
portal u otros usuarios te ayudarán a hacer más llevadero el aprendizaje de la
programación.
f) Otras vías: aprender con un amigo, familiar,

etc. no es una mala opción, siempre que esa
persona tenga un buen nivel de conocimientos,
capacidad didáctica y tiempo suficiente para
dedicarnos.
OPERACIÓN:
ANALIZAR LAS COMPUTADORAS Y SU PROGRAMACIÓN.
Cuando encendemos una computadora el circuito de control llamado BIOS

(Basic Input/Output System = sistema básico de entrada/salida), inicia una
inspección del sistema a esta secuencia denominada en el argot computacional
POST (POWER ON SELET TEST). El propósito de examinar es confirmar la
existencia de un buen funcionamiento de algunos componentes vitales del
computador.
Algunos de los componentes de vital importancia que son revisados son:

microprocesador, memorias RAM, BIOS, dispositivos básicos de comunicación
como el teclado y la señal de video. Cuando alguno de estos está funcionado
mal o está desconectado, el BIOS suele informar a través de señales escritas y
audibles (pitidos del speaker), según su fabricante, para informar que existe
una anomalía y por tanto tu PC no puede arrancar.
Pasado el POST, el BIOS tiene como función la búsqueda de un sistema de

control que debe cargar en la memoria. Este es el sistema operativo (Unix,
Linux, Windows, unidades ópticas o CD-ROM, red, etc). Si lo encuentra, lee
sus instrucciones y deposita un conjunto básico de instrucciones en la memoria
RAM para que el sistema operativo continué con el control de la computadora.
Todo el movimiento generado (transmisión y ordenamiento de datos) es dirigido
por el cerebro del sistema, el microprocesador. Este a su vez utiliza toda la red
de subalternos (otros chips) para ordenar la transmisión de señales que se
necesitan para que tu PC funcione correctamente. Al final cuando un trabajo es
aprobado por el operador de la computadora, se ordena al programa que
guarde los datos en forma definitiva.

El software es un término genérico para los programas que funcionan en el

interior de una computadora. En este caso posiblemente sea Windows es el
sistema operativo o programa de funcionamiento que le da la vida a su
computadora, es así como se puede observar esta información en la pantalla.
El hardware es también un término genérico para todos los componentes

físicos del computador. Este es el nivel más básico en el cual la computadora
funciona. El punto dominante a recordar es que toda la información está
procesada electrónicamente por el hardware. La PC esta preparada como su
computadora personal, aunque se abrevia (PC) y es a menudo asociada con la
computadora con la cual funciona el sistema operativo de Windows.
Las computadoras están integrados por una serie de componentes electrónicos

que son los responsables de su correcto funcionamiento. Entre ellos destacan:
• Unidad central de procesos (CPU): es el cerebro del PC.

Se encarga de procesar las instrucciones y los datos con los
que trabaja la computadora. El procesador es el dispositivo
más importante y el que más influye en su velocidad al
analizar información.
• Memoria RAM o memoria principal: es la memoria

de acceso aleatorio, en la que se guardan
instrucciones y datos de los programas para que la
CPU puede acceder a ellos directamente a través del
bus de datos externo de alta velocidad. A la RAM se
le conoce como memoria de lectura/escritura, para
diferenciarla de la ROM. Es decir que en la RAM, la CPU puede escribir y leer.
Por esto, la mayoría de los programas destinan parte de la RAM como espacio
temporal para guardar datos, lo que permite reescribir. Como no retiene su
contenido, al apagar la computadora es importante guardar la información. La
cantidad de memoria RAM influye bastante en la velocidad de un PC. Entre
más memoria RAM tenga, más rápido trabaja y más programas puede tener
abiertos al mismo tiempo.
• Memoria ROM: es la memoria solo para lectura. Es la

parte del almacenamiento principal dla computadora que no
pierde su contenido cuando se interrumpe la energía.
Contiene programas esenciales del sistema que ni la
computadora ni el usuario pueden borrar, como los que le

permiten iniciar el funcionamiento cada vez que se enciende la computadora.
• Disco duro: es el dispositivo de almacenamiento

secundario que usa varios discos rígidos cubiertos
de un material magnéticamente sensible. Está
alojado, junto con las cabezas de lectura, en un
mecanismo sellado en forma hermética, en el que
se guardan los programas y todos los archivos
creados por el usuario cuando trabaja con esos
programas. Entre más capacidad tenga un disco duro, más información y
programas puede almacenar en el PC. La capacidad del disco duro se mide en
gigabytes (GB). Un GB equivale a 1.024 megabytes (MB) aproximadamente.
En el disco duro quedan guardados, entre otras cosas, todos los archivos
creados por el usuario.
• Caché: es una unidad pequeña de memoria ultrarápida

en la que se almacena información a la que se ha
accedido recientemente o a la que se accede con
frecuencia, lo que evita que el microprocesador tenga que
recuperar esta información de circuitos de memoria más
lentos. El caché suele estar ubicado en la tarjeta madre,
pero a veces está integrado en el módulo del procesador.
Su capacidad de almacenamiento de datos se mide en kilobytes (KB). Mientras
más caché tenga la computadora es mejor, porque tendrá más instrucciones y
datos disponibles en una memoria más veloz.
• Tarjeta madre: es la tarjeta de circuitos que

contiene el procesador o CPU, la memoria
RAM, los chips de apoyo al microprocesador y
las ranuras de expansión. Estas son las que
permiten insertar, por ejemplo, la tarjeta de
sonido (que permite al PC reproducir sonido),
el módem interno (que hace posible navegar
por Internet) o la tarjeta gráfica o de video (que
permite mostrar imágenes en la pantalla).
• CD-ROM - DVD-ROM: esta unidad sirve para leer

los discos compactos, sean estos programas, música
o material multimedia (sonidos, imágenes, textos),
como las enciclopedias y los juegos electrónicos. La
velocidad de esta unidad depende de dos factores: la

tasa de transferencia de datos y el tiempo de

acceso. El CD ROM lee la información contenida
en los discos compactos. La tasa de
transferencia de datos se refiere a la cantidad de
datos que la unidad de CD ROM puede enviar al
PC en un segundo. Esa tasa se mide en kilobytes por segundo (kbps) y se
indica con un número al lado de un X, por ejemplo: 16X, 24X o 48X. Mientras
más X, mayor velocidad. El tiempo de acceso se refiere a lo que tarda el
proceso completo.
Cómo funciona un procesador.
El microprocesador, o simplemente procesador, es el circuito integrado central

y más complejo de una computadora u ordenador; a modo de ilustración, se le
suele asociar por analogía como el "cerebro" de una computadora.
El procesador es un circuito integrado constituido por millones de componentes

electrónicos integrados. Constituye la unidad central de procesamiento (CPU)
de un PC catalogado como microcomputador.

Desde el punto de vista funcional es, básicamente, el

encargado de realizar toda operación aritmético-lógica, de
control y de comunicación con el resto de los componentes
integrados que conforman un PC, siguiendo el modelo
base de Von Neumann. También es el principal encargado
de ejecutar los programas, sean de usuario o de sistema;
sólo ejecuta instrucciones programadas a muy bajo nivel,
realizando operaciones elementales, básicamente, las aritméticas y lógicas,
tales como sumar, restar, multiplicar, dividir, las lógicas binarias y accesos a
memoria.
Esta unidad central de procesamiento está constituida,

esencialmente, por registros, una unidad de control y una
unidad aritmético lógica (ALU), aunque actualmente todo
microprocesador también incluye una unidad de cálculo en
coma flotante, (también conocida como "coprocesador
matemático"), que permite operaciones por hardware con
números decimales, elevando por ende notablemente la eficiencia que

proporciona sólo la ALU con el cálculo indirecto a través de los clásicos

números enteros.
Logica de la computadora.
Las computadoras digitales utilizan el sistema de números binarios, que tiene

dos dígitos 0 y 1. Un dígito binario se denomina un bit. La información está
representada en las computadoras digitales en grupos de bits. Utilizando
diversas técnicas de codificación los grupos de bits pueden hacerse que
representen no solamente números binarios sino también otros símbolos
discretos cualesquiera, tales como dígitos decimales o letras de alfabeto.
Utilizando arreglos binarios y diversas técnicas de codificación, los dígitos
binarios o grupos de bits pueden utilizarse para desarrollar conjuntos completos
de instrucciones para realizar diversos tipos de cálculos.
La información binaria se representa en un sistema digital por cantidades

físicas denominadas señales, Las señales eléctricas tales como voltajes
existen a través del sistema digital en cualquiera de dos valores reconocibles y
representan una variable binaria igual a 1 o 0. Por ejemplo, un sistema digital
particular puede emplear una señal de 3 volts para representar el binario "1" y
0.5 volts para el binario "0". La siguiente ilustración muestra un ejemplo de una
señal binaria.
Como se muestra en la figura, cada valor binario tiene una desviación

aceptable del valor nominal. La región intermedia entre las dos regiones
permitidas se cruza solamente durante la transición de estado. Los terminales
de entrada de un circuito digital aceptan señales binarias dentro de las
tolerancias permitidas y los circuitos responden en los terminales de salida con
señales binarias que caen dentro de las tolerancias permitidas.

La lógica binaria tiene que ver con variables binarias y con operaciones que
toman un sentido lógico. La manipulación de información binaria se hace por
circuitos lógicos que se denominan Compuertas.
Las compuertas son bloques del hardware que producen señales en binario 1 ó
0 cuando se satisfacen los requisitos de entrada lógica. Las diversas
compuertas lógicas se encuentran comúnmente en sistemas de computadoras
digitales. Cada compuerta tiene un símbolo gráfico diferente y su operación
puede describirse por medio de una función algebraica. Las relaciones entrada
- salida de las variables binarias para cada compuerta pueden representarse en
forma tabular en una tabla de verdad.
A continuación se detallan los nombres, símbolos, gráficos, funciones
algebraicas, y tablas de verdad de las compuertas más usadas.
Compuerta AND:
Cada compuerta tiene dos variables de entrada

designadas por A y B y una salida binaria designada por
x.
La compuerta AND produce la multiplicación lógica AND:

esto es: la salida es 1 si la entrada A y la entrada B están
ambas en el binario 1: de otra manera, la salida es 0.
Estas condiciones también son especificadas en la tabla

de verdad para la compuerta AND. La tabla muestra que
la salida x es 1 solamente cuando ambas entradas A y B
están en 1.
El símbolo de operación algebraico de la función AND es

el mismo que el símbolo de la multiplicación de la
aritmética ordinaria (*).
Las compuertas AND pueden tener más de dos entradas

y por definición, la salida es 1 si todas las entradas son 1.

Compuerta OR:
La compuerta OR produce la función sumadora, esto es,

la salida es 1 si la entrada A o la entrada B o ambas
entradas son 1; de otra manera, la salida es 0.
El símbolo algebraico de la función OR (+), es igual a la

operación de aritmética de suma.
Las compuertas OR pueden tener más de dos entradas y

por definición la salida es 1 si cualquier entrada es 1.
Compuerta NOT:
El circuito NOT es un inversor que invierte el nivel lógico

de una señal binaria. Produce el NOT, o función
complementaria. El símbolo algebraico utilizado para el
complemento es una barra sobra el símbolo de la variable
binaria.
Si la variable binaria posee un valor 0, la compuerta NOT

cambia su estado al valor 1 y viceversa.
El círculo pequeño en la salida de un símbolo gráfico de
un inversor designa un inversor lógico. Es decir cambia
los valores binarios 1 a 0 y viceversa.
Sistema Binario: el lenguaje de las computadoras.
En el interior del gabinete del sistema de una computadora, se ven

principalmente circuitos electrónicos. En una computadora los datos son
reducidos a interruptores eléctricos. Los interruptores pueden tener sólo uno de
dos estados posibles: encendido o apagado. Así que sólo se cuenta con dos
símbolos numéricos, 1 para “encendido” y O para “apagado”.
Al contar con tan sólo dos símbolos numéricos, las computadoras funcionan
internamente con el sistema binario que se compone de dos dígitos (0 y 1) para
la representación de datos e instrucciones. Estos dos dígitos se implementan
de forma electrónica mediante dos estados (apagado o encendido). Toda la
información que entra a una computadora es convertida en estos números
binarios.
Bit: Al referirse a datos de computadoras, cada interruptor que esté apagado

(valor 0) o encendido (valor 1) es un bit. La palabra bit es la forma abreviada

de binary digit (dígito binario) y constituye la unidad de datos más pequeña

posible.
Bytes: Para representar cualquier cosa significativa es necesario usar grupos

de bits. El byte es una agrupación de ocho bits. En una computadora los bytes
se utilizan para representar números, letras y caracteres especiales. Con un
byte se tienen 256 combinaciones diferentes de ocho bits (combinaciones de
ceros y unos). Esto permite representar todos los caracteres del teclado,
incluyendo letras (mayúsculas y minúsculas), números, signos de puntuación y
otros símbolos mediante alguna de estas combinaciones.
Unidad de medida de capacidad de almacenamiento.

La capacidad de almacenamiento primario de una computadora (y la de
almacenamiento secundario también) usa como unidad de medida el byte, de
manera similar a como el litro viene a representar la unidad de capacidad de un
recipiente. En la siguiente tabla, se presenta la capacidad de memoria en los
múltiplos más usados del byte y sus equivalencias.
Tabla 1.- Capacidad de memoria en los múltiplos del byte.
Unidad Abreviatura Equivalencia

Kilobyte K, KB o K-byte. 1.024 bytes (aprox. Mil bytes)
Megabyte MB o M-byte. 1.024 KB (aprox. 1 millón de bytes)
Gigabyte GB o G-byte 1.024 MB (aprox. Mil millones de bytes)
Terabyte TB o T-Byte 1.024 GB (aprox. Un millón de billones de bytes)

Un Kilobyte está constituido exactamente por 1.024 bytes aunque se suele

aproximar a mil bytes. La misma consideración es válida para las demás
medidas como se muestra en la tabla de los múltiplos del byte.
Esquemas de codificación binaria.

Para representar caracteres como combinaciones de ceros (0) o unos (1) en la
computadora, se hace uso de los denominados esquemas de codificación
binaria. Los esquemas más conocidos utilizan ocho bits para formar cada byte.
Estos esquemas son el ASCII y el EBCDIC. A diferencia de los anteriores el
Unicode, que es un código más reciente, emplea dieciséis bits. Al oprimir una
tecla del teclado, el carácter es convertido automáticamente en un conjunto de
pulsos electrónicos. El CPU es capaz de reconocer estos pulsos. Al presionar
la letra “C” de un teclado, por ejemplo, ésta se convierte en el código ASCII de
01000011.
ASCII American Standard Code for Information Code (código estadounidense

estándar para intercambio de información) es el juego usado más
extensamente en microcomputadoras.
EBCDIC Extended Binary Coded Decimal Interchange Code (códigos de
intercambio de decimales codificados en binarios extendidos) desarrollado por
IBM y usado principalmente en computadoras grandes.
Unicode Diseñado para soportar idiomas internacionales como el chino y el
japonés. Estos idiomas poseen tantos caracteres que no pueden
representarse con los códigos ASCII y EBCDIC, fue desarrollando por
Unicode Inc., con apoyo de Apple, IBM y Microsoft.
Bit de paridad.
Un bit de paridad es un bit adicional que se añade automáticamente a un byte
para efectos de detección de errores. Al teclear la letra “C”, por ejemplo,
debería representarse en el CPU como 01000011. En general pueden suceder
distorsiones que podrían causar un error e interpretar el último 1 como un 0. El
byte sería leído debido al error como 01000010. El bit de paridad es una forma
para poder determinar si se está recibiendo datos correctamente. Existen
sistemas de paridad pares y sistemas de paridad impares. Cuando se emplea
el sistema de paridad par, se fija el bit de paridad ya sea en 0 o 1 de modo que
la cantidad de unos sea par.
Para la letra “C” (01000011) en el ejemplo, se cuenta el número de unos
determinando, que se trata de tres en este caso. Se agrega al principio un bit
de paridad, que se fija en 1, para que el número de unos sea par. La señal

enviada es 101000011. Cuando la señal es recibida por el CPU, se verifica el

número de unos. Si no es par, ha ocurrido algún error. A esto es lo que se
conoce como error de paridad. Entonces el CPU solicitará que la señal se
reenvíe. Los sistemas de paridad impares funcionan exactamente al contrario
de los sistemas de paridad de pares. Como es fácil imaginar, se coloca un cero
o un uno para que el número de unos sea impar.
OPERACIÓN:
APLICAR LA METODOLOGÍA DE PROGRAMACIÓN.
Análisis y diseño de sistemas.
En la actualidad la mayoría de los usuarios de microcomputadoras tienen

acceso a un sistema de información o forman parte del mismo. Todas las
organizaciones cuentan con un sistema de información de algún tipo, que sus
empleados deben utilizar. Cuando en cualquier organización se desea
implantar un nuevo sistema, de tal forma que sus miembros sean más
productivos, obteniendo un mayor provecho y apoyo del mismo, se requiere
realizar una serie de acciones y previsiones.
La creación o establecimiento de un nuevo sistema de información en la

organización, puede ser una tarea compleja. Para encarar este tipo de
situaciones existe un proceso de análisis y diseño de sistemas que auxilia en la
resolución de tales problemas. El análisis y diseño de sistemas proporciona
una guía útil que busca disminuir las situaciones de fracaso o errores al
acometer estos procesos.
Razones para conocer el análisis y diseño de sistemas.
Aunque pareciese que es tema sólo de profesionales, como usuario final, toda
persona que usa una microcomputadora se beneficiará al conocer sobre este
proceso. Puede ocurrir que, una vez contratado como miembro de una
organización, se convierta en usuario de su sistema de información, entonces

el conocimiento del análisis y diseño de sistemas, le permitirá aumentar su

productividad personal, sirviéndole para resolver los problemas que surjan en
su área de trabajo, determinando nuevos requerimientos de información y
permitiéndole colaborar con los profesionales en informática en la resolución de
tales situaciones.
Consumo de recursos a lo largo de la vida del sistema
Necesidad del análisis y diseño de sistemas.
La instalación de un sistema sin la adecuada planeación puede conducir a

grandes frustraciones y causar que el sistema sea subutilizado, o peor aún,
deje de ser usado al no cumplir con las expectativas que le dieron origen. El
análisis y diseño de sistemas es una guía que permite estructurar el proceso de
desarrollo de sistemas de información.
Tal proceso siempre representará un esfuerzo, inversión de tiempo y recursos

por parte de la organización. Acometer tal esfuerzo de manera casual, presenta
un alto grado de riesgo al no garantizar la culminación del proyecto con éxito.
Este procedimiento permite reducir al mínimo el riesgo de fracaso de nuevos
proyectos, pues es común que muchos errores surjan al utilizar nuevos
sistemas de información, bien por no adaptarse correctamente a las
necesidades reales o por desempeñarse de forma inadecuada.
Ciclo de vida del desarrollo de sistemas.
Antes de dar detalles sobre este proceso, se define lo que es un sistema. De

manera sencilla, un sistema puede ser definido como un conjunto de
actividades y elementos organizados para alcanzar un fin. Un sistema de
información se compone de elementos como hardware, software, personas,
procedimientos y datos que interactúan unos con otros para generar la
información primordial en el desempeño de la organización.
La información es un recurso valioso que permite a la organización llevar a

cabo la prestación de servicios o elaboración de productos. Es común que las

organizaciones deban cambiar sus sistemas de información, motivado al

crecimiento de la misma, cambio en regulaciones estatales, surgimiento de
nueva tecnología, y otros. Es decir, siempre habrá factores que modifiquen el
ambiente donde se desempeña la organización y ésta debe cambiar para
afrontarlos, lo cual se verá reflejado en los sistemas que la conforman.
El análisis y diseño de sistemas es un procedimiento para la resolución de

problemas. Cuando se trata del diseño de sistemas de información, busca
analizar sistemáticamente la entrada o flujo de datos, la transformación de los
datos, el almacenamiento de datos y la salida de información en el contexto de
una organización particular. También es usado para analizar, diseñar e
implementar mejoras que puedan incorporarse a la organización y puedan ser
alcanzadas al usar un sistema de información computarizado.
Este procedimiento se lleva a cabo, en el llamado ciclo de vida de desarrollo de

sistemas, el cual consta de seis pasos que permiten el diagnóstico y
optimización de un sistema de información. Este ciclo puede repetirse
indefinidamente, porque como ya se señaló, las organizaciones siempre se ven
sometidas a cambios, y sus sistemas deben renovarse periódicamente. Los
pasos del ciclo de vida de desarrollo son los que se encuentran en la imagen.
Se suele llamar analistas de sistemas a quienes se encargan de realizar en las
empresas, el proceso de análisis y diseño de sistemas, definiendo los
lineamientos a seguir y la manera en que debe incorporarse la tecnología de la
computación para adecuar y actualizar sus sistemas de información.
Ciclo de vida de desarrollo de sistemas de seis fases
Los usuarios juegan un papel crítico al momento de cambiar o desarrollar

exitosamente un sistema de información, porque son quienes conocen los
problemas de su área de trabajo, pudiendo suministrar información valiosa y
atinada sobre las necesidades que debería resolver tal sistema. El desarrollo

acertado de sistemas de información automatizados requiere del trabajo

conjunto de usuarios finales y de los analistas de sistemas.
Resumen del ciclo de vida de desarrollo de sistemas
Ciclo de vida de desarrollo de sistemas

Fase Tareas asociadas
1 Investigación preliminar Definir el problema Sugerir alternativas
Presentar reporte breve
2 Análisis Recopilar datos Analizar datos
Documentar resultado
3 Diseño Diseñar alternativas Escoger la mejor
alternativa Reportar resultado
4 Desarrollo Desarrollar o adquirir software Adquirir
hardware Probar Sistema
5 Implementación Instalación Capacitación de usuarios
6 Mantenimiento Auditar nuevo sistema Evaluar
eriódicamente
CÓMO PROGRAMAR CORRECTAMENTE.
Como programadores los estándares que encontramos en la red o en libros

pueden ser bastante útiles. Un estilo de programación va a constar de una
serie de reglas o definiciones que permitirán que el código de fuente de un
programa o aplicación que realicemos sea comprensible y evite futuras
confusiones.
A pesar de que cada lenguaje de programación puede tener su propio estilo,
hay algunas definiciones generales que se aplican a la mayoría, y esas son
siempre muy escenciales para desarrollar un buen trabajo. El estilo de
programación considera reglas de identación, formateado, estilo de variables,
etc. El objetivo principal es establecer un “estilo estandarizado” que permita
una fácil distribución o modifcación posterior del código (source code).
1. Reglas de identación para programar: A pesar de que en la mayoría de
los lenguajes de programación los espacios y saltos de línea no afectan el
proceso de compilación, se hace más sencillo comprender y “estratificar” un
código para poder notar en dónde realizar determinada modificación o cambio,
por ejemplo:

Comparado con:
Obviamente el primero resulta mucho más claro de entender al cumplir ciertas

reglas de espaciado y tabulamiento.
Existen lenguajes como Python que dependen estrictamente de la identación
para funcionar, lo que ayuda a establecer un código más limpio y comprensible.
2. Espaciado: Tal como se mencionó en la identación, un compilador no

considera el espaciado para crear el programa; sin embargo, es recomendable
aplicar espacios para mejorar la lectura.
Por ejemplo:
En relación a:
Resulta más “apretado”, por ello puede confundir muchas veces, por lo que el
segundo código es más recomendado.
3. Espaciado vs Tabulación: El espaciado es recomendado que se realice sin

usar la barra espaciadora, sino la barra de tabulación; con ello podemos
obtener mejores resultados y un código más comprensible.

4. Estilo de las variables: Con el objeto de que el programa sea entendible, es

necesario regularizar sus variables. Obviamente no es obligatorio, pero como
todo lo anterior, es muy aconsejado su uso.
-Variables normales: Variable de números, edades, fechas, objetos e
instancias, nombres, etc; siempre con minúsculas.
Ejemplos:
-Métodos y funciones: Las subrutinas de un código se recomienda se

identifiquen con minúsculas, pero en caso de encontrar varias palabras, los
comienzos de las siguientes deberían ser con mayúsculas.
Ejemplos:
-Clases: Las clases se deben identificar con mayúsculas, mientras que sus
objetos instanciadores (tal como se mencionó anteriormente), con minúsculas.
Ejemplos:
Notas importantes sobre las variables:
a. Nunca es recomendado usar caracteres especiales en los nombres:

CORRECTO: int anio; int cedula;

INCORRECTO: int año; int cédula;
b. Para identificar un espacio es bueno usar el caracter “_” en lugar de “-”:

CORRECTO: String nombre_principal;
INCORRECTO: String nombre-principal;
Con estas buenas prácticas su código podrá quedar más limpio, ordenado y
entendible.
NOTA:
Programar un proyecto de gran embergadura no es una tarea fácil. Por esto, es de fundamental
importancia seguir estos pasos para evitar errores de los cuales luego nos podamos arrepentir
y que nos puede costar la reprogramación de todo el programa con su consecuente pérdida de
tiempo adicional, sea cual sea el lenguaje de programación que vayamos a utilizar.
Lo primero que debemos hacer es entender de arriba a abajo que es lo que debe hacer el
programa. Nunca empieces a programar sin tener, como mínimo, una idea o visión global del
problema. No es mala idea coger un papel y hacer un listado de todas las tareas que debe
realizar y en caso de que surjan dudas, preguntarla antes de empezar a desarrollar.
Una vez hemos entendido el problema, debemos hacer un análisis integro de este. Debemos
coger un papel y representar en él la forma más óptima que se nos ocurra para resolver cada
una de las tareas detectadas en el paso anterior.
Los cinco demonios del Apocalipsis algorítmico.

Demonio 1 "El Ley pareja": Encuentras gente que tiene tu misma duda y tampoco tiene
respuestas.
Demonio 2 "La conversación entre curados (borrachos)": Encuentras una pregunta similar a la
tuya y un montón de respuestas donde nadie le da la solución correcta al asunto.
Demonio 3 "El anciano rebelde": Encuentras respuesta a tu problema pero para windows NT o
95.
Demonio 4 "El exótico”: Un sitio que parece tener respuesta a tu pregunta está en japonés.
Demonio 5 "El Tax-Man": Un sitio te cobra para decirte la respuesta a tu pregunta.
OPERACIÓN:
CLASIFICAR LOS LENGUAJES DE PROGRAMACIÓN Y PROGRAMAS
TRADUCTORES.
El ordenador sólo entiende un lenguaje conocido como código binario o código

máquina, consistente en ceros y unos. Es decir, sólo utiliza 0 y 1 para codificar
cualquier acción.

Los lenguajes más próximos a la arquitectura hardware se denominan

lenguajes de bajo nivel y los que se encuentran más cercanos a los
programadores y usuarios se denominan lenguajes de alto nivel.
Lenguajes de bajo nivel.

Son lenguajes totalmente dependientes de la máquina, es decir que el
programa que se realiza con este tipo de lenguajes no se pueden migrar o
utilizar en otras maquinas.
Al estar prácticamente diseñados a medida del hardware, aprovechan al

máximo las características del mismo.
Dentro de este grupo se encuentran:

El lenguaje maquina: este lenguaje ordena a la máquina las operaciones
fundamentales para su funcionamiento. Cnsiste en la combinación de 0's y 1's
para formar las ordenes entendibles por el hardware de la maquina.
Este lenguaje es mucho más rápido que los lenguajes de alto nivel.
La desventaja es que son bastantes difíciles de manejar y usar, además de

tener códigos fuente enormes donde encontrar un fallo es casi imposible.
El lenguaje ensamblador es un derivado del lenguaje maquina y esta formado

por abreviaturas de letras y números llamadas mnemotécnicos. Con la
aparición de este lenguaje se crearon los programas traductores para poder
pasar los programas escritos en lenguaje ensamblador a lenguaje máquina.
Como ventaja con respecto al código máquina es que los códigos fuentes eran
más cortos y los programas creados ocupaban menos memoria. Las
desventajas de este lenguaje siguen siendo prácticamente las mismas que las
del lenguaje ensamblador, ñadiendo la dificultad de tener que aprender un
nuevo lenguaje difícil de probar y mantener.
Lenguajes de alto nivel.

Son aquellos que se encuentran más cercanos al lenguaje natural que al
lenguaje máquina.
Están dirigidos a solucionar problemas mediante el uso de EDD's.

NOTA:
EDD's son las abreviaturas de Estructuras Dinamicas de Datos, algo muy utilizado en todos los
lenguajes de programación. Son estructuras que pueden cambiar de tamaño durante la
ejecución del programa. Nos permiten crear estructuras de datos que se adapten a las
necesidades reales de un programa.
Se tratan de lenguajes independientes de la arquitectura del ordenador. Por lo

que, en principio, un programa escrito en un lenguaje de alto nivel, lo puedes
migrar de una máquina a otra sin ningún tipo de problema.
Estos lenguajes permiten al programador olvidarse por completo del
funcionamiento interno de la maquina/s para la que están diseñando el
programa. Tan solo necesitan un traductor que entiendan el código fuente
como las características de la maquina.
Suelen usar tipos de datos para la programación y hay lenguajes de propósito
general (cualquier tipo de aplicación) y de propósito especifico (como
FORTRAN para trabajos científicos).
Lenguajes de Medio nivel.

Se trata de un término no aceptado por todos, pero q seguramente habrás
oído. Estos lenguajes se encuentran en un punto medio entre los dos
anteriores. Dentro de estos lenguajes podría situarse C ya que puede acceder
a los registros del sistema, trabajar con direcciones de memoria, todas ellas
características de lenguajes de bajo nivel y a la vez realizar operaciones de alto
nivel.
Generaciones.
La evolución de los lenguajes de programación se puede dividir en 5 etapas o
generaciones.
Primera generación: lenguaje maquina.

Segunda generación: se crearon los primeros lenguajes ensambladores.
Tercera generación: se crean los primeros lenguajes de alto nivel. Ej. C,
Pascal, Cobol…
Cuarta generación: Son los lenguajes capaces de generar código por si solos,
son los llamados RAD, con lo cuales se pueden realizar aplicaciones sin ser un
experto en el lenguaje. Aquí también se encuentran los lenguajes orientados a
objetos, haciendo posible la reutilización d partes del código para otros
programas. Ej. Visual, Natural Adabes…
Quinta generación: aquí se encuentran los lenguajes orientados a la
inteligencia artificial. Estos lenguajes todavía están poco desarrollados. Ej.
LISP

FUNDAMENTO TEÓRICO:
Establecer los fundamentos de programación.

Programación es la acción y efecto de programar. Este
verbo tiene varios usos: se refiere a idear y ordenar las
acciones que se realizarán en el marco de un proyecto; al
anuncio de las partes que componen un acto o
espectáculo; a la preparación de máquinas para que
cumplan con una cierta tarea en un momento
determinado; a la elaboración de programas para la
resolución de problemas mediante ordenadores; y a la
preparación de los datos necesarios para obtener una
solución de un problema a través de una calculadora
electrónica, por ejemplo.
En la actualidad, la noción de programación se encuentra muy asociada a la

creación de aplicaciones informáticas y videojuegos; es el proceso por el cual
una persona desarrolla un programa valiéndose de una herramienta que le
permita escribir el código (el cual puede estar en uno o varios lenguajes, tales
como C++, Java, Python, PHP, Power Builder, .NET, etc) y de otra que sea
capaz de “traducirlo” a lo que se conoce como lenguaje de máquina, el cual
puede ser entendido por un microprocesador.
Este último paso se conoce como compilación y es necesario para que el

código pueda ser ejecutado por la plataforma para la cual haya sido creado,
que puede ser un ordenador, una tableta, una consola o un teléfono móvil, por
ejemplo. Existe también una forma de traducir el código denominada
interpretación, que consiste en analizar línea a línea, hasta que se traduzca lo
suficiente como para poder realizar una tarea. Cabe mencionar que los
lenguajes de programación se dividen en dos grandes grupos, donde los que
pueden ser compilados no pueden ser interpretados, y viceversa.
Definición de Compilador.
Cuando hablamos de programación, hemos mencionado que existen dos
Códigos fundamentales a la hora de crear aplicaciones, programas o corregir
errores presentes en dicha tarea, teniendo por un lado al Código Fuente, que
es el que se encuentra en un Lenguaje de Programación entendible por los
usuarios, y por otro lado el Código Objeto, que es la traducción del mismo para
que todas las órdenes que han sido redactadas puedan ser “entendidas” por el
dispositivo que las vaya a ejecutar.

La tarea de traducción de un Código Fuente, hacia el producto final que será el

Código Objeto, está dada por la acción de Compilar, para lo cual se requiere de
una aplicación que es conocida justamente como Compilador, el cual
describiremos a continuación.
Básicamente, el Compilador
consiste en una aplicación que tiene
como premisa fundamental la
Traducción del lenguaje específico
de programación (también conocido
como Lenguaje de Alto Nivel) hacia
otro que es solamente comprensible
por el equipo, que se encargará de
interpretarlo llevándolo a un sistema binario que se basa en la transmisión o
no-transmisión de energía eléctrica (Lenguaje de Bajo Nivel)
Para poder realizar esta transformación, el Compilador debe realizar un análisis

de qué es lo que se ha escrito en el Lenguaje de Programación establecido, a
través de tres criterios fundamentales, cuyo conjunto es conocido como Front
End:
Léxico: Que el lenguaje sea correctamente aplicado, con palabras

preestablecidas por el mismo.
Sintáctico: Que la programación esté ordenada, sin fallas en sus variables.
Semántico: Criterio en el cual se verifica que el resultado de lo que ha sido
programado tiene una correlación con la orden que ha querido ser ejecutada.
Realizado esto, comienza una etapa en la cual se sintetiza el Código Objeto,

teniendo ésta tres pasos fundamentales, contando además con un asistente
que nos informa de todos los Errores que hayan sido encontrados y que
requieren una posterior enmienda, además de fallas en la traducción, teniendo
este proceso el nombre de Back End:

Código Intermedio: Se genera un Código Objeto preliminar en base al

Lenguaje de Alto Nivel.
Optimización: El código anteriormente creado en forma previa al resultado
final es analizado y mejorado en pos de mayor rendimiento y menos errores.
Generación: Finalmente, en esta etapa se da lugar a la creación de un Código
Objeto.
Realizado esto, se obtiene finalmente el Lenguaje de Bajo Nivel que será

posteriormente interpretado por el ordenador y ejecutado por los distintos
dispositivos del ordenador.
¿Cuál es la diferencia entre Intérprete y Compilador?
Hay dos formas de ejecutar programas escritos en un lenguaje de alto nivel. El

más común es compilar el programa y el otro método es pasar el programa a
través de un intérprete. Tanto el intérprete como el compilador tienen como
finalidad traducir las instrucciones recibidas a un lenguaje que el equipo pueda
entender.
Las diferencias entre intérprete y compilador son:
Un intérprete traduce instrucciones de alto nivel en una forma intermedia para

ser ejecutado. En contraste, un compilador, traduce instrucciones de alto nivel
directamente en lenguaje de máquina.
El intérprete traduce un programa línea a línea mientras que el compilador
traduce el programa entero y luego lo ejecuta.

El intérprete detecta si el programa tiene errores y permite su depuración

durante el proceso de ejecución, mientras que el compilador espera hasta
terminar la compilación de todo el programa para generar un informe de
errores.
Un programa compilado es más seguro que uno interpretado, porque no
contiene el código fuente, que puede ser modificado incorrectamente por el
usuario.
Ambos, intérpretes y compiladores están disponibles en la mayoría de los
lenguajes de alto nivel.
Definicion de Código Fuente.
El código fuente consiste en uno o más

archivos que contienen las instrucciones de
programación con las cuales un
desarrollador de software creó una
aplicación. Regularmente el código fuente
fue escrito utilizando alguna herramienta de
programación.
Cuando un desarrollador de software
escribe un programa utilizando algún tipo
de lenguaje de programación (Visual Basic, C++, etc.) El archivo o archivos que
son escritos forman lo que se denomina programa origen o código fuente. Para
ejecutar el programa, el código fuente debe ser traducirlo a lenguaje de
máquina, para que computador lo pueda entender y así ejecutar la aplicación
de acuerdo a las instrucciones recibidas.
Al comprar un sistema operativo o alguna aplicación de uso general como
Microsoft Office, por lo general recibes una aplicación en forma de código
objeto compilado, que solo permite ser ejecutado, no puede ser modificado
porque el código fuente no está incluido.
No obstante existen algunos proveedores de software que proporcionar el
código fuente, pero no resulta muy útil si no eres programador y entiendes la
lógica de desarrollo de software.

Requerimientos personales para programar.

Personales es un término que utilizamos con bastante cuidado, ya que en
verdad a lo que nos referimos es a una serie de características y habilidades
(natas y/o adquiridas) personales que ayudan mucho en el aprendizaje. Si bien
el no tener alguna de estas puede que termine por no ser un impedimento si
sirve de mucho tenerlas. Nos referimos a:
Paciencia, y mucha: Y hacemos mucho

hincapié en este punto, por eso lo hemos
puesto al tope de la lista. La programación
puede llegar a ser muy frustrante y en
muchas ocasiones podemos quedarnos
pegados por un buen rato en la busqueda
de una solución a un problema, por muy
pequeño que sea. Más adelante daremos
algunos consejos sobre esto. Lo
importante es tener paciencia y entender que siempre hay baches en el
camino, por muy buenos que lleguemos a ser.
Perseverancia: Va ligado netamente al punto anterior. En la programación

siempre hay que ser perseverante para poder lograr los objetivos que nos
proponemos.
En muchas ocasiones nos encontraremos con distintos problemas que van

desde: no saber como afrontar un problema, hasta bloqueos mentales o
desconocimiento. Saldremos adelante solo siendo perseverantes y solo
continuando cuando pensemos que ya debemos tirar la esponja. Estas últimas
2 cualidades es lo que separa a los buenos programadores de los malos. No
los conocimientos de lenguajes, sino la paciencia y la perseverancia es lo que
los llevará a ser buenos.
Mirar las situaciones desde distintos
puntos: Esto es muy útil y nos refleja a
nosotros mismos de como enfrentamos la
vida. Cuando se nos presenta una
situación de cualquier tipo, mientras de
más puntos o lados la miremos y
obtengamos ciertas conclusiones,
aumentamos más la posibilidad de
encontrar una buena solución.

Debemos siempre tener en cuenta que todas las personas piensan de distinta
forma y por lo tanto todos pensamos distintas soluciones y más aún, distintas
formas de implementar estas soluciones. Si bien es siempre bueno definir hacia
nosotros mismos una metodología para resolver los problemas, es muy útil
tener la habilidad de abstraerse y mirar la situación desde otro lado. En más de
alguna ocasión con esto obtendremos mejores soluciones que las que
habiamos pensado originalmente.
Pensar lógica y básicamente: Algunos

informáticos definen las computadoras como
tremendamente básicas y tontas". ¿Curioso, no?.
Es una tremenda verdad. Los computadores son
máquinas tremendamente elementales desde un
punto de vista que saben realizar solo un par de
operaciones básicas como cargar, grabar o
sumar.
Todo lo demás que pueden hacer es, o bien una combinación de esas
operaciones, o el producto de otros programadores que han desarrollado
aplicaciones que les permiten a estas máquinas realizar otros trabajos. ¿A qué
vamos con esto?, a que siempre hay que tener presente lo básico de la forma
de pensar de los computadores cuando programamos y por eso muchas veces
debemos pensar igual de básico que ellos. Cuando necesitamos encontrar una
solución, debemos enfrentar la situación como un computador lo haría sin
saber otro tipo de informaciones que nosotros sabemos y debemos diseñar
nuestras soluciones de la forma más básica para poder implementarlas.
Ser estructurado: A pesar de que los programadores tienen la fama de ser

medios "locos y volados" para encontrar solución a las respuestas, también son
tremendamente estructurados. Y es que cuando pensemos una solución a
implementar mediante programación, debemos pensarla estructurada de la
forma: Bueno, para hacer esto, primero hay que hacer esto, luego esto, luego
esto y finalmente esto. Ese orden y esa estructuración nos irán ayudando a no
tener que volver sobre el mismo camino hecho para agregar cosas que
deberían haber estado ahí.
Conocimientos matemáticos: Si bien no es
extremadamente necesario y no
necesitamos ser unos magos de los
números, ya que hoy con Internet tenemos
acceso a la información de manera rápida y
sencilla, si es bueno tener nociones

matemáticas sobre operaciones, conocimientos algebraicos, geométricos ya

que al programar utilizaremos uno o varios de estos conceptos en ocasiones.
Ser curioso y tener disposición a resolver problemas: La programación nos
presenta problemas, problemas y más problemas. Por eso es bueno tener
curiosidad de como resolverlos de distintas formas y siempre tener la
disposición a encontrar soluciones, en especial la más adecuada. Es nuestra
curiosidad y nuestro espíritu de superación lo que eventualmente nos irá
convirtiendo en mejores programadores.
Es por esto que en las carreras relacionadas con el área de la computación e
informática, previo a la programación siempre nos pasan (muchas veces
odiandolo y sin entender bien porque) Cálculo y Álgebra. El primero nos
enseña a expandir la mente y mirar los problemas desde distintos puntos y el
segundo nos enseña a establecer una estructura de pensamiento. Así que a
comenzar a darle la importancia debida a las funciones, sistemas de
ecuaciones y gráficos.
Y finalmente un detalle a siempre tener en consideración: En la

programación, siempre hay más de una forma de resolver los problemas.
ANALIZAR LAS COMPUTADORAS Y SU PROGRAMACIÓN.
¿QUÉ ES UNA COMPUTADORA?

Una computadora1 es un dispositivo electrónico
utilizado para procesar información y obtener
resultados.
Los datos y la información se pueden introducir en la
computadora por la entrada (input) y a continuación se
procesan para producir una salida (output, resultados).
La computadora se puede considerar como una unidad en la que se ponen

ciertos datos, entrada de datos, procesa estos datos y produce unos datos de
salida. Los datos de entrada y los datos de salida pueden ser realmente
cualquier cosa, texto, dibujos o sonido. El sistema más sencillo de comunicarse
una persona con la computadora es esencialmente mediante un ratón (mouse),
un teclado y una pantalla (monitor).

Hoy día existen otros dispositivos muy populares tales como escáneres,
micrófonos, altavoces, cámaras de vídeo, cámaras digitales, etc.; de igual
manera, mediante módems, es posible conectar su computadora con otras
computadoras a través de redes, siendo la más importante, la red Internet.
Lógica de la computadora.
La lógica de la computadora se basa en el álgebra booleana y sistema de

numeración en base dos (sistema binario). La información se representa en
forma binaria mediante el uso de los dígitos 0 (cero) y 1 (uno). En un circuito
digital, en un instante dado la presencia de un pulso eléctrico (bits o dígitos)
representa el primer dígito del sistema binario. A la inversa, la ausencia de un
impulso eléctrico representa el número 0.
Los impulsos eléctricos se llaman bits. Una vez que la información traducida en
bits, éstos son procesados por circuitos lógicos (puertas lógicas), capaces de
asociar un impulso de salida dada a los pulsos eléctricos en la entrada. Las
puertas lógicas son circuitos eléctricos integrados de interruptores (switches)
en serie o en paralelo. Cada puerta lógica lleva a cabo una función simple
álgebra en particular Boolean (NOT, AND, OR, NAND, XOR, etc) .. Por
ejemplo, el siguiente circuito eléctrico permite realizar la función del operador
O:

La combinación de puertas lógicas puede crear circuitos lógicos combinatorios

para llevar a cabo las funciones y también cálculos más complejos. A partir de
una tabla de verdad, las puertas lógicas se combinan entre sí en un circuito
eléctrico (operación de conmutación de circuitos) para lograr el mismo
resultado con los impulsos eléctricos.
Los circuitos lógicos pueden también acompañados de elementos de memoria

para registrar los impulsos eléctricos que se pasan durante el proceso de
cálculo. En la presencia de elementos del circuito lógico de la memoria se dice
circuito secuencial (circuito de conmutación secuencial). La combinación de los
circuitos eléctricos determina los circuitos integrados de la ciencia electrónica /
computación que se basa en la lógica de lacomputadora.
Lenguaje Binario en Informática.
La computación no nació repentinamente en un año

específico. Surge de años de evolución y desarrollo. La
base de la comunicación entre distintos dispositivos fue
prácticamente desarrollada a partir del pensamiento de
Gottfried Wilhelm Leibniz (1646-1716) y George Boole
(1815-1864) que descubrió los operadores lógicos.

Siendo el operador más sencillo de comprender y el que se tomará por ejemplo

será el operador Not.
Este, recibe generalmente el nombre de negación, porque entrega el valor

contrario al que recibe por su entrada. Si en su entrada hay un uno, en su
salida habrá un cero y si hay un cero en su entrada, su salida tendrá un uno, es
decir entrega el valor contrario al que recibe. En electrónica digital a un
operador lógico se lo conoce como una “compuerta lógica”.
El sistema binario es un sistema de numeración en el que los números se

representan utilizando las cifras cero y uno, esto es infomática tiene mucha
importancia ya que las computadoras trabajan internamente con 2 niveles de
voltaje lo que hace que su sistema de numeración natural sea binario, por
ejemplo 1 para encendido y 0 para apagado.
Todas aquellas personas que se dedican a la informática es fundamental tener

hablidad con este tipo de numeración. En este artículo voy a explicar un poco
cómo se utiliza y en que consiste el sistema binario.
En binario, tan sólo existen dos dígitos, el cero y el uno. Hablamos, por tanto,
de un sistema en base dos, en el que 2 es el peso relativo de cada cifra
respecto de la que se encuentra a la derecha. Es decir:
An, An-1, ….., A5, A4, A3, A2, A1, A0
El subíndice n indica el peso relativo (2n) La forma de contar es análoga a

todos los sistemas de numeración, incluido el nuestro, se van generando
números con la combinación progresiva de todos los digitos. En base 10
(sistema decimal), cuando llegamos al 9, seguimos con una cifra más, pero
comenzando desde el principio: 9,10,11… en binario sería:

0, 1 (cero y uno)
10, 11 (dos y tres)
100, 101, 110, 111 (cuatro, cinco, seis y siete)
1000, 1001, 1010, 1011, 1100, 1101, 1110, 1111 (del ocho al quince)
10000, 10001, 10010, 10011, 10100….
Ya sabemos contar… pero si nos dan un número muy grande en binario…

¿como sabríamos qué número es contar hasta que lleguemos a ese número?
Bien, para eso utilizaremos el siguiente método: multiplicaremos cada dígito por
su peso y sumaremos todos los valores. Por ejemplo, dado el número en
binario 11110100101:
1 1 1 1 0 1 0 0 1 0 1 — Número binario
10 9 8 7 6 5 4 3 2 1 0 — Posición – peso
1×210 + 1×29 + 1×28 + 1×27 + 0×26 + 1×25 + 0×24 + 0×23 + 1×22 + 0×21 +
1×20
=
1024 + 512 + 256 + 128 + 0 + 32 + 0 + 4 + 1 = 1957
Como podemos ver todo se basa en potencias de dos. Para mayor soltura,
tendremos que aprendernos de memoria las potencias de 2, al menos hasta
210 = 1024. Además, cuando ya estemos familiarizados, podremos realizar el
paso anterior de memoria, sin desglosar todas las multiplicaciones y sumas,
simplemente con un cálculo de cabeza.
No se termina ahí la cosa. Debemos aprender también a pasar números en

decimal a binario. Para ello, dividiremos sucesivamente por dos y anotaremos
los restos. El número en binario será el último cociente seguido de todos los
restos en orden ascendente (de abajo a arriba). Es decir:
1957 / 2 = 978 Resto: 1

978 / 2 = 489 Resto: 0
489 / 2 = 244 Resto: 1
244 / 2 = 122 Resto: 0
122 / 2 = 61 Resto: 0
61 / 2 = 30 Resto: 1
30 / 2 = 15 Resto: 0
15 / 2 = 7 Resto: 1
7 / 2 = 3 Resto: 1
3 / 2 = 1 Resto: 1
Observar que sale como número: 11110100101

Ahora bien, ¿y para pasar a ambos sistemas si el número no es entero? La
solución consiste en hacer las cuentas por separado. Si tenemos 1957.8125,
por un lado pasaremos el 1957 a binario como ya hemos aprendido. Por otro,

tomaremos la parte fraccionaria, 0,8125, y la multiplicaremos sucesivamente

por 2, hasta que el producto sea 1. Tomaremos la parte entera de cada
multiplicación, de forma descendente (de arriba a abajo, o del primero al
último):
0.8125 x 2 = 1.625 — Parte Entera: 1

0.625 x 2 = 1.25 — Parte Entera: 1
0.25 x 2 = 0.5 — Parte Entera: 0
0.5 x 2 = 1 — Parte Entera: 1
El cambio de binario a decimal se realizará igual que con la parte entera,

teniendo en cuenta que su peso será 2-1, 2-2, 2-3, 2-4… comenzando por el
primer dígito después de la coma:
1 1 1 1 0 1 0 0 1 0 1 . 1 1 0 1 — Número binario
10 9 8 7 6 5 4 3 2 1 0 . -1 -2 -3 -4 — Posición – peso
1×210 + 1×29 + 1×28 + 1×27 + 0×26 + 1×25 + 0×24 + 0×23 + 1×22 + 0×21 +
1×20 + + 1×2-1 + 1×2-2 + 0×2-3 + 1×2-4
=
1024 + 512 + 256 + 128 + 0 + 32 + 0 + 4 + 1 + + 0.5 + 0.25 + 0 + 0.0625
=
1957.8125
¿Recuerda el uso de las tarjetas perforadas

usadas por el obrero textil? ¿Recuerda que
mencioné anteriormente a la primera
programadora que hacia sus programas
perforando tarjetas? En la tarjeta perforada
solo había dos estados: “agujereado” o
“liso”, en el binario ocurre lo mismo, la
diferencia es que ahora en vez de usar una
plantilla de madera o metal perforada,
usamos cables (o líneas de conducción) y lo que seria “agujereado” o “liso”
ahora es un “uno” o “cero” representado por una variaciones de la tensión
transportada en los cables o líneas conductoras según corresponda.

Aplicar la metodología de programación.
Una metodología de programación es un conjunto o sistema de métodos,

principios y reglas que permiten enfrentar de manera sistemática el desarrollo
de un programa que resuelve un problema algorítmico. Estas metodologías
generalmente se estructuran como una secuencia de pasos que parten de la
definición del problema y culminan con un programa que lo resuelve.
A continuación se presenta de manera general los pasos de una metodología:
El Diálogo Con la cual se busca comprender totalmente el

problema a resolver.
La Especificación Con la cual se establece de manera precisa las

entradas, salidas y las condiciones que deben cumplir.
Diseño En esta etapa se construye un algoritmo que cumpla

con la especificación.
Codificación Se traduce el algoritmo a un lenguaje de

programación.
Prueba y Verificación Se realizan pruebas del programa implementado para

determinar su validez en la resolución del problema.
DIÁLOGO.
En el primer paso en el proceso de solución a un problema se debe determinar

de manera clara y concisa la siguiente información:
1. Los objetos conocidos, es decir, aquellos objetos de los cuales poseemos

información total o parcial útil en la búsqueda de los objetos desconocidos.

2. Las condiciones, aquellas relaciones establecidas entre los objetos

conocidos y los desconocidos. Para esto se deben encontrar entre otras, la
dependencia entre los valores de los objetos desconocidos de los valores de
los objetos conocidos y que restricciones le impone el planteamiento del
problema a dichos objetos.
3. Los valores posibles que pueden tomar los objetos desconocidos.
Ejemplo. Sean los puntos P=(a,b) y Q=(c,d) que definen una recta, encontrar
un segmento de recta perpendicular a la anterior que pase por el punto medio
de los puntos dados.
OBJETOS DESCONOCIDOS Un segmento de recta.
OBJETOS CONOCIDOS Los puntos P y Q.
CONDICIONES El segmento de recta debe pasar por el punto

medio entre P y Q, y debe ser perpendicular a
la recta trazada entre P y Q.
ESPECIFICACIÓN DE ALGORITMOS.
Después de entender totalmente el problema a resolver (lo cual se consigue

con la etapa del diálogo), se debe realizar una especificación del algoritmo que
permite encontrar su solución. Un algoritmo que no esté claramente
especificado puede ser interpretado de diferentes maneras y al diseñarlo se
puede terminar con un algoritmo que no sirve para solucionar el problema.
La especificación de un algoritmo se hace mediante una descripción clara y

precisa de:
1. Las entradas que el algoritmo recibirá.
2. Las salidas que el algoritmo proporcionará.
3. La dependencia que mantendrán las salidas obtenidas con las entradas
recibidas.
Esta descripción puede ser presentada mediante un diagrama de caja negra

como el de la siguiente figura:

PASOS PARA LA ESPECIFICACIÓN DE ALGORITMOS.

Especificar Entradas
Las entradas corresponden a los objetos conocidos. Se debe indicar
claramente la descripción, cantidad y tipo de las mismas.
Especificar Salidas
Las salidas corresponden a los objetos desconocidos del problema. Se debe
indicar claramente la cantidad, descripción y tipo de las mismas.
Especificar Condiciones
Se describe claramente como dependen las salidas de las entradas, se puede
usar lenguaje matemático o informal.
EJEMPLOS DE ESPECIFICACIÓN.
PROBLEMA 1: Construir un algoritmo que calcule el promedio de 4 notas.
Entradas
N1,N2,N3,N4 (notas parciales) de tipo Real.
Salidas
Final (nota final) de tipo Real.
Condiciones
DISEÑO ESTRUCTURADO DE ALGORITMOS.
La fase de diseño del algoritmo, es decir, la fase en la que se construye el

algoritmo que permitirá encontrar la solución al problema, está dividida en dos
pasos importantes:

División: En el que a partir de la especificación del algoritmo se divide el

proceso (algoritmo en abstracto) en varios subprocesos hasta llegar al nivel de
instrucción.
Abstracción: En el que se revisa que porciones del algoritmo se repiten o son

muy utilizadas y con las cuales se construyen funciones y/o procedimientos.
DIVISIÓN
Consiste en subdividir de manera sistemática el proceso en una colección de
pasos más pequeños. Está subdivisión se realiza de manera repetida hasta
llegar al nivel de instrucción.
DEFINICIÓN DE ABSTRACCIONES.
 Identificar que secuencias de pasos se utilizan más de una vez en diferentes

partes del proceso.
 Recolectar estas secuencias de pasos en funciones y procedimientos según
sea el caso.
 Documentar cada función y procedimiento especificando claramente:
El propósito de la función (o procedimiento).
El nombre, tipo y propósito de cada argumento.
El resultado (o efectos laterales).
CODIFICACIÓN.
Cuando ya se ha diseñado completamente el algoritmo y se tiene escrito en
algún esquema de representación (pseudo-código o diagrama de flujo), el
siguiente paso es codificarlo en el lenguaje de programación definido para tal
fin.

En este momento es cuando el programador interactua con el computador

mediante la herramienta de software que disponga para codificar en el lenguaje
seleccionado.
PRUEBAS DE ESCRITORIO.
La prueba de escritorio es una herramienta útil para entender que hace un
determinado algoritmo, o para verificar que un algoritmo cumple con la
especificación sin necesidad de ejecutarlo.
Básicamente, una prueba de escritorio es una ejecución ‘a mano’ del algoritmo,

por lo tanto se debe llevar registro de los valores que va tomando cada una de
las variables involucradas en el mismo.
Clasificar los lenguajes de programación y programas traductores.
Un lenguaje de programación es un lenguaje inventado para controlar una

máquina, (normalmente, un ordenador). Hay muchísimos, de toda clase de
tipos y características, inventados para facilitar el abordaje de distintos
problemas, el mantenimiento del software, su reutilización, mejorar la
productividad, etc.
Los lenguajes de programación se pueden clasificar según varios criterios. He
encontrado doce en total: Nivel de abstracción, propósito, evolución histórica,
manera de ejecutarse, manera de abordar la tarea a realizar, paradigma de
programación, lugar de ejecución, concurrencia, interactividad, realización
visual, determinismo y productividad.
Hay que tener en cuenta también, que en la práctica, la mayoría de lenguajes
no pueden ser puramente clasificados en una categoría, pues surgen
incorporando ideas de otros lenguajes y de otras filosofías de programación,
pero no importa al establecer las clasificaciones, pues el auténtico objetivo de
las mismas es mostrar los rangos, las posibilidades y tipos de lenguajes que
hay.
1. Nivel de abstracción.
Según el nivel de abstracción, o sea, según el grado de cercanía a la máquina:
 Lenguajes de bajo nivel: La programación se realiza teniendo muy en cuenta
las características del procesador. Ejemplo: Lenguajes ensamblador.
 Lenguajes de nivel medio: Permiten un mayor grado de abstracción pero al
mismo tiempo mantienen algunas cualidades de los lenguajes de bajo nivel.

Ejemplo: C puede realizar operaciones lógicas y de desplazamiento con bits,

tratar todos los tipos de datos como lo que son en realidad a bajo nivel
(números), etc.
 Lenguajes de alto nivel: Más parecidos al lenguaje humano. Manejan

conceptos, tipos de datos, etc., de una manera cercana al pensamiento
humano ignorando (abstrayéndose) del funcionamiento de la máquina.
Ejemplos: Java, Ruby.
Hay quien sólo considera lenguajes de bajo nivel y de alto nivel, (en ese caso,
C es considerado de alto nivel).
2. Propósito.
Según el propósito, es decir, el tipo de problemas a tratar con ellos:
 Lenguajes de propósito general: Aptos para todo tipo de tareas: Ejemplo: C.

 Lenguajes de propósito específico: Hechos para un objetivo muy concreto.
Ejemplo: Csound (para crear ficheros de audio).
 Lenguajes de programación de sistemas: Diseñados para realizar sistemas
operativos o drivers. Ejemplo: C.
 Lenguajes de script: Para realizar tareas varias de control y auxiliares.
Antiguamente eran los llamados lenguajes de procesamiento por lotes
(batch) o JCL (“Job Control Languages”). Se subdividen en varias clases (de
shell, de GUI, de programación web, etc.). Ejemplos: bash (shell), mIRC
script, JavaScript (programación web).
3. Evolución histórica.
Con el paso del tiempo, se va incrementando el nivel de abstracción, pero en la
práctica, los de una generación no terminan de sustituir a los de la anterior:
 Lenguajes de primera generación (1GL): Código máquina.

 Lenguajes de segunda generación (2GL): Lenguajes ensamblador.
 Lenguajes de tercera generación (3GL): La mayoría de los lenguajes
modernos, diseñados para facilitar la programación a los humanos.
Ejemplos: C, Java.
 Lenguajes de cuarta generación (4GL): Diseñados con un propósito
concreto, o sea, para abordar un tipo concreto de problemas. Ejemplos:
NATURAL, Mathematica.

 Lenguajes de quinta generación (5GL): La intención es que el programador

establezca el qué problema ha de ser resuelto y las condiciones a reunir, y la
máquina lo resuelve. Se usan en inteligencia artificial. Ejemplo: Prolog.
4. Manera de ejecutarse.
Según la manera de ejecutarse:
 Lenguajes compilados: Un programa traductor traduce el código del

programa (código fuente) en código máquina (código objeto). Otro programa,
el enlazador, unirá los ficheros de código objeto del programa principal con
los de las librerías para producir el programa ejecutable. Ejemplo: C.
 Lenguajes interpretados: Un programa (intérprete), ejecuta las instrucciones
del programa de manera directa. Ejemplo: Lisp.
 También los hay mixtos, como Java, que primero pasan por una fase de
compilación en la que el código fuente se transforma en “bytecode”, y este
“bytecode” puede ser ejecutado luego (interpretado) en ordenadores con
distintas arquitecturas (procesadores) que tengan todos instalados la misma
“máquina virtual” Java.
5. Manera de abordar la tarea a realizar.

Según la manera de abordar la tarea a realizar, pueden ser:
 Lenguajes imperativos: Indican cómo hay que hacer la tarea, es decir,

expresan los pasos a realizar. Ejemplo: C.
 Lenguajes declarativos: Indican qué hay que hacer. Ejemplos: Lisp, Prolog.
Otros ejemplos de lenguajes declarativos, pero que no son lenguajes de
programación, son HTML (para describir páginas web) o SQL (para consultar
bases de datos).
6. Paradigma de programación.
El paradigma de programación es el estilo de programación empleado. Algunos
lenguajes soportan varios paradigmas, y otros sólo uno. Se puede decir que
históricamente han ido apareciendo para facilitar la tarea de programar según
el tipo de problema a abordar, o para facilitar el mantenimiento del software, o
por otra cuestión similar, por lo que todos corresponden a lenguajes de alto
nivel (o nivel medio), estando los lenguajes ensambladores “atados” a la
arquitectura de su procesador correspondiente. Los principales son:

 Lenguajes de programación procedural: Divide el problema en partes más

pequeñas, que serán realizadas por subprogramas (subrutinas, funciones,
procedimientos), que se llaman unas a otras para ser ejecutadas. Ejemplos:
C, Pascal.
 Lenguajes de programación orientada a objetos: Crean un sistema de clases
y objetos siguiendo el ejemplo del mundo real, en el que unos objetos
realizan acciones y se comunican con otros objetos. Ejemplos: C++, Java.
 Lenguajes de programación funcional: La tarea se realiza evaluando
funciones, (como en Matemáticas), de manera recursiva. Ejemplo: Lisp.
 Lenguajes de programación lógica: La tarea a realizar se expresa
empleando lógica formal matemática. Expresa qué computar. Ejemplo:
Prolog.
Hay muchos paradigmas de programación: Programación genérica,

programación reflexiva, programación orientada a procesos, etc.
7. Lugar de ejecución.
En sistemas distribuidos, según dónde se ejecute:
 Lenguajes de servidor: Se ejecutan en el servidor. Ejemplo: PHP es el más

utilizado en servidores web.
 Lenguajes de cliente: Se ejecutan en el cliente. Ejemplo: JavaScript en
navegadores web.
8. Concurrencia.
Según admitan o no concurrencia de procesos, esto es, la ejecución simultánea
de varios procesos lanzados por el programa:
 Lenguajes concurrentes. Ejemplo: Ada.

 Lenguajes no concurrentes. Ejemplo: C.
9. Interactividad.
Según la interactividad del programa con el usuario u otros programas:
 Lenguajes orientados a sucesos: El flujo del programa es controlado por la

interacción con el usuario o por mensajes de otros programas/sistema

operativo, como editores de texto, interfaces gráficos de usuario (GUI) o

kernels. Ejemplo: VisualBasic, lenguajes de programación declarativos.
 Lenguajes no orientados a sucesos: El flujo del programa no depende de
sucesos exteriores, sino que se conoce de antemano, siendo los procesos
batch el ejemplo más claro (actualizaciones de bases de datos, colas de
impresión de documentos, etc.). Ejemplos: Lenguajes de programación
imperativos.
10. Realización visual.

Según la realización visual o no del programa:
 Lenguajes de programación visual: El programa se realiza moviendo bloques

de construcción de programas (objetos visuales) en un interfaz adecuado
para ello. No confundir con entornos de programación visual, como Microsoft
Visual Studio y sus lenguajes de programación textuales (como Visual C#).
Ejemplo: Mindscript.
 Lenguajes de programación textual: El código del programa se realiza
escribiéndolo. Ejemplos: C, Java, Lisp.
11. Determinismo.
Según se pueda predecir o no el siguiente estado del programa a partir del
estado actual:
 Lenguajes deterministas. Ejemplos: Todos los anteriores.

 Lenguajes probabilísticos o no deterministas: Sirven para explorar grandes
espacios de búsqueda, (como gramáticas), y en la investigación teórica de
hipercomputación. Ejemplo: mutt (generador de texto aleatorio).
12. Productividad.
Según se caractericen por tener virtudes útiles o productivas, u oscuras y
enrevesadas:
 Lenguajes útiles o productivos: Sus virtudes en cuanto a eficiencia, sencillez,

claridad, productividad, etc., motiva que sean utilizados en empresas,
administraciones públicas y/o en la enseñanza. Ejemplos: Cualquier lenguaje
de uso habitual (C, Java, C++, Lisp, Python, Ruby,…).

 Lenguajes esotéricos o exóticos: Inventados con la intención de ser los más

raros, oscuros, difíciles, simples y/o retorcidos de los lenguajes, para
diversión y entretenimiento de frikis programadores. A veces exploran
nuevas ideas en programación. Ejemplo: Brainfuck.
Ejercicios y tareas de investigación
1. ¿Cuáles son los requisitos para ser un buen programador?

2. ¿En que consiste el lenguaje binario? – Haga un ejemplo.
3. Que lenguajes de programación conoce y a que categoría pertenecen.
4. Explique que es un compilador y para que sirve.
5. ¿Qué es el código fuente de un sistema?

02
TAREA 02: ANALIZAR LA ESTRUCTURA GENERAL DE UN
PROGRAMA.

 Definir el concepto y partes de un programa.
 Elaborar la documentación de un programa.
" Un fracaso es sólo una cicatriz, un mapa hacia la

victoria...”……. ANONIMO.
Orden de Ejecución:
 Definir el concepto y partes de un programa.
 Elaborar la documentación de un programa.

OPERACIÓN:
DEFINIR EL CONCEPTO Y PARTES DE UN PROGRAMA.
Desde la perspectiva de la informática, un programa de
aplicación consiste en una clase de software que se
diseña con el fin de que para el usuario sea más
sencilla la concreción de un determinado trabajo. Esta
particularidad lo distingue del resto de los programas,
entre los cuales se pueden citar a los sistemas
operativos (que son los que permiten el funcionamiento
de la computadora), los lenguajes de programación
(aquellos que dan las herramientas necesarias para desarrollar los programas
informáticos en general) y las utilidades (pensadas para realizar acciones de
mantenimiento y tareas generales).
Programa de aplicaciónEl software es el elemento intangible y lógico que forma

parte de una computadora. El hardware, en cambio, es el componente material
y físico. Se dice que los sistemas operativos constituyen el lazo que une al
software con el hardware.
Los procesadores de texto, las hojas de cálculo y las bases de datos forman
parte de los denominados programas de aplicación. Esto demuestra que las
aplicaciones informáticas sirven para automatizar tareas como la contabilidad o
la redacción de textos.
En el caso de los procesadores podemos destacar a Microsoft Word, que es el

más utilizado actualmente en todo el mundo y que se caracteriza o define
porque le ofrece la posibilidad al usuario de llevar a cabo la creación, diseño e
impresión de documentos textuales de diversa tipología como pueden ser
informes, cartas, redacciones…
Microsoft Excel, por su parte, es el programa de aplicación más extendido en

materia de hojas de cálculo. En multitud de empresas de distinta índole, y
también a nivel personal, se opta por hacer uso de dicho software que se utiliza
frecuentemente en lo que son labores de tipo contable y financiero.
En materia de las bases de datos, hay que

destacar como programación de aplicación a
Access que está diseñado tanto para poder
trabajar con aquellas en el ámbito profesional

como en el más personal. Gracias al mismo se pueden desarrollar desde tablas

para guardar los datos pertinentes hasta consultas para recuperar cierta
información pasando por formularios para actualizar aquellos o los informes
que se utilizan para llevar a cabo la impresión de los datos que se estimen
oportunos.
No obstante, no podemos pasar por alto que estos tres programas,

pertenecientes a Microsoft, tienen un importante rival desde hace algún tiempo:
OpenOffice. Y es que es una llamada “suite informática” de tipo libre que
cuenta con una serie de aplicaciones que permiten realizar las mismas tareas
que aquellos nos ofrecen.
En concreto los rivales serían OpenOffice Writer como procesador de textos,

OpenOffice Calc como hojas de cálculo y OpenOffice Base que funciona como
base de datos.
En ocasiones, los programas de aplicación son diseñados a medida, es decir,

según las necesidades y pretensiones de cada usuario. Por eso, el software
permite resolver dificultades específicas. En otros casos, se trata de paquetes
integrados que solucionan problemas generales e incluyen múltiples
aplicaciones. Por ejemplo, un paquete de oficina combina aplicaciones como
procesadores de textos y hojas de cálculo.
Cabe destacar que el paquete o suite de oficina más popular a escala

internacional es Office, un producto impulsado por Microsoft. Esta compañía,
fundada en 1975 por Bill Gates y Paul Allen, es la firma de software más
grande del mundo. Su actividad no se agota en los programas de aplicación,
sino que la empresa también desarrolla el sistema operativo más popular:
Windows.
Elaborar la documentación de un programa.

El fin de documentar el código de un programa es simplemente hacer que los
demás entiendan que está haciendo el programa o porque lo hace, y no que
nada más la computadora entienda el código.
 ¿Qué debemos documentar?
 ¿De que se encarga tal clase?
 ¿Qué hace tal método?
 El uso de algunas variables importantes.
 El algoritmo que estamos usando.

 Limitaciones del programa.
El hablar de los tipos de comentarios depende mucho del lenguaje de

programación que estes usando.
Una línea de código

“//”
Javadoc
“/**” varias líneas de código
Tipo c
“/*”
Manuales técnicos o manuales de mantenimiento.

Esta documentación esta destinada a los
programadores y ayuda de referencia para dar
manteminiento a un sistema dentro de su vida
útil. Los tipos de documentación dentro de estos
manuales son internas y externas. La
documentación Interna: se refiere a los
comentarios que encontramos dentro del
programa fuente (detalles significativos de un
programador). La documentación Externa: se refiere a toda aquella información
que se encuentra independiente del programa por ejemplo manuales impresos
que se otorga junto con el programa aquí es dondé se describen todas las
características técnicas del programa y su funcionamiento.
Manual del Usuario.

Este manual no es más que un documento que le
indica o le ayuda al usuario a conocer, utilizar y
operar de una manera correcta el sistema o
programa que se ha desarrollado, se describen los
objetivos y características externas.
Definir el concepto y partes de un programa.

Definición de Programa.

Siendo la base de los ordenadores y lo que es la

informática en sí, muchos conocemos de que para
poder utilizar un equipo debemos contar con un
Programa que nos permite realizar una función
determinada dentro de un sistema, pero quizá muy
pocos puedan definir exactamente en qué consiste
uno de estos, por lo que a continuación daremos un
breve reseña de los mismos.
Definimos entonces como Programa a un conjunto de instructivos que son

impartidos hacia el Ordenador indicando las instrucciones que incluyen el paso
por paso para poder llegar a un resultado determinado, debiendo para ello
tener una organización específica y seguir los pasos de una estructura,
teniendo entonces predefinidas una serie de acciones que son seguidas para
obtener el resultado esperado.
La planificación de los Programas se lleva en forma bastante similar a lo que es

un Método Científico, teniendo como punto de partida el establecimiento de una
Problemática determinada que éste tenderá a solucionar, lo que es justamente
el inicio de toda planificación y contando con distintos métodos de trabajo.
La derivación de este inicio dará lugar a un Algoritmo,

que permitirá generar entonces una serie de Pasos
Predeterminados que tendrá que seguir el ordenador
(es decir, las instrucciones que imparte el programa)
teniendo entonces una Secuencia Lógica que deberá
seguirse para poder dar una solución a la problemática
inicial.
La elaboración de un programa hasta este momento está dado entonces por la

utilización de un Lenguaje de Alto Nivel, que es el que es entendible por los
usuarios que tengan los conocimientos de programación determinados, y que
sigue entonces distintas Reglas y Condiciones que son impuestas por la
aplicación que se utiliza para la tarea de programación.
La prueba del Algoritmo se realiza mediante la tarea de verificación que

conlleva posteriormente a la Compilación, que consiste en la traducción del
Código Fuente (es decir, el mencionado anteriormente entendible por los
usuarios) hacia la realización de un Código Objeto que es el que está en
Lenguaje de Bajo Nivel, solamente entendido por el ordenador y sus distintos
dispositivos, y que emplea justamente el Código Binario de ceros y unos, es
decir, la transmisión o no-transmisión de impulsos eléctricos, que permite la
conexión mediante el circuito electrónico cerrado que es el sistema operativo.

Debemos pensar entonces que un Programa no solo puede contar con un

proceso o un algoritmo determinado, ni que puede cumplir solamente una
función, sino que puede contener una muy alta complejidad de Soluciones a
distintas problemáticas que hayan sido planteadas.
Funcionamiento.
El comportamiento de un programa depende del tipo de lenguaje usado para

escribirlo. En cualquier caso, casi todos los lenguajes de programación se
basan en el mismo principio: el programa consiste en un conjunto de comandos
que el equipo debe ejecutar.
El equipo ejecuta los comandos a medida que va leyendo el archivo (de arriba
hacia abajo) hasta que alcanza un comando (al que a menudo se hace
referencia como un comando ramificado) que ordena al equipo ir a una
ubicación específica del programa. En cierto modo, se parece a la búsqueda
del tesoro, donde el equipo debe seguir las pistas y ejecutar los comandos
hasta alcanzar el final del programa y detenerse.
Forma de ejecución.
Una vez escritos, los programas pueden ser ejecutados de diversas formas:
Mediante un programa que va adaptando las instrucciones conforme son

encontradas. A este proceso se lo llama interpretar y a los programas que lo
hacen se los conoce como intérpretes. Ejemplos de esto son bash, clásico en
estaciones Unix y que fue escrito para el proyecto GNU o Python, cuya
peculiaridad además de ser multipropósito, está en su facilidad de uso y
productividad y de hecho, es usado en parte de los proyectos Google y
YouTube.
Traduciendo el código escrito del programa (lo que se denomina código

fuente), a su equivalente en lenguaje máquina.
A este proceso se le llama compilar y al programa traductor se le denomina

compilador. Ejemplos de esto son: El lenguaje C, que combina en su sintaxis
característica de medio y bajo nivel y el compilador gcc usado en el proyecto
GNU.
Ejecución y almacenamiento de los programas informáticos.
Típicamente, los programas se almacenan en una memoria no volátil, para que

luego el usuario de la computadora, directa o indirectamente, solicite su
ejecución. Al momento de dicha solicitud, el programa es cargado en la

memoria de acceso aleatorio o RAM del equipo, bajo el control del software
llamado sistema operativo, el cual puede acceder directamente al procesador.
El procesador ejecuta (corre) el programa, instrucción por instrucción hasta que
termina. A un programa en ejecución se le suele llamar también proceso. Un
programa puede terminar su ejecución en forma normal o por causa de un
error, dicho error puede ser de software o de hardware.
Tipos de programas.
Programas empotrados en hardware: Algunos programas están empotrados en

el hardware. Una computadora con arquitectura de programas almacenados
requiere un programa inicial almacenado en su ROM para arrancar. El proceso
de arranque es para identificar e inicializar todos los aspectos del sistema,
desde los registros del procesador, controladores de dispositivos hasta el
contenido de la memoria RAM. Seguido del proceso de inicialización, este
programa inicial carga al sistema operativo e inicializa al contador de programa
para empezar las operaciones normales. Independiente de la computadora, un
dispositivo de hardware podría tener firmware empotrado para el control de sus
operaciones. El firmware se utiliza cuando se espera que el programa cambie
en raras ocasiones o nunca, o cuando el programa no debe perderse cuando
haya ausencia de energía.
Programas cargados manualmente: Los programas históricamente se

cargaron manualmente al procesador central mediante interruptores. Una
instrucción era representada por una configuración de estado abierto o cerrado
de los interruptores. Después de establecer la configuración, se ejecutaba un
botón de ejecución. Este proceso era repetitivo. También, históricamente los
programas se cargaban manualmente mediante una cinta de papel o tarjetas
perforadas. Después de que el programa se cargaba, la dirección de inicio se
establecía mediante interruptores y el botón de ejecución se presionaba.
Programas generados automáticamente: La programación automática es un

estilo de programación que crea código fuente mediante clases genéricas,
prototipos, plantillas, aspectos, y generadores de código para aumentar la
productividad del programador. El código fuente se genera con herramientas de
programación tal como un procesador de plantilla o un IDE. La forma más
simple de un generador de código fuente es un procesador macro, tal como el
preprocesador de C, que reemplaza patrones de código fuente de acuerdo a
reglas relativamente simples.
Un motor de software da de salida código fuente o lenguaje de marcado que
simultáneamente se vuelve la entrada de otro proceso informático. Podemos
pensar como analogía un proceso manejando a otro siendo el código máquina
quemado como combustible. Los servidores de aplicaciones son motores de
software que entregan aplicaciones a computadoras cliente. Por ejemplo, un

software para wikis es un sevidor de aplicaciones que permite a los usuarios

desarrollar contenido dinámico ensamblado a partir de artículos. Las Wikis
generan HTML, CSS, Java, y Javascript los cuales son interpretados por un
navegador web.
Ejecución simultánea de programas.
Muchos programas pueden correr simultáneamente en la misma computadora,

a lo cual se le conoce como multitarea y puede lograrse a través de
mecanismos de software o de hardware. Los sistemas operativos modernos
pueden correr varios programas a través del planificador de procesos — un
mecanismo de software para conmutar con frecuencia la cantidad de procesos
del procesador de modo que los usuarios puedan interactuar con cada
programa mientras estos están corriendo.
También se puede lograr la multitarea por medio del hardware; las

computadoras modernas que usan varios procesadores o procesadores con
varios núcleos pueden correr muchos programas a la vez.
Categorías funcionales.
Los programas se pueden categorizar según líneas funcionales. Estas

categorías funcionales son software de sistema y software de aplicación. El
software de sistema incluye al sistema operativo el cual acopla el hardware con
el software de aplicación.
El propósito del sistema operativo es proveer un ambiente en el cual el

software de aplicación se ejecuta de una manera conveniente y eficiente.
Además del sistema operativo, el software de sistema incluye programas
utilitarios que ayudan a manejar y configurar la computadora. Si un programa
no es software de sistema entonces es software de aplicación.
El middleware también es un software de aplicación que acopla el software de

sistema con la interfaz de usuario. También son software de aplicación los
programas utilitarios que ayudan a los usuarios a resolver problemas de
aplicaciones, como por ejemplo la necesidad de ordenamiento.
Partes de un programa
Entrada y salida de datos Estructura de un programa

Aquí aprenderás a comunicarte En esta parte se define el orden en
con el usuario a través de las el que se escriben, en qué
interfaces de usuario los cuales consisten, cuáles son obligatorias
tienen unos procedimientos que te y cuáles no, cómo se relacionan

permiten leer y escribir datos en la unas con otras, etc.

salida y entrada estándar
respectivamente.
Sentencias y expresiones Variables y constantes

Los operadores se utilizan para
Constantes: Tienen un valor fijo
construir expresiones que calculan
que se le da cuando se define la
valores; las expresiones son los
constante y que ya no puede ser
componentes centrales de las
modificado durante la ejecución.
sentencias; las sentencias se
pueden agrupar en bloques.
Variables: El valor puede cambiar
durante la ejecución del algoritmo,
pero nunca varía su nombre y su
tipo.
Control del flujo Tipos de datos

En esta parte aprenderá a que sus
Es uno de los conceptos
programas puedan variar el orden
fundamentales de cualquier
de su ejecución si se cumplen
lenguaje de programación. Estos
ciertas condiciones (sentencias
definen los métodos de
selectivas). Y también aprenderá a
almacenamiento disponibles para
repetir algo varias veces
representar información, junto con
(sentencias iterativas).
la manera en que dicha
información ha de ser interpretada.
Para crear una variable (de un tipo

simple) en memoria debe
declararse indicando su tipo de
variable y su identificador que la
identificará de forma única.
Programación modular.
En esta parte se ve como construír pequeños programas
(procedimientos y funciones) que ayuden a solucionar un problema
grande dividiéndolo en subproblemas
Elaborar la documentación de un programa.

Un sistema pobremente documentado carece de valor
aunque haya funcionado bien en alguna ocasión. En el
caso de programas pequeños y poco importantes que
sólo se utilizan durante un corto periodo de tiempo,
unos cuantos comentarios en el código podrían ser
suficientes. No obstante, la mayoría de los programas
cuya única documentación es el código, se quedan
obsoletos rápidamente y es imposible mantenerlos. El

que la dedicación de un poco de esfuerzo a la documentación sea

recompensada incluso dentro de los límites de un pequeño proyecto, constituye
una sorpresa para la mayoría de los novatos.
A menos que usted sea infalible y viva en un mundo en el que nada cambia,
tendrá que volver a consultar el código que ya está escrito, y pondrá en duda
decisiones que tomó durante el desarrollo del mismo. Si no documenta sus
decisiones, se verá siempre cometiendo los mismos errores y tratando de
comprender lo que pudo haber descrito fácilmente en una ocasión. La falta de
documentación no sólo genera trabajo adicional, sino que también tiende a
dañar la calidad del código. Si no posee una nítida caracterización del
problema, es imposible que desarrolle una solución clara.
Aprender a documentar software es una tarea complicada

y exige un criterio de ingeniería maduro. Documentar de
forma concisa es un error habitual, pero el otro extremo
puede resultar igual de perjudicial: si escribe
documentaciones extensas, éstas atosigarán al lector y
constituirán una carga a la hora de conservarlas. Es
esencial documentar sólo los asuntos correctos. La
documentación no sirve de ayuda para nadie si su
extensión desanima a la gente a la hora de leerla.
Los principiantes tienen la tentación de centrar sus esfuerzos en temas

sencillos, ya que éstos les resultan más fáciles de documentar. Esto es una
pérdida de tiempo; no se aprende nada del esfuerzo y se termina escribiendo
una documentación que es cualquier cosa excepto útil. Los principiantes
también tienden a mostrarse reacios con los problemas de documentación.
Esto trae consigo poca visión de futuro: si usted sabe que algún aspecto de su
diseño no es del todo correcto, que alguna parte del problema no se ha
aclarado o que es posible que parte del código tenga errores, ¡dígalo! Hará que
el lector ahorre tiempo dándole vueltas a algo que aparentemente es erróneo,
se acordará de dónde tiene que mirar si encuentra problemas y acabará
teniendo una documentación más útil y honesta.
Otro asunto es cuándo documentar. Aunque algunas

veces es conveniente posponer la tarea de la
documentación mientras se realizan experimentos, los
programadores con experiencia suelen documentar de
forma metódica incluso el código provisional, los análisis
de un problema inicial y los borradores de un diseño.

Ellos creen que esto hace que la experimentación sea más productiva.
Además, dado que han tomado la documentación como hábito, les resulta
normal documentar a medida que van avanzando.
La documentación se integra de todos los elementos que explican las

características de un programa o sistema, y son necesarios para poder
utilizarlo, operarlo o modificarlo. Documentar es una tarea tan necesaria e
importante como escribir el código: el código indica cómo funciona el programa,
y la documentación indica porqué lo hace. El responsable de un proyecto no
debe permitir que se entreguen sistemas sin documentación.
Cuando un programa es pequeño el programador generalmente puede retener
en la mente todos los detalles (al menos por algún tiempo), por lo cual no
necesita de documentación. En el caso de programas amplios se vuelve
imposible recordar cómo se relaciona cada detalle con los demás. Si además
se considera que posteriormente el programa tendrá que ser modificado, se
apreciará que el propósito del código de un programador no es solamente
instruir a un dispositivo electrónico sobre cómo solucionar un problema, sino
informar a los futuros programadores sobre cómo fue resuelto el problema.
Pero la documentación no sólo es para los
programadores, también los usuarios de los
programas necesitan de ayuda para operarlo; e
incluso el comprador requiere de material que le
permita evaluarla compra. Hacer que la
documentación sea concisa y descriptiva a la
vez. Ser congruente en todos los programas. El
tiempo de lectura de los programas es mucho
más largo que el de escritura. Si el proyecto es
pequeño, puede ser suficiente con recopilar toda
la documentación en un archivo e integrarlo con los demás archivos del
programa.
MANUAL TÉCNICO O DE MANTENIMIENTO:.

Es la documentación destinada a los programadores y sirve de referencia para
darle mantenimiento a un sistema durante su vida útil. Tiene dos niveles:
Interna y Externa. Documentación interna: Son los comentarios que se
encuentran dentro del programa fuente, y que describen detalles significativos
para un programador. Documentación externa: Es aquella que se encuentra
independiente del programa fuente. Suele encontrarse en un manual (impreso)
que se proporciona con el programa y describe con profundidad sus
características técnicas y funcionamiento.

Manual del usuario: Es un documento que le indica al usuario (u operador)

conocer, utilizar y operar correctamente el sistema. Describe los objetivos y
opciones del programa, así como sus características externas. La
documentación básica para un programa (o un sistema pequeño). Sin
embargo, si se desarrolla un sistema grande o complejo, cada etapa del
proceso de desarrollo deberá ser documentada.
1. ¿Indique que es un programa informatico para Ud.?

2. ¿Cuáles son los elementos más importantes de un programa?
3. Mencione una lista de 10 programas y clasifiquelos.
4. ¿Es importante documentar un programa?, explique.
5. Descargue un software de aplicación que tenga licencia Free y elabore la
estructura del manual de usuario.

03
TAREA 03: APLICAR LA LÓGICA DE PROGRAMACIÓN.

 Definir el concepto de un algoritmo.
 Construir algoritmos para resolver casos prácticos.
 Elaborar diagramas de flujo.
 Construir Pseudocodigos
" El triunfo del verdadero hombre surge de las cenizas del

error....”……. Pablo Neruda.

 Definir el concepto de un algoritmo.
 Construir algoritmos para resolver casos prácticos.
 Elaborar diagramas de flujo.
 Construir Pseudocodigos

OPERACIÓN:
DEFINIR EL CONCEPTO DE UN ALGORITMO.
DEFINICIÓN: Un Algoritmo, se puede definir como una secuencia de

instrucciones que representan un modelo de solución para determinado tipo de
problemas. O bien como un conjunto de instrucciones que realizadas en orden
conducen a obtener la solución de un problema. Por lo tanto podemos decir
que es un conjunto ordenado y finito de pasos que nos permite solucionar un
problema.
CLASIFICACIÓN DE ALGORITMOS:
Los algoritmos se pueden clasificar en cuatro tipos:
 Algoritmo computacional: Es un algoritmo que puede ser ejecutado en una

computadora. Ejemplo: Fórmula aplicada para un cálculo de la raíz cuadrada
de un valor x.
 Algoritmo no computacional: Es un algoritmo que no requiere de una
computadora para ser ejecutado. Ejemplo: Instalación de un equipo de
sonido.
 Algoritmo cualitativo: Un algoritmo es cualitativo cuando en sus pasos o
instrucciones no están involucrados cálculos numéricos. Ejemplos: Las
instrucciones para desarrollar una actividad física, encontrar un tesoro.
 Algoritmo cuantitativo: Una algoritmo es cuantitativo cuando en sus pasos o
instrucciones involucran cálculos numéricos. Ejemplo: Solución de una
ecuación de segundo grado.
TÉCNICAS DE REPRESENTACIÓN: Para la representación de un algoritmo,

antes de ser convertido a lenguaje de programación, se utilizan algunos
métodos de representación escrita, gráfica o matemática. Los métodos más
conocidos son:

 Diagramación libre (Diagramas de flujo).

 Diagramas Nassi-Shneiderman.
 Pseudocódigo.
 Lenguaje natural (español, inglés, etc.).
 Fórmulas matemáticas.
SÍMBOLOS O FIGURAS DEL DIAGRAMA DE FLUJO Y SU

SIGNIFICADO

Al diseñar un algoritmo se debe tener presente las características de precisión,

definición y finitud.
Visualicemos estas características a través del siguiente ejemplo:
Ejemplo: Algoritmo para hacer una torta
Entrada: Harina de trigo, mantequilla, huevos, sal, azúcar
Proceso:
1.- Unir la mantequilla con el azúcar
2.- Batir hasta lograr consistencia cremosa
3.- Agregar harina de trigo, huevos, sal y azúcar
4.- Batir hasta que esponje
5.- Precalentar el horno, en 250 °, y enmantequillar tortera
6.- Una vez logre la consistencia de esponjado, colocar en la tortera
7.- Introducir en el horno por espacio de 45 minutos

Salida:
Torta
Siguiendo el ejemplo recuerde determinar las instrucciones de Entrada,
Proceso y Salida.
Según el ejercicio anterior, se puede determinar que el algoritmo para hacer

torta, cumple con las características fundamentales de los algoritmos. Es decir,
¿Es preciso?, ¿Es definido?, ¿Es finito?, razona tus respuestas.
OPERACIÓN:
CONSTRUIR ALGORITMOS PARA RESOLVER CASOS PRÁCTICOS.
Ejemplos de algoritmos de estudio.
Pasos para lograr una carrera universitaria:
Primero deberás realizar lo siguiente:
A la edad de 3 años iniciar el preescolar y concluirlo,

a los 6 años iniciaras el nivel primaria que durará 6 años, del cual egresaras a
la edad 12 años,
por lo que posteriormente deberás matricularte en el nivel secundaria
y ahí durarás 5 años, y posteriormente la universidad en la cual estudiarás
durante 5 años más, para que en los ultimos años identifiques con cual carrera
universitaria te identificas y será tu preparación ser un futuro profesionista.
Ejemplos de algoritmos matemáticos.
Pasos para realizar la suma de dígitos y obtener el total.
Se tiene que hacer el siguiente algoritmo:
Tener 1 dígito más (+) otro dígito y obtener el total (=).

250 + 250 = 500
De esa forma se sigue un algoritmo sumatoria para lograr el resultado.
Ejemplos de algoritmos de uso de computadora.
Ejemplos de algoritmos variados.

Pasos para manejar o usar una computadora.
Se tiene que encender previamente conectando el cable en el enchufe.

Oprimir el botón de la pc, de encendido.
Oprimir el botón de encendido del monitor.
Esperar que inicie el sistema operativo windows.
Tener ya conectado el teclado y el mouse.
Y listo para iniciar a trabajar en su computadora o navegar por internet
Pasos para desarrollar el algoritmo para lavarse las manos.
INICIO
Abrir el grifo de agua.
Mojarse las manos.
Aplicarse jabón.
Enjuagarse las manos.
Cerrar el grifo de agua.
Secarse las manos con papel.
Exponer las manos a corriente de aire caliente.
FIN
Pasos para desarrollar el algoritmo para cambiar la llanta de un auto.
INICIO.
levantar el auto con la gata.
soltar y sacar los pernos de la llanta.
quitar la llanta.
colocar llanta de repuesto.
colocar y apretar los pernos.
bajar la gata.
FIN

Desarrollar el algoritmo para el siguiente problema:

PROBLEMA: Un estudiante se encuentra en su casa (durmiendo) y
debe ir a la universidad (a tomar la clase de programación!!), ¿qué
debe haga el estudiante?
Inicio
Dormir
haga 1 hasta que suene el despertador (o lo llame la mamá).
Mirar la hora.
¿Hay tiempo suficiente?
Si hay, entonces
Bañarse.
Vestirse.
Desayunar.
Sino,
Vestirse.
Cepillarse los dientes.
Despedirse de la mamá y el papá.
¿Hay tiempo suficiente?
Si, Caminar al paradero.
Sino, Correr al paradero.
Hasta que pase un bus para la universidad haga :
Esperar el bus
Ver a las demás personas que esperan un bus.
Tomar el bus.
Mientras no llegue a la universidad haga :
Seguir en el bus.
Pelear mentalmente con el conductor.
Timbrar.
Bajarse.
Entrar a la universidad.
Fin

OPERACIÓN:
ELABORAR DIAGRAMAS DE FLUJO.
Pasos para elaborar un diagrama de flujo para encontrar el area de un

triangulo.
Pasos para elaborar un diagrama de flujo para encontrar promedio de tres

calificaciones.
Pseudocodigo
1.- Inicio
2.- Calificacion1← 0, Calificacion2←0, Calificacion3←0, Promedio←0
3.- Leer “Dame Calificación 1: ”, Calificacion1
4.- Leer “Dame Calificación 2: “, Calificacion2
6.- Promedio←(Calificacion1+Calificacion2+Calificacion3)/3
7.- Imprimir “El Promedio es: ”Promedio
8.- Fin

El diagrama de flujo o diagrama de actividades es la representación gráfica del

algoritmo o proceso. Se utiliza en disciplinas como programación, economía,
procesos industriales y psicología cognitiva.
En Lenguaje Unificado de Modelado (UML), un diagrama de actividades

representa los flujos de trabajo paso a paso de negocio y operacionales de los
componentes en un sistema. Un diagrama de actividades muestra el flujo de
control general.
Tipos de diagramas de flujo
Formato vertical: En él, el flujo y la secuencia de las operaciones, va de arriba

hacia abajo. Es una lista ordenada de las operaciones de un proceso con toda
la información que se considere necesaria, según su propósito.
Formato horizontal: En él, el flujo o la secuencia de las operaciones, va de

izquierda a derecha.
Formato panorámico: El proceso entero está representado en una sola carta

y puede apreciarse de una sola mirada mucho más rápido que leyendo el texto,
lo que facilita su comprensión, aun para personas no familiarizadas. Registra
no solo en línea vertical, sino también horizontal, distintas acciones simultáneas
y la participación de más de un puesto o departamento que el formato vertical
no registra.
Formato Arquitectónico: Describe el itinerario de ruta de una forma o persona

sobre el plano arquitectónico del área de trabajo. El primero de los flujogramas
es eminentemente descriptivo, mientras que los utilizados son
fundamentalmente representativos.
Pasos para crear el diagrama de flujo que proporcione el precio medio de

un producto a partir del precio en tres establecimientos distintos.

OPERACIÓN:
CONSTRUIR PSEUDOCODIGOS.
Pasos para desarrollar un pseudocodigo que permita leer dos valores

distintos, determinar cual de los dos valores es el mayor y escribirlo.
Pseudocódigo Diagrama de Flujo

1. Inicio
2. Inicializar variables: A = 0,
B=0
3. Solicitar la introducción de
dos
valores distintos
4. Leer los dos valores
5. Asignarlos a las variables A

yB
6. Si A = B Entonces vuelve a
3
porque los valores deben ser
distintos
7. Si A>B Entonces
Escribir A, “Es el mayor”
8. De lo contrario: Escribir B,
“Es
el mayor”
9. Fin_Si
10. Fin
Pasos para desarrollar un Pseudocodigo que permita calcular el area de

un triangulo:
1.- Inicio
2.- Base ← 0, Altura ← 0, Area ←0
3.- Leer “Dame base: ”, Base
4.- Leer “Dame Altura: ”, Altura
5.- Area ← (Base*Altura)/2
6.- Imprimir “El Area es: ”, Area
7.- Fin
Pasos para desarrollar un pseudocodigo que permita calcular el promedio
de tres calificaciones:
1.- Inicio
2.- Calificacion1← 0, Calificacion2←0, Calificacion3←0, Promedio←0
3.- Leer “Dame Calificación 1: ”, Calificacion1
6.- Promedio←(Calificacion1+Calificacion2+Calificacion3)/3
7.- Imprimir “El Promedio es: ”Promedio
8.- Fin
Pasos para desarrollar el siguiente caso utilizando pseudocodigo:
Desarrolle un algoritmo que permita leer tres valores y almacenarlos en

las variables A, B y C respectivamente. El algoritmo debe imprimir cual es
el mayor y cual es el menor. Recuerde constatar que los tres valores
introducidos por el teclado sean valores distintos. Presente un mensaje
de alerta en caso de que se detecte la introducción de valores iguales.

1. Inicio
2. Inicializar las
variables A, B y C
3. Leer los tres valores
4. Almacenar en las
variables A, B
yC
5. Si A > B y A > C
Entonces
6. Escribir A “Es el
mayor”
7. Sino
8. Si B > A y B > C
Entonces
9. Escribir B “Es el
mayor”
10. Sino
11. Escribir C “Es el
mayor”
12. Fin_Si
13. Fin_Si
14. Fin

Pasos para desarrollar un pseudocodigo que que realice la sumatoria de

los números enteros comprendidos entre el 1 y el 10, es decir, 1 + 2 + 3 +
…. + 10:

1. Inicio
2. Declaración de
variables:
N= 0, Suma = 0
3. Asignación Contador :
N=N+1
4. Asignación
Acumulador:
Suma = Suma + N
5. Si N = 10 Entonces
6. Escribir Suma
7. De lo contrario,
Repetir desde el
paso 3
8. Fin_Si
8. Fin

Definir el concepto de un algoritmo.

Es un conjunto de pasos lógicosordenados, secuencialmente yfinita, escritos de
tal forma quepermiten visualizar la solución deun problema determinado en
unmomento específico.
Características:
 Finito: debe tener un fi.
 Concreto: Realizar funciones y operaciones.
 Legible: Estar bien estructurado.
 Eficiente: realizar las operaciones con unmínimo de recursos.
 No ambiguo: libre de errores.
 Preciso: Indicar un orden para la realización decada paso.
 Definido: Igual resultado siempre (Si se sigue un algoritmos dos o mas veces
dara el mismo resultado).
Estructura:
 Datos.
 Procesos.
 Estructuras de Control.
 ELEMENTOS.
 Entradas (variables y constantes) salidas.
Ejemplo: encender un automóvil
1. Poner la llave.
2. Asegurarse que el cambio esté en neutro.
3. Pisar el acelerador.
4. Girar la llave hasta la posición “arranque”.
5. Si el motor arranca antes de 6 seg, dejar lallave en la posición “encendido”.
6. Si el motor no arranca antes de 6 seg, volver al paso 3 (como máximo 5
veces).
7. Si el auto no arranca, llamar a la grúa.

Requisitos:
 Definir el problema.
 Debe estar dentro del contexto.
 Debe resolver el problema.
 Debe evitar la ambigüedad.
El siguiente ejemplo muestra un algoritmo para cambiar un foco quemado.
Cambiar un foco quemado podría resumirse en dos pasos:
o Quitar el foco quemado.

o Colocar un foco nuevo.
Pero, si tuviera que entrenar un robot doméstico para que efectúe esta tarea,
tendrá que ser más específico y claro en los pasos a seguir, dar mas detalles
(suponga que el foco se encuentra en el techo de una habitación):
o Situar escalera bajo el foco quemado.

o Elegir un foco de remplazo (de la misma potencia que el anterior).
o Subir por la escalera hasta alcanzar el foco.
o Girar el foco contra las manecillas del reloj hasta que esté suelto.
o Ubicar el foco nuevo en el mismo lugar que el anterior.
o Enroscar en el sentido de las manecillas del reloj hasta que quede apretado.
o Bajar de la escalera.
NOTA:
Los algoritmos pueden representarse a través de un conjunto de palabras por
medio de las cuales se puede representar la lógica de un programa. Este
conjunto de palabras constituyen lo que se conoce como pseudocódigo.
Además, los algoritmos se pueden representar gráficamente a través de un
diagrama de flujo. Ambas herramientas se describen a continuación.
Construir algoritmos para resolver casos prácticos.

Elementos para la construcción de un algoritmo.
Definíamos algoritmo como un conjunto de pasos conducentes a resolver un

problema, cada uno de esos pasos, corresponde a lo que se denomina en el
programa, una instrucción, aunque pudiera darse que, en una instrucción se
junten dos o más pasos.
Aprender a realizar un algoritmo se fundamenta en lo que se persigue lograr

con su desarrollo; debido a que no existe un método único para resolver

problemas se estudian diferentes métodos de resolución o modelos de

construcción para lograr la generación del resultado deseado.
Esto nos lleva a reestructurar el concepto de algoritmo, como un conjunto de

instrucciones o pasos en los que se describe su inicio, desarrollo o proceso y
salida o resultado del algoritmo; elaborados para lograr resolver un problema.
Dado que un algoritmo es un conjunto de instrucciones elaboradas con la

finalidad de resolver un problema, a continuación se describen los elementos
que se utilizan en la construcción de una instrucción.
Instrucción o sentencia.
Dependiendo del origen del material instruccional se habla de instrucción o

sentencia; ésta, define una acción o un mandato que se debe realizar, esa
acción o mandato se representa a través de un comando o lo que es lo mismo
palabras reservadas de un lenguaje de programación en particular.
Una instrucción esta compuesta por uno o más comandos (acción), datos,
símbolos, variables o constantes y expresiones, que en conjunto representan
una instrucción o sentencia.
Ejemplo de instrucción:
En la construcción de los programas se estila utilizar una instrucción por línea.
Así mismo, se utiliza la identación, que no es más que la alineación de aquellas
instrucciones dentro de las estructuras que las contienen de manera ordenada
que permita visualizar el inicio y fin de cada bloque de instrucciones.
Si ASISTIO =”SI” Entonces

Leer Sueldo,
Asignar Sueldo = Sueldo + HoraExtra
Fin Si
Donde:
SI
Representa una estructura condicional utilizada para establecer preguntas
o programar ciertas condiciones
ASISTIO
Nombre de una Variable lógica que puede obtener sólo dos valores “SI”
o “NO”. En el ejemplo se programa la condición de la variables cuando
es “SI”
ENTONCES

Parte de la instrucción o estructura condicional
LEER SUELDO
Instrucción utilizando el comando cuya acción es la lectura de un campo
o dato
Asignar SUELDO=
SUELDO+HORAEXTRA
Instrucción de asignación, permite asignar o calcular el valor que adquirirá
una variable
Fin SI
Cierra la estructura condicional Si –Entonces –Fin Si
Comandos o palabras reservadas.

Todos los lenguajes, naturales o computacionales, tienen palabras que denotan
una acción. Los comandos no son más que acciones que debe interpretar y
ejecutar el computador. Cada comando conserva una sintaxis determinada, es
decir la forma de utilizarlo. Los lenguajes computacionales tienen en su
repertorio comandos dirigidos al procesamiento de archivos y datos, entre ellos:
Leer, Calcular, Asignar, Clasificar, Imprimir.
Datos.
Los datos son símbolos que se convierten en condiciones, hechos, situaciones
o valores. Un dato puede significar un número, una letra, un signo ortográfico o
cualquier símbolo que represente una cantidad, una medida, una palabra o una
descripción. La importancia de los datos está en su capacidad de asociarse
dentro de un contexto para convertirse en información. Es decir, por si mismos
los datos no tienen capacidad de comunicar un significado y por tanto no
pueden afectar el comportamiento de quien los recibe. Para ser útiles, los datos
deben convertirse en información que ofrezca un significado, conocimiento,
ideas o conclusiones.
TIPOS DE DATOS.
Como se describió anteriormente, un dato es un campo que puede convertirse

en información. Existen datos simples (sin estructura) y compuestos
(estructurados).
Los datos simples son los siguientes:

- Numéricos (Reales, Enteros)
- Lógicos
- Carácter (Char, String)
Los tipos de datos simples son:

Tipos de datos

Numéricos Lógicos Carácter

Reales Enteros Char String
☺ Ejemplo. Ejemplos de tipos de datos simples
Tipo de datos Características
Ejemplos.
Numéricos Enteros.
Los números enteros son los números naturales positivos y negativos que
conocemos.
1
2
25
146
-456
Numéricos Reales.
Los números reales, son los números que tienen
parte decimal.
0.56
1.00
25.13
148.45
-456.23
Lógicos o boléanos.
Son aquellos datos cuyos únicos valores sólo pueden ser: Verdadero (V) o
Falso (F), puede encontrarse,
Verdadero (True) o Falso (False).
Se utiliza para representar las opciones (si/no) a determinadas condiciones.
Nacionalidad = “Venezolano”
(S/N)?
Carácter o Char.
Su valor lo comprenden todos los caracteres alfabéticos, mayúsculas y
minúsculas (A – Z), numéricos (0 – 9) y símbolos especiales (#,@,%,&).
Carácter String o cadena.

Su valor esta representado por un conjunto de caracteres.
“Abril”
“Reporte Anual de Fallas
Técnicas”
“1º de mayo, Día del Trabajador”
ELABORAR DIAGRAMAS DE FLUJO.

Definicion de un Diagrama de Flujo.
Un diagrama de flujo es una representación gráfica de un algoritmo o de una

parte del mismo. La ventaja de utilizar un diagrama de flujo es que se le puede
construir independientemente del lenguaje de programación, pues al momento
de llevarlo a código se puede hacer en cualquier lenguaje. Dichos diagramas
se construyen utilizando ciertos símbolos de uso especial como son
rectángulos, óvalos, pequeños círculos, etc.; estos símbolos están conectados
entre sí por flechas conocidas como líneas de flujo. A continuación se
presentan estos símbolos y su significado.
Beneficios del Diagrama de Flujo.
En primer lugar, facilita la obtención de una visión transparente del proceso,

mejorando su comprensión. El conjunto de actividades, relaciones e incidencias
de un proceso no es fácilmente discernible a priori. La diagramación hace
posible aprehender ese conjunto e ir más allá, centrándose en aspectos
específicos del mismo, apreciando las interrelaciones que forman parte del
proceso así como las que se dan con otros procesos y subprocesos.
Permiten definir los límites de un proceso. A veces estos límites no son tan
evidentes, no estando definidos los distintos proveedores y clientes (internos y
externos) involucrados.
El diagrama de flujo facilita la identificación de los clientes, es más sencillo

determinar sus necesidades y ajustar el proceso hacia la satisfacción de sus
necesidades y expectativas.
Estimula el pensamiento analítico en el momento de estudiar un proceso,

haciendo más factible generar alternativas útiles.
Proporciona un método de comunicación más eficaz, al introducir un lenguaje

común, si bien es cierto que para ello se hace preciso la capacitación de
aquellas personas que entrarán en contacto con la diagramación.
Un diagrama de flujo ayuda a establecer el valor agregado de cada una de las

actividades que componen el proceso.
Igualmente, constituye una excelente referencia para establecer mecanismos

de control y medición de los procesos, así como de los objetivos concretos para
las distintas operaciones llevadas a cabo.

Facilita el estudio y aplicación de acciones que redunden en la mejora de las

variables tiempo y costes de actividad e incidir, por consiguiente, en la mejora
de la eficacia y la eficiencia.
Constituyen el punto de comienzo indispensable para acciones de mejora o

reingeniería.
Nombre Símbolo Función

Representa el inicio y fin de un programa.
También puede representar una parada o
Terminal
interrupción programada que sea necesaria
realizar en un programa.
Cualquier tipo de introducción de datos en

Entrada / salida la memoria desde los periféricos o registro
de información procesada en un periférico.
Cualquier tipo de operación que pueda

originar cambio de valor, formato o posición
Proceso de la información almacenada en memoria,
operaciones aritméticas, de
transformaciones, etc.
Indica operaciones lógicas o de

comparación entre datos (normalmente
dos) y en función del resultado de la misma
Decisión
determina (normalmente si y no) cual de los
distintos caminos alternativos del programa
se debe seguir
Sirve para enlazar dos partes cualesquiera

de un diagrama a través de un conector en
Conector
la salida y otro conector en la entrada. Se
Misma Página refiere a la conexión en la misma pagina del
diagrama
Indicador de
Indica el sentido de la ejecución de las
dirección o operaciones
línea de flujo
Se utiliza en ocasiones en lugar del símbolo
de salida. El dibujo representa un pedazo
Salida
de hoja. Es usado para mostrar datos o
resultados.
Reglas de los diagramas de flujo:
 Debe de indicar claramente dónde inicia y dónde termina el diagrama.

 Cualquier camino del diagrama debe de llevarte siempre a la terminal de fin.
 Organizar los símbolos de tal forma que siga visualmente el flujo de arriba

hacia abajo y de izquierda a derecha.

 No usar lenguaje de programación dentro de los símbolos.
 Centrar el diagrama en la página.
 Las líneas deben ser verticales u horizontales, nunca diagonales.
Las líneas deben ser verticales u horizontales, nunca diagonales.
No cruzar las líneas de flujo empleando los conectores adecuados sin hacer
uso excesivo de ellos.
No fraccionar el diagrama con el uso excesivo de conectores.

Solo debe llegar una sola línea de flujo a un símbolo. Pero pueden llegar
muchas líneas de flujo a otras líneas.
Las líneas de flujo deben de entrar a un símbolo pro la parte superior y/o
izquierda y salir de él por la parte inferior y/o derecha.

Evitar que el diagrama sobrepase una página; de no ser posible, enumerar y

emplear los conectores correspondientes.
Usar lógica positiva, es decir, realizar procesos cuando es verdadera la
condición y expresar las condiciones de manera clara (por ej., "no es a =/= de
b" ==> "a=b").
Comentar al margen únicamente cuando sea necesario.
CONSTRUIR PSEUDOCÓDIGOS.
En ciencias de la computación, y análisis numérico
el pseudocódigo (o falso lenguaje) es una
descripción de un algoritmo de programación
informático de alto nivel compacto e informal que
utiliza las convenciones estructurales de un lenguaje
de programación verdadero, pero que está diseñado
para la lectura humana en lugar de la lectura en
máquina, y con independencia de cualquier otro
lenguaje de programación. Normalmente, el
pseudocódigo omite detalles que no son esenciales
para la comprensión humana del algoritmo, tales
como declaraciones de variables, código específico del sistema y algunas
subrutinas.
El lenguaje de programación se complementa, donde sea conveniente, con

descripciones detalladas en lenguaje natural, o con notación matemática
compacta. Se utiliza pseudocódigo pues este es más fácil de entender para las
personas que el código de lenguaje de programación convencional, ya que es
una descripción eficiente y con un entorno independiente de los principios
fundamentales de un algoritmo. Se utiliza comúnmente en los libros de texto y
publicaciones científicas que se documentan varios algoritmos, y también en la
planificación del desarrollo de programas informáticos, para esbozar la
estructura del programa antes de realizar la codificación efectivamente. No
existe una sintaxis estándar para el pseudocódigo, aunque los dos programas
que manejan pseudocódigo tengan su sintáxis propia. Aunque parecido, el
pseudocódigo no debe confundirse con los programas esqueleto que incluyen
código ficticio, que pueden ser compilados sin errores. Aunque los diagramas
de flujo y UML sean más amplios en el papel, pueden ser considerados como
una alternativa gráfica al pseudocódigo.
NOTA:
Este pseudocódigo o pseudolenguaje es usado para o hacer un bosquejo de una aplicación de
manera rápida, o para aprender programación, se usa más que todo en clases de lógica y
algoritmia.

No es un lenguaje estructurado así que cada quien puede poner las normas de el, por ejemplo
una condición o una toma de decisiones en pseudolenguaje seria algo como:
si Numero_visitas >= 50000 entonces

escriba "mi blog tiene buen trafico"
sino entonces
escriba "tengo que mejorar mi blog"
fin si
En el ejemplo anterior vemos que lo que esta en verde serian las instrucciones que podrían
variar en los diferentes lenguajes de programación (si = if) (escriba = print) (sino = else) lo que
esta en azul "Numero_visitas" representa una variable, los operadores matemáticos se usan de
la misma manera en casi todos los lenguajes, en este caso ">=" significa (Mayor o igual) y lo
que esta entre comillas es lo que se debe imprimir en la pantalla de la aplicación.
Ejemplo:
Realizar el pseudocódigo de un programa que permita calcular el área de un
rectángulo. Se debe introducir la base y la altura para poder realizar el cálculo.
Programa; área
Entorno: BASE, ALTURA, AREA son número enteros
Algoritmo:
escribir .Introduzca la base y la altura.
leer BASE, ALTURA
calcular AREA = BASE * ALTURA
escribir .El área del rectángulo es .AREA
Finprograma
A continuación se muestran algunos ejemplos de palabras utilizadas para

construir algoritmos en pseudocódigo.
PALABRA UTILIZACIÓN
ABRE Abre un archivo
CASO Selección entre múltiples alternativas
CIERRA Cierra un archivo
ENTONCES Complemento de la selección SI - ENTONCES
ESCRIBE Visualiza un dato en pantalla
FIN Finaliza un bloque de instrucciones
HASTA Cierra la iteración HAZ - HASTA
HAZ Inicia la iteración HAZ - HASTA
INICIO Inicia un bloque de instrucciones
LEER Leer un dato del teclado
MIENTRAS Inicia la iteración mientras

NO Niega la condición que le sigue

O Disyunción lógica
O – BIEN Complemento opcional de la selección SI - ENTONCES
PARA Inicia un número fijo de iteraciones
SI Inicia la selección SI-ENTONCES
USUAL Opcional en la instrucción CASO
Y Conjunción lógica
{ Inicio de comentario
} Fin de comentario
<= Asignación
1. ¿Indique que es un algoritmo informatico?

2. ¿Para que sirve un diagrama de flujo?
3. Desarrolle el algoritmos, pseudocodigo y diagrama de flujo para el siguiente
caso:
Determinar la hipotenusa de un triángulo rectángulo conocidas las
longitudes de sus dos catetos.

04
TAREA 04: DEFINIR LOS TIPOS DE ESTRUCTURAS QUE
EXISTEN EN UN PROGRAMA.

 Construir estructuras condicionales simples.
 Elaborar estructuras de repetición.
 Analizar y desarrollar estructuras anidadas complejas.
 Desarrollar casos prácticos de programación. Construir Pseudocodigos
" Antes que toda otra cosa la preparación es la clave para el

éxito.....”……. Alexandre Graham Bell.

 Construir estructuras condicionales simples.
 Elaborar estructuras de repetición.
 Analizar y desarrollar estructuras anidadas complejas.
 Desarrollar casos prácticos de programación.

OPERACIÓN:
CONSTRUIR ESTRUCTURAS CONDICIONALES SIMPLES.
Realizar el siguiente ejercicio en VBA.

La instruccion If Then Else es una estructura condicional que nos permite
ejecutar acciones en función de si se cumple una condicion. Generalizando
tenemos tenemos: If cumple condición Then ejecutar acción 1 Else ejecutar
acción 2.
Dentro de esta estructura puede haber otra estructura condicional y dentro de
esta otra, y así sucesivamente. A esto se le conoce como una Estructura If
anidada. A continuación veremos un ejemplo de una estructura If Then Else:
En VBA de MS.Excel escribimos el siguiente procedimiento para determinar
que porcentaje de descuento se le realiza a una compra dependiendo del
monto de compra; y de esta manera obtener el monto final a pagar. Si el monto
de compras es mayor a s/. 10,000.00 entonces se le aplica un descuento de
10%, caso contrario se le aplica un descuento de 5%:
Sub COBRANZA()
MONTO = Worksheets(“HOJA1″).Range(“B1″).Value
If MONTO > 10000 Then
DESCUENTO = 0.1 * MONTO
Else
DESCUENTO = 0.05 * MONTO
End If
MONTO_F = MONTO – DESCUENTO
Worksheets(“HOJA1″).Range(“B2″).Value = DESCUENTO
Worksheets(“HOJA1″).Range(“B3″).Value = MONTO_F
End Sub

Comprobar que un número escrito en la celda activa es el requerido. Si se

cumple, muestra un mensaje diciendo "El código es correcto". Si no se
cumple, la macro termina y no hace nada.
Sub ComprobarCódigo()
If ActiveCell = "ABCD" Then
MsgBox ("El código es correcto")
End If
End Sub
Comprobar que un número escrito en una celda determinada es el

requerido. Si se cumple, muestra un mensaje diciendo "El código es
correcto". Si no se cumple, muestra un mensaje diciendo "El código no es
correcto".
Sub ComprobarCódigo()
If Range("A1") = "BF1234" Then
MsgBox("El código es correcto")
Else
MsgBox("El código no es correcto")
End If
End Sub
OPERACIÓN:
ELABORAR ESTRUCTURAS DE REPETICIÓN.
CICLO FOR VISUAL BASIC
Este ciclo es uno de los mas usados para repetir una secuencia de
instrucciones, sobre todo cuando se conoce la cantidad exacta de veces que se
quiere que se ejecute una instrucción simple o compuesta.
Su formato general es:

FOR VARCICLO=VALORINICIAL TO VALORFINAL [STEP INCR O DECR]

INSTRUCCION(ES)
NETX VARCICLO
Pasos para elaborar código en VBA para ingresar los números del 1 al 10
en las celdas de A1 a A10.
Sub repetitivo1()
For i = 1 To 10
Range("A" & i).Value = i
Next
End Sub
RESULTADO:
Pasos para elaborar un formulario que tenga un cuadro de lista, el cual se

llenara con los números del 10 al 20 al darle clic en el botón “OK”.
Paso 1:
Insertar un formulario en VBA.

Paso 2:
Insertar los controles respectivos, seleccionándolo del cuadro de herramientas
y arrastrándolo al formulario.
Paso 3:
Modifique las propiedades de los objetos insertados en el formulario para que
tenga los valores que se pueden ver en la imagen inicial del enunciado de este
ejercicio.

Paso 4:
Dele doble clic al botón e ingrese el siguiente código:
Private Sub CommandButton1_Click()

For x = 10 To 20
ListBox1.AddItem (x)
Next x
End Sub
Paso 5:
Ejecutamos el formulario y le damos clic en el botón “OK”, podemos ver que la
lista se llena con los números del 1 al 10.
OPERACIÓN:
ANALIZAR Y DESARROLLAR ESTRUCTURAS ANIDADAS COMPLEJAS.
Pasos para crear código VBA que muestre un mensaje si el usuario ingresa el
usuario y clave correcta.
Paso 1:
Diseñe la hoja de calcula e ingrese al editor de
macros.
Paso 2:
Inserte un modulo en el cual se creara la
programación.

Paso 3:
Ingrese el siguiente código:
Sub validar_usuario()
If Range("B1").Value = "SENATI" And Range("B2").Value = "ETI" Then

MsgBox ("BIENVENIDO")
Range("B4").Value = "BIENVENIDO"
Else
MsgBox ("ACCESO DENEGADO")
Range("B4").Value = "ACCESO DENEGADO"
End If
End Sub
Paso 4:
En la hoja de Excel ingrese una forma la cual se vinculara con la macro creada
la cual tiene el nombre validar_usuario().

Paso 5:
En la hoja de Excel, ingrese un usuario y clave y ejecute el botón procesar,
dependiendo si cumple la validación mostrara un mensaje distinto.
OPERACIÓN:
DESARROLLAR CASOS PRÁCTICOS DE PROGRAMACIÓN.
Crear código vba para comprobar que A3 es mayor que A1 y si es verdad

entonces escribir en la celda A4: “A3 mayor que A1″
Sub Ejercicio1()
If Range("A3") > Range("A1") Then
Range("A4") = "A3 es mayor que A1"
End If
End Sub
Crear código vba para rellenar el color de fondo de la celda A1 en

amarillo.
Sub Ejercicio2()
Range("A1").Interior.Color = vbYellow
End Sub

Crear código vba para comprobar que A1 y A2 son menores que C1 y si

es verdadero poner en negrita los valores de C1:C5.
Sub Ejercicio3()
If Range("A1") < Range("C1") And Range("A2") < Range("C1") Then
Range("C1:C5").Font.Bold = True
End If
End Sub
Crear código vba para elaborar una tabla de multiplicar del numero
ingresaso en la celda A1.
Sub crear_tabla()
contador = 1
num = Range("A1").Value
For i = 1 To 12
contador = contador + 1
Range("A" & contador).Value = num

Range("B" & contador).Value = "X"
Range("C" & contador).Value = i
Range("D" & contador).Value = "="
Range("E" & contador).Value = num * i
Next i
End Sub
RESULTADO:

Complete el código anterior para aplicarle un formato al resultado de la tabla

generada y un botón que limpie todo el resultado.
Construir estructuras condicionales simples.
Las estructuras condicionales comparan una variable contra otro(s) valor (es),
para que en base al resultado de esta comparación, se siga un curso de acción
dentro del programa. Cabe mencionar que la comparación se puede hacer
contra otra variable o contra una constante, según se necesite.
Existen tres tipos básicos, las simples, las dobles y las múltiples.
No todos los problemas pueden resolverse empleando estructuras

secuenciales. Cuando hay que tomar una decisión aparecen las estructuras
condicionales.
En nuestra vida diaria se nos presentan situaciones donde debemos decidir.
¿Elijo la carrera A o la carrera B?

¿Me pongo este pantalón?
Para ir al trabajo, ¿elijo el camino A o el camino B?
Al cursar una carrera, ¿elijo el turno mañana, tarde o noche?
Cuando se presenta la elección tenemos la opción de realizar una actividad o

no realizar ninguna.
Representación gráfica:

Podemos observar: El rombo representa la condición. Hay dos opciones que se

pueden tomar. Si la condición da verdadera se sigue el camino del verdadero, o
sea el de la derecha, si la condición da falsa se sigue el camino de la izquierda.
Se trata de una estructura CONDICIONAL SIMPLE porque por el camino del
verdadero hay actividades y por el camino del falso no hay actividades.
Por el camino del verdadero pueden existir varias operaciones, entradas y
salidas, inclusive ya veremos que puede haber otras estructuras condicionales.
Por supuesto que en un problema se combinan estructuras secuenciales y

condicionales.
Simples:
Las estructuras condicionales simples se les conocen como Tomas de decisió.
Estas tomas de decisión tienen la siguiente forma:
Pseudocódigo: Diagrama de flujo:
Dobles:
Las estructuras condicionales dobles permiten elegir entre dos opciones o
alternativas posibles en función del cumplimiento o no de una determinada
condición. Se representa de la siguiente forma:

Donde:
 Si: Indica el comando de comparación.
 Condición: Indica la condición a evaluar.
 Entonces: Precede a las acciones a realizar cuando se cumple la condición.
 Instrucción(es): Son las acciones a realizar cuando se cumple o no la
condición.
 Si no: Precede a las acciones a realizar cuando no se cumple la condición.
 Dependiendo de si la comparación es cierta o falsa, se pueden realizar una o
más acciones.
Múltiples:
Las estructuras de comparación múltiples, son tomas de decisión
especializadas que permiten comparar una variable contra distintos posibles
resultados, ejecutando para cada caso una serie de instrucciones específicas.
La forma común es la siguiente:

Múltiples (En caso de):

Las estructuras de comparación múltiples, es una toma de decisión
especializada que permiten evaluar una variable con distintos posibles
resultados, ejecutando para cada caso una serie de instrucciones especificas.
La forma es la siguiente:
Elaborar estructuras de repetición.

Las estructuras de repetición, permiten la ejecución de una lista o secuencia de
instrucciones (<bloque de instrucciones>) en varias ocasiones. El número de
veces que el bloque de instrucciones se ejecutará se puede especificar de
manera explícita, o a través de una condición lógica que indica cuándo se
ejecuta de nuevo y cuándo no. A cada ejecución del bloque de instrucciones se
le conoce como una iteración.
Existen tres tipos principales de sentencias de repetición:

• Ciclo mientras
• Ciclo haga-mientras
• Ciclo para
A continuación se describe cada una de ellas.

CICLO MIENTRAS.
El ciclo mientras permite ejecutar un bloque de instrucciones mientras que una
expresión lógica dada se cumpla, es decir, mientras su evaluación dé como
resultado verdadero. La expresión lógica se denomina condición y siempre se
evalúa antes de ejecutar el bloque de instrucciones. Si la condición no se
cumple, el bloque no se ejecuta. Si la condición se cumple, el bloque se
ejecuta, después de lo cual la instrucción vuelve a empezar, es decir, la
condición se vuelve a evaluar.
En el caso en que la condición evalúe la primera vez como falsa, el bloque de

instrucciones no será ejecutado, lo cual quiere decir que el número de
repeticiones o iteraciones de este bloque será cero. Si la condición siempre
evalúa a verdadero, la instrucción se ejecutará indefinidamente, es decir, un
número infinito de veces.
La forma general del ciclo mientras es la siguiente:
Donde, <condición> es la expresión lógica que se evalúa para determinar la

ejecución o no del bloque de instrucciones, y <acción S1, S2…> son el
conjunto de instrucciones que se ejecutan si la condición evalúa a Verdadero.
CICLO HAGA—MIENTRAS.
El ciclo haga-mientras es similar al ciclo mientras, la diferencia radica en el
momento de evaluación de la condición.
En el ciclo haga-mientras la condición se evalúa después de ejecutar el bloque

de instrucciones, por lo tanto, el bloque se ejecuta por lo menos una vez. Este
bloque se ejecuta nuevamente si la condición evalúa a verdadero, y no se
ejecuta más si se evalúa como falso.

La forma general del ciclo haga-mientras es la siguiente:
Donde, <bloque instrucciones> es el conjunto de instrucciones que se ejecuta y

<condición> es la expresión lógica que determina si el bloque se ejecuta. Si la
<condición> se evalúa como verdadero el bloque es ejecutado de nuevo y si es
evaluada como falso no es ejecutado.
Después de ejecutar el bloque de acciones se evalúa la <condición>.
CICLO PARA.
El ciclo para ejecuta un bloque de instrucciones un número determinado de
veces. Este número de veces está determinado por una variable contadora (de
tipo entero) que toma valores desde un límite inferior hasta un límite superior.
En cada ciclo después de ejecutar el bloque de instrucciones, la variable
contadora es incrementada en 1 automáticamente y en el momento en que la
variable sobrepasa el límite superior el ciclo termina.
El valor final de la variable contadora depende del lenguaje de programación

utilizado, por lo tanto, no es recomendable diseñar algoritmos que utilicen el
valor de la variable contadora de un ciclo para, después de ejecutar el mismo.
De la definición de ciclo para se puede inferir que el bloque de instrucciones no
se ejecuta si el límite inferior es mayor al límite superior.
La forma general del ciclo para es la siguiente:

Donde <variable> es la variable contadora del ciclo, la cual debe ser de tipo
entero. <lim_inf> es el valor inicial que toma la variable contadora. <lim_sup>
es el último valor que toma la variable contadora; cuando el valor de la variable
contadora supere este valor, el ciclo termina. <bloque instrucciones> es el
conjunto de instrucciones que se ejecuta en cada iteración, mientras la variable
contadora no sobrepase el <lim_sup>.
Casos:
Cuando <lim_inf> es menor que <lim_sup> ocurre lo siguiente:
1. La variable contadora se vuelve igual a <lim_inf>

2. Se ejecuta <bloque de instrucciones>
3. Se incrementa automáticamente en 1 la variable contadora del ciclo.
4. Si el valor de contador del ciclo es menor o igual que <lim_sup> se vuelve de
nuevo al paso 2. De otro modo se abandona el ciclo.
Es de anotar que el valor final de la variable contadora queda incrementada por

encima del <lim_sup> para que pueda finalizar el ciclo.
Cuando <lim_inf> es mayor que <lim_sup> el ciclo termina sin ejecutarse

nunca el <bloque de instrucciones>. Tenga en cuenta que no se genera error al
correr el programa.
Ejemplo:
para (x:=5 hasta 4) hacer.

Esta línea de código nunca se ejecuta.
• Es de anotar que los lenguajes de programación tienen una variable a esta

instrucción para que el valor pueda ir en descenso.
• Tanto <lim_inf> como <lim_sup> pueden ser expresiones como en el

siguiente
ejemplo:
para(j:=x+1 hasta 2*y) hacer.
En este caso se calculan primero los valores de las expresiones (x+1) y (2*y)
empleando para esto los valores actuales de x y y para utilizarlos como
<lim_inf> y <lim_sup> respectivamente.

Analizar y desarrollar estructuras anidadas complejas.
Para hacer estructuras condicionales más complejas podemos anidar

sentencias IF, es decir, colocar estructuras IF dentro de otras estructuras IF.
Con un solo IF podemos evaluar y realizar una acción u otra según dos
posibilidades, pero si tenemos más posibilidades que evaluar debemos anidar
IFs para crear el flujo de código necesario para decidir correctamente.
Por ejemplo, si deseo comprobar si un número es mayor menor o igual que

otro, tengo que evaluar tres posibilidades distintas. Primero puedo comprobar si
los dos números son iguales, si lo son, ya he resuelto el problema, pero si no
son iguales todavía tendré que ver cuál de los dos es mayor. Veamos este
ejemplo en código Javascript.
var numero1=23
var numero2=63
if (numero1 == numero2){
document.write("Los dos números son iguales")
}else{
if (numero1 > numero2) {
document.write("El primer número es mayor que el segundo")
}else{
document.write("El primer número es menor que el segundo")
}
}
El flujo del programa es como comentábamos antes, primero se evalúa si los

dos números son iguales. En caso positivo se muestra un mensaje informando
de ello. En caso contrario ya sabemos que son distintos, pero aun debemos
averiguar cuál de los dos es mayor. Para eso se hace otra comparación para
saber si el primero es mayor que el segundo. Si esta comparación da
resultados positivos mostramos un mensaje diciendo que el primero es mayor
que el segundo, en caso contrario indicaremos que el primero es menor que el
segundo.
Volvemos a remarcar que las llaves son en este caso opcionales, pues sólo se
ejecuta una sentencia para cada caso. Además, los saltos de línea y los
sangrados también opcionales en todo caso y nos sirven sólo para ver el
código de una manera más ordenada. Mantener el código bien estructurado y
escrito de una manera comprensible es muy importante, ya que nos hará la
vida más agradable a la hora de programar y más adelante cuando tengamos
que revisar los programas.

Alternativa Múltiple.
Con frecuencia existen más de dos alternativas posibles (por ejemplo: en una
ecuación de segundo grado el discriminante puede ser negativo, nulo o
positivo). Este problema se puede resolver utilizando estructuras alternativas
simples o dobles anidadas o en cascada, pero este tipo de solución añade
complejidad al algoritmo y hace difícil la lectura del código fuente.
La estructura de selección múltiple ofrece una solución más simple y compacta.

Para esta estructura se evalúa una expresión que puede tomar n valores
distintos (1, 2, 3, ..., n) A cada valor de la expresión corresponde una
instrucción (o serie de instrucciones) diferente, lo que significa que el flujo
seguirá un camino distinto entre los n posibles caminos en dependencia del
valor de la expresión de control.
La representación gráfica de este tipo de estructura de selección sería:
En español, el pseudocódigo que representa a la estructura de selección

múltiple es:
Según_sea <expresión> hacer

caso 1: acción 1
caso 2: acción 2
.
.
.
caso n: acción n
si_no
acción x
fin_según

Por ejemplo, el pseudocódigo para una aplicación que escribe los nombres de
los días de la semana en función de una variable (DIA) introducida por el
teclado sería:
Var
Entero: DIA
Inicio
Leer(DIA)
Según_sea (DIA)
Caso 1: escribir(“Lunes”)
Caso 2: escribir(“Martes)
Caso 3: escribir(“Miércoles”)
Caso 4: escribir(“Jueves”)
Caso 5: escribir(“Viernes”)
Caso 6: escribir(“Sabado”)
Caso 7: escribir(“Domingo”)
si_no
escribir(“Error”)
fin_según
fin
VB Select Case
En VB la selección múltiple se implementa mediante la estructura Select Case,

cuya sintaxis general es:
Select Case <expresión>

Case 1
Bloque 1 de instrucciones
Case 2
Case 3
.
.
.
Case n
Bloque n de instrucciones
Case Else
Bloque x de instrucciones
End Select
Note que la última opción (Case Else) cubre la posibilidad de que la expresión

no tome ninguno de los n valores previstos.
El algoritmo gráfico de una sentencia IF anidada se representa de la siguiente

manera:
El algoritmo escrito: Nº. si condición 1 entonces,
Nº.Nº sentencia(s) 1
de lo contrario, si condición 2 entonces,
Nº.Nº sentencia(s) 2
de lo contrario, si condición n entonces,

Nº.Nº sentencia(s) N
de lo contrario
Nº.Nº sentencia(s) N+1
Desarrollar casos prácticos de programación.
Programacion vba para Excel.

Visual Basic para aplicaciones es una combinación de un entorno de
programación integrado denominado Editor de Visual Basic y del lenguaje de
programación Visual Basic, permitiendo diseñar y desarrollar con facilidad
programas en Visual Basic. El término “para aplicaciones” hace referencia al
hecho de que el lenguaje de programación y las herramientas de desarrollo
están integrados con las aplicaciones del Microsoft Office (en este caso, el

Microsoft Excel), de forma que se puedan desarrollar nuevas funcionalidades y

soluciones a medida, con el uso de estas aplicaciones.
El Editor de Visual Basic contiene todas las herramientas de programación

necesarias para escribir código en Visual Basic y crear soluciones
personalizadas.
Este Editor, es una ventana independiente de Microsoft Excel, pero tiene el

mismo aspecto que cualquier otra ventana de una aplicación Microsoft Office, y
funciona igual para todas estas aplicaciones. Cuando se cierre la aplicación,
consecuentemente también se cerrará la ventana del Editor de Visual Basic
asociada.
Editor de Visual Basic.

El Editor de Visual Basic, VBE por sus
siglas en inglés, es un programa
independiente a Excel pero fuertemente
relacionado a él porque es el programa
que nos permite escribir código VBA que
estará asociado a las macros.
Existen al menos dos alternativas para abrir este editor, la primera de ellas es a
través del botón Visual Basic de la ficha Programador.
El segundo método para abrir este programa es, en mi opinión, el más sencillo
y rápido y que es a través del atajo de teclado: ALT + F11. El Editor de Visual
Basic contiene varias ventanas y barras de herramientas.

En la parte izquierda se
muestra el Explorador de
proyectos el cual muestra el
proyecto VBA creado para el
libro actual y además muestra
las hojas pertenecientes a ese
libro de Excel. Si por alguna
razón no puedes visualizar
este módulo puedes
habilitarlo en la opción de
menú Ver y seleccionando la
opción Explorador de
proyectos.
El Explorador de proyectos también nos ayuda a crear o abrir módulos de

código que se serán de gran utilidad para reutilizar todas las funciones de
código VBA que vayamos escribiendo.
Dentro del Editor de Visual Basic puedes observar una ventana llamada
Inmediato que está en la parte inferior. Esta ventana es de mucha ayuda al
momento de escribir código VBA porque permite introducir instrucciones y
observar el resultado inmediato. Además, desde el código VBA podemos
imprimir mensajes hacia la ventana Inmediato con el comando Debug.Print de
manera que podamos depurar nuestro código. Si no puedes observar esta
ventana puedes mostrarla también desde el menú Ver.
El área más grande en blanco es donde escribiremos el código VBA. Es en esa

ventana en donde escribimos y editamos las instrucciones VBA que dan forma
a nuestras macros.
Programando en VBA.
Excel 2013 es una de las
herramientas de software
más poderosas para el
manejo, análisis y
presentación de datos. Aun y
con todas sus bondades, en
ocasiones Excel no llega a
suplir algunas necesidades
específicas de los usuarios.

Afortunadamente Excel cuenta con VBA que es un lenguaje de programación

que permite extender las habilidades del programa para cubrir nuestros
requerimientos. Utilizando VBA se pueden desarrollar nuevos algoritmos para
analizar la información o para integrar a Excel con alguna otra aplicación como
Microsoft Access.
Principios fundamentales.
La programación en VBA puede ser un tanto misteriosa para la mayoría de los
usuarios de Excel, sin embargo una vez que se comprenden los principios
básicos de programación en VBA se comenzarán a crear soluciones robustas y
efectivas.
El primer concepto importante a entender es que cada elemento de Excel es

representado en VBA como un objeto. Por ejemplo, existe el objeto Workbook
que representa a un libro de Excel. También existe el objeto Sheet que
representa una hoja y el objeto Chart para un gráfico.
El segundo concepto importante a entender es que cada uno de estos objetos

tiene propiedades y métodos. Para explicar mejor este concepto utilizaré una
analogía.
Propiedades y Métodos.
Supongamos que tenemos el objeto auto. Así es, un auto como el que
manejamos todos los días para ir al trabajo. Este auto tiene varias propiedades
como son: marca, modelo, color, tipo de transmisión las cuales ayudan a
describir mejor al auto.
También hay propiedades que indican su estado actual como por ejemplo
gasolina disponible, temperatura del aceite, velocidad, kilómetros recorridos
entre otras propiedades más.
Podemos decir que las propiedades de un objeto nos ayudan a describirlo

mejor en todo momento.
Por otro lado tenemos los métodos de un objeto que en resumen son las
acciones que podemos realizar con dicho objeto. Por ejemplo, con nuestro auto
podemos hacer lo siguiente: encenderlo, avanzar, vuelta a la izquierda, vuelta a
la derecha, reversa, detener, apagar, etc. Todas las acciones que se pueden
llevar a cabo con un objeto son conocidas como métodos.
Volviendo al terreno de Excel, el objeto Workbook tiene propiedades como

ActiveSheet (Hoja activa), Name (Nombre), ReadOnly (Solo Lectura), Saved
(Guardado) y algunos de sus métodos son Save (Guardar), Close (Cerrar),
PrintOut (Imprimir), Protect (Proteger), Unprotect (Desproteger).
Será dificil mencionar todos los objetos de Excel y sus propiedades en esta
publicación, pero lo importante a recordar en esta ocasión es que cada
elemento de Excel está siempre representado por un objeto en VBA y cada
objeto tiene a su vez propiedades y métodos que nos permitirán trabajar con
nuestros datos.
Ejemplo de código VBA.
Sub Macro1()
'
' Macro1 Macro
' Macro grabada el 01/10/2013 por ETI
'
' Acceso directo: CTRL+r
'
Range("A1").Select
ActiveCell.FormulaR1C1 = "Ramón"
Range("A2").Select
End Sub
A continuación se da una explicación de lo que ha hecho Excel:
 Sub y End Sub indican el inicio y el final del procedimiento de la Macro1.

 Todo lo que aparece con un apostrofe ´ indica que no se tomara en cuenta
que es solo texto o comentarios y ese texto debe de aparecer en un color, ya
sea el color verde.
 Range("A1").Select Indica que lo primero que hicimos al grabar la macro fue
trasladarnos a la celda A1.La orden Range nos permite trasladarnos a una
celda.
 ActiveCell.FormulaR1C1 = "Ramón" Esto indica que se escribirá en la celda
en que se encuentra el valor de texto Ramón. Todo lo que aparece entre

comillas siempre será un valor de texto.

 ActiveCell.FormulaR1C1 nos permite escribir un valor en la celda activa.
 Range("A2").Select Otra vez indicamos que se traslade a la celda A2. Esto
se debe a que cuando escribimos el nombre de Ramón en A1 presionamos
Enter y al dar Enter bajo a la celda A2.
Para comprender mejor el ejemplo anterior modificaremos el código anterior

dentro del editor de Visual Basic.
Sub Macro1()
Range("A1").Select
ActiveCell.FormulaR1C1 = "SENATI"
Range("B1").Select
ActiveCell.FormulaR1C1 = "Av. Alfredo Mendiola N 3520"
Range("C1").Select
ActiveCell.FormulaR1C1 = "01-10-13"
Range("D1").Select
ActiveCell.FormulaR1C1 = "ETI"
Range("E1").Select
ActiveCell.FormulaR1C1 = "REDES"
End Sub
Al ejecutar la macro en Excel mostrará lo siguiente:
En A1 escribirá SENATI
En B1 escribirá Av. Alfredo Mendiola N 3520
En C1 escribirá 01-10-13
En D1 escribirá ETI
En E1 escribirá REDES
Propiedades.
Las propiedades son las características, atributos, formas o aspectos del
objeto, a las que se hace referencia mediante el uso de variables. Una
propiedad de objeto común de Excel es su Nombre, que nos permitirá usarlos
en las diferentes usos que hagamos del objeto. De manera que una celda, un
rango de celdas, una hoja, libro, gráfico o tabla en Excel, tendrá un nombre con
el cual lo identificaremos.
Para hacer referencia a las propiedades mediante los programas en VBA, se

usa la sintaxis:

NombreDelObjeto.Propiedad
Ejemplo:
Range("A5").Name Aquí se hace referencia al nombre del objeto Range de
la celda A5.
Métodos.
Un método es una acción, un procedimiento (un hilo), que tiene efectos sobre
un objeto.
Ejemplo:
Range("A5").Select Aquí se ejecuta el método Select, que permite activar la

celda A5 y ponerla en disponible para cualquier otra operación.
Range("B2:G4").Formato En este caso, se ejecuta el método Formato

sobre el rango B2:G4. Se supone que el método Formato ya está definido
previamente.
Eventos.
Un evento es el resultado de una acción, es la forma cómo queda el objeto
después de alguna acción sobre él. Por lo general estas acciones son
producidas por los métodos que actúan sobre el objeto.
En la versión 2003 del Excel, podemos tener algunos eventos como:

 Se seleccionó una celda o rango.
 Se seleccionó una hoja (haciendo clic en la pestaña o etiqueta de la misma)
 Se ha abierto o cerrado un libro.
 Se ha activado o desactivado una hoja de cálculo.
 Se han calculado de nuevo las fórmulas de una hoja de cálculo.
 Se ha seguido un hipervínculo.
1. ¿Qué es una estructura condicional anidada?

2. ¿Para que sirve una estructura repetitiva?
3. Desarrolle código VBA para generar una tabla multiplicar solo de números
positivos, si ingresa un numero negativo deberá mostrar un mensaje de
alerta. La tabla ya no será el 1 al 12 como en ejemplo visto en clase, sino
será hasta un número ingresado por el usuario en una celda de la hoja de
Excel.

05
TAREA 05: DEFINIR LOS TIPOS DE DATOS DE UN
PROGRAMA.

 Trabajar con Constantes y variables.
 Definir las palabras reservadas de un lenguaje.
 Definir las funciones internas de un programa.
 Trabajar los tipos de operadores y expresiones de un programa.
" El fracaso es una parte importante del éxito......” Anonimo.
 Trabajar con Constantes y variables.
 Definir las palabras reservadas de un lenguaje.
 Definir las funciones internas de un programa.
 Trabajar los tipos de operadores y expresiones de un programa.

OPERACIÓN:
TRABAJAR CON CONSTANTES Y VARIABLES.
La forma de declara una variable es a través de la instrucción Dim. En la línea

se declara la variable de nombre Variable y al mismo tiempo Visual Basic
guarda espacio en memoria para poder utilizarla.
Pasos para crear código VBA para que nos permite introducir la
información requerida por teclado utilizando variables.
Paso 1:
Cree un nuevo archvo de Excel, inserte un modulo e ingrese el siguiente
código:
Sub ejemplo1()
Dim strNombre As String
strNombre = InputBox(“¿Cómo te llamas?”, “Saludos”)
MsgBox (“Hola ” & strNombre)
End Sub
Paso 2:
Ejecutamos la macro e ingresamos el nombre.
Paso 3:
A continuación insertaremos el siguiente módulo ejemplo2 en el mismo modulo,
para analizar el uso correcto de variables:
Sub ejemplo2()
Dim numero1, numero2, producto As Integer
Dim respuesta As String
numero1 = InputBox("Introduzca el primer número", "PRODUCTO")
numero2 = InputBox("Introduzca el segundo número", "PRODUCTO")
producto = numero1 * numero2
respuesta = MsgBox(numero1 & " X " & numero2 & "=" & producto)
End Sub

Paso 4:
Si introduce cualquier número entero le dará un resultado correcto, pero pruebe
a introducir una letra, un número decimal o deje sin introducir un número.
Observará que arroja un error. Esto es así porque hemos declarado variables
de tipo entero, por tanto la variable resultado no espera que se introduzca
letras o campos vacíos.
Resultado al ingresar números:
Resultado al ingresar textos:
NOTA:
El ejercicio nos pregunta que insertemos
un nombre de usuario, que
posteriormente se inserta en la celda A1.
Hemos declarado la variable de forma
local a nivel de módulo o procedimiento.
Si a continuación insertáramos otro
módulo exactamente igual pero sin la
definición de la variable nos daría lugar a
un error:

OPERACIÓN:
DEFINIR LAS PALABRAS RESERVADAS DE UN LENGUAJE.
En los lenguajes informáticos, una palabra reservada es una palabra que tiene
un significado gramatical especial para ese lenguaje y no puede ser utilizada
como un identificador de objetos en códigos del mismo, como ser variables.
Por ejemplo, en SQL, un usuario no puede ser llamado "group", porque la

palabra group es usada para indicar que un identificador se refiere a un grupo,
no a un usuario. Al tratarse de una palabra clave su uso queda restringido.
Ocasionalmente la especificación de un lenguaje de programación puede tener

palabras reservadas que están previstas para un posible uso en futuras
versiones. En Java const y goto son palabras reservadas — no tienen
significado en Java, pero tampoco pueden ser usadas como identificadores.
Al reservar los términos pueden ser implementados en futuras versiones de

Java, si se desea, sin que el código fuente más antiguo escrito en Java deje de
funcionar.
NOTA:
Definicion de SQL
La sigla que se conoce como SQL corresponde a la expresión inglesa Structured Query
Language (entendida en español como Lenguaje de Consulta Estructurado), la cual identifica a
un tipo de lenguaje vinculado con la gestión de bases de datos de carácter relacional que
permite la especificación de distintas clases de operaciones entre éstas. Gracias a la utilización
del álgebra y de cálculos relacionales, el SQL brinda la posibilidad de realizar consultas con el
objetivo de recuperar información de las bases de datos de manera sencilla.
Palabras reservadas en SQL
En SQL, son palabras reservadas todas las sentencias, cláusulas

modificadoras, tipos de dato, y funciones propias del DBMS.Así, por ejemplo,
no se pueden usar denominaciones tales como SELECT, GROUP, CONCAT,
SUM, MAX o semejantes.
En cada DBMS, además, existen conjuntos de denominaciones que le son

propias, y que si pueden ser usadas en otros, lo que tiende a producir ciertos
problemas al migrar proceso o sintaxis de uno a otro. Tal es el caso de
SYSDATE, NOW, o BIGINT, el primero de los cuales es usual en Oracle, y los
dos siguientes en MySQL.
Pese a eso, todos los DBMS tienen, también, la posibiilidad de usar estas

palabras reservadas, siempre que se respeten ciertas reglas sintácticas:
Todas las palabras reservadas usadas para nombres de objetos creados en

una base de datos deben estar encerrados entre caracteres específicamente
usados para ello.
En varios sistemas de bases de datos se utilizanpara ello los acentos graves

(`), que no tienen otro uso en el SQL.
Pasos para crear un formulario y programar la suma de dos valores sin utilizar
palabras reservadas.
Paso 1:
Diseñe el siguiente formulario:
Paso 2:
Dele doble clic en el botón sumar e ingrese el siguiente código:
If txtnum1.Text = "" Or txtnum2.Text = "" Then

MsgBox "Complete ambos numeros"
Else
Dim n1 As Double
Dim n2 As Double
Dim resultado As Double
n1 = txtnum1.Text
n2 = txtnum2.Text
resultado = n1 + n2

txtresultado.Text = resultado
End If
End Sub
Paso 3:
Si cambiamos el nombre de la variable n1 por ejemplo por la palabra integer

aparecerá el siguiente error:
Integer es una palabra reservada de VBA que sirve para definir una variable del
tipo entero.
OPERACIÓN:
DEFINIR LAS FUNCIONES INTERNAS DE UN PROGRAMA.
Pasos para crear código vba donde permita ingresar un texto y devuelve la
posición de una cadena en una frase.
Paso 1:
Inserte un modulo en un nuevo archivo de Excel e ingrese el siguiente código:
Private Sub cadena_InStr()
Dim frase As String

Dim Posición As Integer

frase = InputBox("Inserte una frase…")

Posición = InStr(frase, InputBox("Indique la letra de la que quiere averiguar su
posición"))
MsgBox Posición
End Sub
Paso 2:
Ejecute la función e inserte el texto tal como lo muestra la siguiente imagen:
Paso 3:
Ingrese el texto que desea buscar y que la función InStr encuentre su posición.
Resultado:
La función buscara el texto “R” en la frase del paso 2 y nos mostrara su
posición.
Ingrese los siguientes códigos de funciones en un nuevo archivo de Excel y

ejecútelos para verificar el resultado.
La función Left (izquierda)

Left es una función que extrae los caracteres de una frase, empezando por la
izquierda.

Left (frase, 4) significa que cuatro caracteres son extraídos del valor de variable
frase, a partir de la posición más a la izquierda.
Private Sub CadenaLeft()

Dim frase As String
frase = "Esta es la prueba de la function Left"
MsgBox Left(frase, 4)
End Sub
Este código devuelve la cadena "Esta" de la frase "Esta es la prueba de la

function Left"
La función Right (derecha)

Right es una función que extrae los caracteres de una frase, comenzando por
la derecha.
Right (frase, 5) significa que cinco caracteres son extraídos de la variable frase,
a partir de la posición más a la derecha.
Private Sub CadenaRight()

Dim frase As String
frase = "Esta es la prueba de la función Right"
MsgBox Right(frase, 5)
End Sub
Este código devuelve la cadena " Right " de la frase " Esta es la prueba de la
función Right”
La función Mid
Mid es una función que extrae una cadena de una frase, a partir de la posición
especificada por el segundo parámetro en el soporte.
Mid (frase, 8,3) significa que una serie de tres caracteres son extraídos de la
frase, a partir de la 8 ª posición de la izquierda, incluido el espacio vacío.
Private Sub CadenaMid()
Dim frase As String
frase = "Esta es la prueba de la función Mid"
MsgBox Mid(frase, 12, 6)
End Sub
Este código devuelve la cadena "prueba" de la frase "Esta es la prueba de la

función Mid"

La función Len
Len es una función que devuelve la longitud de una frase (incluido el espacio
vacío entre los dos)
Private Sub CadenaLen()

Dim frase As String
frase = "Esta es la prueba de la función Len"
MsgBox Len(frase)
End Sub
En este caso nos dará como resultado 35.
Resultado de los códigos en el entorno VBA.
Unir cadenas de texto.

Para unir dos (o más) cadenas de texto podemos utilizar el operador &.
Observa el siguiente código:

El resultado de este código es el siguiente:
OPERACIÓN:
TRABAJAR LOS TIPOS DE OPERADORES Y EXPRESIONES DE UN
PROGRAMA.
Visual Basic clasifica los operadores con que trabaja de la siguiente manera:
 Operadores aritméticos: operadores utilizados para ejecutar cálculos

matemáticos.
 Operadores de comparación: operadores utilizados para efectuar
comparaciones.
 Operadores de concatenación: operadores utilizados para combinar cadenas
de caracteres.
 Operadores lógicos: operadores usados para realizar operaciones lógicas.
Operadores Operadores de Operaciones de Operadores

Aritméticos comparación concatenación lógicos
Operador ^ < (Menor que) & Operador And
<= (Menor o
Operador * + Operador Eqv
igual que)
Operador / > (Mayor que) Operador Imp
>= (Mayor o
Operador \ Operador Not
igual que)
Operador Mod = (Igual a) Operador Or
Operador + <> (Distinto de) Operador Xor
Operador - Is
Like

Elaborar un formulario que procese las operaciones básicas.
Paso 1:
Diseñe el siguiente formulario:
Paso 2:
Ingrese el siguiente código.
Dim Primero, Segundo 'declara variables

Primero = Val(Text1.Text) 'convierte a números
Segundo = Val(Text2.Text)
'si se pulsa el primero botón, suma los números
If Option1.Value = True Then

Label4.Caption = Primero + Segundo
End If
'si se pulsa el segundo botón, resta los números

Label4.Caption = Primero - Segundo
End If
'si se pulsa el tercer botón, multiplica los números

Label4.Caption = Primero * Segundo
End If
'si se pulsa el cuarto botón, divide los números

Label4.Caption = Primero / Segundo

End If
End Sub
IMPORTANTE:
Verifique los nombres de los controles en la propiedad name del editor de VBA.
RESULTADO:
Dependiendo de la operación seleccionada se mostrara el resultado respectivo.
Trabajar con Constantes y variables.
Constantes.
Una constante es un dato numérico o alfanumérico que no cambia durante la

ejecución del programa.
Ejemplo:
pi = 3.1416
Variable.
Es un espacio en la memoria de la computadora que permite almacenar

temporalmente un dato durante la ejecución de un proceso, su contenido puede
cambiar durante la ejecución del programa.
Para poder reconocer una variable en la memoria de la computadora, es

necesario darle un nombre con el cual podamos identificarla dentro de un
algoritmo.

Ejemplo:
area = pi * radio ^ 2
Las variables son : el radio, el area y la constate es pi
Clasificación de las Variables
Por su contenido.
Variables Numéricas: Son aquellas en las cuales se almacenan valores
numéricos, positivos o negativos, es decir almacenan números del 0 al 9,
signos (+ y -) y el punto decimal.
Ejemplo:
iva = 0.15 pi = 3.1416 costo = 2500
Variables Lógicas: Son aquellas que solo pueden tener dos valores (cierto o
falso) estos representan el resultado de una comparación entre otros datos.
Variables Alfanuméricas: Esta formada por caracteres alfanuméricos (letras,

números y caracteres especiales).
Ejemplo:
letra = a apellido = diaz direccion = Av. Perú # 3010
Por su uso.
Variables de Trabajo: Variables que reciben el resultado de una operación
matemática completa y que se usan normalmente dentro de un programa.
Ejemplo:
Suma = a + b /c
Contadores: Se utilizan para llevar el control del número de ocasiones en que
se realiza una operación o se cumple una condición. Con los incrementos
generalmente de uno en uno.
Acumuladores: Forma que toma una variable y que sirve para llevar la suma
acumulativa de una serie de valores que se van leyendo o calculando
progresivamente.

Expresiones.
Las expresiones son combinaciones de constantes, variables, símbolos de
operación, paréntesis y nombres de funciones especiales.
Por ejemplo:
a + (b + 3) / c
Cada expresión toma un valor que se determina tomando los valores de las
variables y constantes implicadas y la ejecución de las operaciones indicadas.
Una expresión consta de operadores y operandos. Según sea el tipo de datos

que manipulan, se clasifican las expresiones en:
Aritméticas
Relacionales
Lógicas
Expresiones
Declarar una variable en VBA.
Sentencia DIM.
Para declarar una variable se usa la sentencia DIM. Esta declaración se coloca
al principio de las secciones o módulos.
Sintaxis:
DIM NombreDeVariable As TipoDeDatos
DIM NombreVar1, NombreVar2, … As TipoDeDatos

Tipos de variable.
La tabla siguiente muestra los tipos de datos compatibles, incluyendo el tamaño
de almacenamiento en memoria y el intervalo en el cual pueden variar.
Tipo de datos Tamaño de Intervalo

almacenamiento
Byte Entero de un byte 0 a 255
Bolean Lógico de dos bytes True o False
Integer Entero de dos bytes -32,768 a 32,767
Long Entero largo de 4 -2,147,483,648 a 2,147,483,647

(entero largo) bytes
Single Decimal de 4 bytes -3,402823E38 a –1,401298E-45 para

(coma flotante/ valores negativos; 1,401298E-45 a
precisión simple) 3,402823E38 para valores positivos
Double Decimal de 8 bytes -1.79769313486231E308 a

(coma flotante/ -4,94065645841247E-324 para valores
precisión doble) negativos; 4,94065645841247E-324 a
1,79769313486232E308 para valores
positivos
Currency Entero de 8 bytes -922.337.203.685.477,5808 a

(entero a escala) 922.337.203.685.477,5807
Decimal Números reales con +/-

decimales hasta de 79.228.162.514.264.337.593.543.950.335
28 dígitos (14 bytes) sin punto decimal;
+/-7,9228162514264337593543950335
con 28 posiciones a la derecha del signo
decimal; el número más pequeño distinto
de cero es
+/-0,0000000000000000000000000001
Date Usado para fechas de 1 de enero de 100 a 31 de diciembre de

8 bytes 9999
Object 4 bytes Cualquier referencia a tipo Object
String Usado para datos de Desde 0 a 2.000 millones

(longitud texto de 10 bytes
variable)

String Como el anterior pero Desde 1 a 65.400 aproximadamente

(longitud fija) de longitud fija
Variant Usado como tipo de Cualquier valor numérico hasta el

(con números) dato genérico de 16 intervalo de un tipo Double
bytes
Variant 22 bytes + longitud de El mismo intervalo que para un

(con caracteres) la cadena tipo String de longitud variable
Definido por el Número requerido por El intervalo de cada elemento es el

usuario los elementos mismo que el intervalo de su tipo de
(utilizando Type) datos.
Ejemplos
DIM A, B As Integer A y B serán usados como enteros
DIM Xtot, Zdat As Double Xtot y Zdat serán usados como

variables reales
DIM XTitulo, Nom01, Nom02 Usados para contener datos literales

As String
DIM N, Epsi As Variant Puede contener datos numéricos o

literales
Clases de variables.
Las variables pueden ser: Locales, Públicas o Estáticas
Variables Locales.
Las variables Locales son aquellas que se declaran dentro de un módulo o
procedimiento y sólo pueden ser utilizadas en éste. Éstas dejan de existir una
vez que el procedimiento termina su ejecución. Se pueden usar en otros
módulos o procedimientos pero sus características nada tienen que hacer con
la declaración dada en otro módulo o procedimiento. Para declararlas se debe
usar la sentencia DIM.
Por ejemplo:
Sub procedimiento()
Dim nDat As Integer
Dim Cadena As String
Sentencias ....
End Sub
Variables Públicas.
Si se quiere que una variable esté disponible para todos los procedimientos de
todos los módulos VBA de un proyecto, se la debe definir a través de la
sentencia PUBLIC (y no DIM).
Por ejemplo:
Public NTotal As Integer
Las variables públicas se deben definir antes del primer procedimiento de un

módulo de VBA; no deben definirse en los módulos correspondientes a las
hojas del Libro de Trabajo ni en los módulos correspondientes a UserForms.
Variables Estáticas.
Si se desea que una variable definida en un procedimiento conserve su valor
una vez terminado éste, e ingresado a otro procedimiento, ésta se debe definir
a través de la sentencia STATIC.
Por ejemplo:
Sub Procedimiento()
Static nDat As Integer
[ Sentencias ...]
End Sub
Option Explicit.
La sentencia Option Explicit permite que el programa se detenga cada vez que
VBA encuentre una variable que no ha sido definida. Esto es de gran utilidad
cuando se usan muchas variables ya que nos permite identificar rápidamente
errores o uso no deseado en el nombre de la variable. Esta sentencia se debe
escribir al comienzo del módulo.
Constantes.
A diferencia de la variables, cuyo valor cambia al ejecutarse un procedimiento,
hay valores que no cambian durante la ejecución de un procedimiento, éstos
valores se denominanConstantes. Las constantes se definen a través de la
sentencia Const.

Por ejemplo;
Const Nivel As Integer
Las constantes también pueden declararse como Públicas para que estén
disponibles en todos los procedimientos de todos los módulos, esto se hace a
través de la sentencia PUBLIC
Public Const TasaActiva As Integer
Esta sentencia debe incluirse en un módulo antes del primer procedimiento.
Para definir constantes Locales, basta definirlas a través de la

sentencia Const dentro de un procedimiento o función.
Definir las palabras reservadas de un lenguaje.
En programación, las palabras reservadas son aquel

grupo de identificadores (palabras) que no pueden ser
utilizadas por el usuario para nombrar a las variables,
funciones, procedimientos, objetos y demás elementos de
programación que cree.
Generalmente esto se debe a que el propio lenguaje de programación ya las

utiliza, por esta razón, las palabras reservadas no pueden ser empleadas como
identificadores definidos por el usuario.
Cada lenguaje de programación tiene su propio grupo de palabras reservadas,

pero en general coinciden algunas de las siguientes: and, array, begin, case,
const, default, do, else, end, file, for, function, goto, if, in, label, mod, not, of, or,
repeat, return, then, to, type, until, void, while, etc.
Identificadores.
Todas las variables, constantes, tipos de datos, funciones y procedimientos que

son definidos por el usuario deben tener un nombre especifico que permita
reconocerlos dentro del programa.
En los lenguajes de programación, a estos nombres se les conoce como

Identificadores. Así pues, todos los nombres de las variables, constates u otros

elementos que nosotros definamos en el programa, excepto las palabras

reservadas, son denominados como identificadores.
Algunos de los identificadores más utilizados en los distintos lenguajes de

programación:
 El nombre puede tener una longitud máxima hasta 127 caracteres.

 El primer carácter debe empezar obligatoriamente por una letra o el carácter
(_).
 Los caracteres siguientes al primero pueden ser letras, dígitos o el carácter
(_).
 No se permiten espacios, ni caracteres especiales (%, $, &, @, !, á, ñ, Ñ, …).
 No se permite usar nombres repetidos, ni palabras reservadas según la
ayuda del programa.
Por ejemplo:
Nombres permitidos Nombres no permitidos
TotalFactura Total Factura

Total_Factura Total$
PrimaNavidena PrimaNavideña
LongitudMaxima LongitudMáxima
_Area1 2_Area
NOTA:
Los usuarios pueden elegir los nombres de sus variables y funciones con gran libertad siempre
y cuando se respeten las reglas del lenguaje, y no utilice palabras reservadas en los nombres
de los identificadores. Aunque no es obligatorio, se aconseja que los identificadores tengan
cierta relación con el uso que se le va a dar; así por ejemplo, si un identificador hace referencia
a un procedimiento, utilice nombres de verbos para relacionarlo con el proceso que realice.
Palabras clave de Visual Basic

Las palabras clave siguientes están reservadas, lo que significa que no se
pueden utilizar como nombres para los elementos de programación, como son
las variables o los procedimientos.

AddHandler Dim Me SByte

AddressOf DirectCast Mod Select
Alias Do Module Set
And Double MustInherit Shadows
AndAlso Each MustOverride Shared
As Else MyBase Short
Boolean ElseIf MyClass Single
ByRef End Namespace Static
Byte EndIf Narrowing Step
ByVal Enum New Stop
Call Erase Next String
Case Error Not Structure
Catch Event Nothing Sub
CBool Exit NotInheritable SyncLock
CByte False NotOverridable Then
CChar Finally Object Throw
CDate For Of To
CDec Friend On True
CDbl Function Operator Try
Char Get Option TryCast
CInt GetType Optional TypeOf
Class Global Or Variant
CLng GoSub OrElse Wend
CObj GoTo Overloads UInteger
Const Handles Overridable ULong
Continue If Overrides UShort
CSByte Implements ParamArray Using
CShort Imports Partial When
CSng In Private While
CStr Inherits Property Widening
CType Integer Protected With
CUInt Interface Public WithEvents
CULng Is RaiseEvent WriteOnly
CUShort IsNot ReadOnly Xor
Date Let ReDim #Const
Decimal Lib REM #Else
Declare Like RemoveHandler #ElseIf
Default Long Resume #End
Delegate Loop Return #If

Definir las funciones internas de un programa.

Las funciones son uno de los elementos más importantes de cualquier lenguaje
de programación actual. De hecho, Niklaus Wirth, uno de los más importantes
teóricos de la programación y creador del lenguaje Pascal entre otros, llegó a
indicar que todo programa no era más que la suma de código (rutinas,
procedimientos o funciones, como se les quiera llamar) y datos (variables,
matrices, etc...). Sea como sea, las funciones tienen un papel estelar en el
desarrollo de aplicaciones en la actualidad.
Hasta ahora, hemos visto como realizar código de una forma estructurada, con
sentencias de control que nos permiten dominar la ejecución del mismo
fácilmente. Pero si sólo tenemos esto, solamente podremos manejar el código
de forma lineal: ejecutaremos las líneas una a una, una detrás de la otra, hasta
el final del programa. Es más, si quisiéramos usar un determinado código
varias veces en el mismo programa tendríamos que repetir ese código varias
veces, teniéndolo que adaptar a cada situación. ¿Y qué ocurre si queremos
reutilizar un código en varios programas? Es un problema que se resuelven
gracias a las funciones.
Las funciones son trozos de código que tienen un nombre y que podemos
utilizar en cualquier parte de nuestro código con una llamada directa.
Este es un buen ejemplo:
function datos_personales(nombre, apellidos, edad)

{
return "Hola, " + nombre + " " + apellidos + ", tienes " + edad + " años.";
}
En este caso hemos definido una función que, usando los parámetros que le
hemos pasado, los combina para formar una cadena formateada, que devuelve
gracias a la palabra reservada return.
Funciones predefinidas en visual basic.
En numerosas ocasiones sobre todo si se han de realizar cálculos

matemáticos, estadísticos o financieros es preciso ejecutar operaciones
distintas a las que gestionan expresiones en las que se utilizan exclusivamente
operadores matemáticos afortunadamente no es preciso acudir al diseño de
laboriosos y complejos algoritmos para encontrar la raíz cuadrada de un

numero o el seno de un Angulo ya que visual BASIC dispone de funciones

incorporadas que devuelven estas cantidades.
Estas funciones se denominan predefinidas internas o estándar o también
funciones de librería.
El formato de la función es la siguiente
ABS(expresión numérica) EABS(3.5)

SQR(expresión numérica) SRQ(4) =2
INT(expresión numérica) INT(3.84)=3
CLASES DE FUNCIONES.
Funciones aritméticas: las funciones aritméticas son aquellas que realizan la

operaciones del cálculo del signo(+,-) parte entera, parte decimal o
truncamiento de los números reales que afectan las operaciones básicas
Funciones exponenciales: las funciones exponenciales se utilizan en

numerosas aplicaciones de gestión científica para resolver problemas de todo
tipo desde crecimiento de población hasta cálculos de interés compuesto que
implica funciones exponenciales
Funciones logarítmicas: los logaritmos son unas de las funciones estándar

utilizadas en matemáticas y aplicaciones científicas. La función logarítmica más
importante es log(argumento) que obtiene el logaritmo natural de un argumento
en: log10(x) = log (x)/log(10)
Funciones trigonométricas: las funciones trigonométricas devuelven los valores

del seno, coseno, tangente y cotangente de un ángulo expresado en radianes.
Sin (expresión en radianes)

Cos (expresión en radianes)
Tan (expresión en radianes)
Atn (expresión en radianes)
La siguiente tabla provee una descripción breve de algunas de las funciones

VBA más utilizadas.
FUNCIÓN DESCRIPCIÓN
Abs Regresa el valor absoluto de un número
Asc Obtiene el valor ASCII del primer caracter de una cadena de texto
CBool Convierte una expresión a su valor booleano

CByte Convierte una expresión al tipo de dato Byte
CCur Convierte una expresión al tipo de dato moneda (Currency)
CDate Convierte una expresión al tipo de dato fecha (Date)
CDbl Convierte una expresión al tipo de dato doble (Double)
CDec Convierte una expresión al tipo de dato decimal (Decimal)
Choose Selecciona un valor de una lista de argumentos
Chr Convierte un valor ANSI en valor de tipo texto
CInt Convierte una expresión en un dato de tipo entero (Int)
CLng Convierte una expresión en un dato de tipo largo (Long)
CreateObject Crea un objeto de tipo OLE
CStr Convierte una expresión en un dato de tipo texto (String)
CurDir Regresa la ruta actual
CVar Convierte una expresión en un dato de tipo variante (Var)
Date Regresa la fecha actual del sistema
DateAdd Agrega un intervalo de tiempo a una fecha especificada
DateDiff Obtiene la diferencia entre una fecha y un intervalo de tiempo especificado
DatePart Regresa una parte específica de una fecha
DateSerial Convierte una fecha en un número serial
DateValue Convierte una cadena de texto en una fecha
Day Regresa el día del mes de una fecha
Dir Regresa el nombre de un archivo o directorio que concuerde con un patrón
EOF Regresa verdadero si se ha llegado al final de un archivo
FileDateTime Regresa la fecha y hora de la última modificación de un archivo
FileLen Regresa el número de bytes en un archivo
FormatCurrency Regresa un número como un texto con formato de moneda
FormatPercent Regresa un número como un texto con formato de porcentaje
Hour Regresa la hora de un valor de tiempo
IIf Regresa un de dos partes, dependiendo de la evaluación de una expresión
InputBox Muestra un cuadro de diálogo que solicita la entrada del usuario

InStr Regresa la posición de una cadena de texto dentro de otra cadena
InStrRev Regresa la pocisión de una cadena de texto dentro de otra cadena pero empezando desde el
final
Int Regresa la parte entera de un número
IsDate Regresa verdadero si la variable es una fecha
IsEmpty Regresa verdadero si la variable está vacía
IsError Regresa verdadero si la expresión es un valor de error
IsNull Regresa verdadero si la expresión es un valor nulo
IsNumeric Regresa verdadero si la variable es un valor numérico
Join Regresa una cadena de texto creada al unir las cadenas contenidas en un arrreglo
LCase Regresa una cadena convertida en minúsculas
Left Regresa un número específico de caracteres a la izquierda de una cadena
Len Regresa la longitud de una cadena (en caracteres)
LTrim Remueve los espacios a la izquierda de una cadena
Mid Extrae un número específico de caracteres de una cadena de texto
Minute Regresa el minuto de una dato de tiempo
Month Regresa el mes de una fecha
MsgBox Despliega un cuadro de dialogo con un mensaje especificado
Now Regresa la fecha y hora actual del sistema
Replace Reemplaza una cadena de texto con otra
Space regresa una cadena de texto con el número de espacios especidicados
Split Regresa un arreglo formado for cadenas de texto que formaban una sola cadena
Str Regresa la representación en texto de un número
Right Regresa un número especificado de carecteres a la derecha de una cadena de texto
Rnd Regresa un número aleatorio entre 0 y 1
Round Redondea un número a una cantidad específica de decimales
RTrim Remueve los espacios en blanco a la derecha de una cadena de texto
Second Regresa los segundos de un dato de tiempo
StrComp Compara dos cadenas de texto
StrReverse Invierte el orden de los caracteres de una cadena

Time Regresa el tiempo actual del sistema
Timer Regresa el número de segundos desde la media noche
TimeValue Convierte una cadena de texto a un númer de serie de tiempo
Trim Remueve los espacios en blanco al inicio y final de una cadena de texto
TypeName Obtiene el nombre del tipo de dato de una variable
UCase Convierte una cadena de texto en mayúsculas
Val Regresa el número contenido en una cadena de texto
Weekday Regresa un número que representa un día de la semana
WeekdayName Regresa el nombre de un día de la semana
Year Obtiene el año de una fecha
Trabajar los tipos de operadores y expresiones de un programa.
OPERACIONES CON LOS DATOS (expresiones y operadores).
1. EXPRESIONES.
Una expresión es una combinación de variables, constantes y literales de tipos

compatibles entre sí, estos elementos están combinados mediante operadores
válidos; la expresión más simple está formada por un único elemento (variable,
literal o constante) sin ningún operador.
Es posible tener expresiones aritméticas (combinando expresiones de
tipo entero y/o real), expresiones lógicas (combinando expresiones de
tipo logico) y expresiones de tipo caracter.
A continuación se muestran algunas expresiones típicas:
2 * pi * r
v*t
(a>5) and (a<10)
“Sub” + “cadena”

Toda expresion tiene asociada un tipo que se corresponde con el tipo del valor
que devuelve la expresion cuando se evalua, por lo que habrá tantos tipos de
expresiones como tipos de datos. Habra expresiones numéricas y lógicas.
2. OPERADORES.
Son símbolos que se utilizan para definir las operaciones que se realicen
entre los datos
2.1 TIPOS.
a) ARITMÉTICOS: Se utilizan para realizar operaciones con datos

numéricos, formando expresiones aritméticas.
SIGNO SIGNIFICADO
+ Suma
- Resta
* Multiplicación
/ División
^ Potenciación
() Agrupa operaciones
El orden de prioridad en la evolución de los operadores aritméticos es el

Siguiente:
1) Paréntesis
2) Potenciación
3) Multiplicación y División
4) Suma y Resta
Ejemplo: Si a = 9; b =2; c =5; d = 3

Expresión Aritmética Resultado
A+b*c 19
(a+b)*c 55
((a + c – b) * b) / (c + d ) 3
(c + d) ^ b 64
b) RELACIONES: Se utiliza para relacionar expresiones que al ser evaluadas

producen un valor booleano: verdadero o falso.
SIGNO SIGNNIFICADO
< Menor que

> Mayor que
= Igual a
<= Menor o igual que
>= Mayor o igual que
<> Distinto de
No existen prioridades en el orden de evaluación de los operadores

relacionales. Si es necesario establecer alguna prioridad en el orden de
evaluación, se deben utilizar los paréntesis.
Ejemplo: si a = 9; b = 2; c = 5; d = 3
Expresión relacional Resultado
c < a Verdadero
a >=c Verdadero
a– b > d Falso
d <= c – b Verdadero
d< c- b Falso

También se puede comprar datos alfanuméricos. En este caso se compran

uno a uno los caracteres, comenzando desde la izquierda.
Si los datos tienen diferentes longitudes, pero son exactamente iguales hasta el
último carácter del más corto, entonces se considera que el más largo es el
mayor. El único caso en que son caracteres, en el mismo orden. La misma
longitud y los mismos caracteres, en el mismo orden. Las letras minúsculas
son mayores que las mayúsculas.
Ejemplo:
Expresión relacional Resultado
“E” < “F” Verdadero
“e” < “F” Falso
“NADAR” = “NADAR” Verdadero
“2” < “12” Falso
“B” > “ASTRO” VERDADERO
c) LÓGICOS: permiten realizar operaciones con expresiones

relacionales, efectuando combinación de condiciones que generan un
resultado booleano: verdadero o falso.
SIGNOS SIGNIFICADO
AND Producto lógico (y)

OR Suma lógica (0)
NOT Negación (NO)
Orden de prioridad en la evaluación de los operadores lógicos:

1) NOT
2) AND
3) OR
AND: es el operador lógico de conjunción. La expresión que se evalúa de

cómo resultado verdadero si y solo si todos las condiciones son verdaderas.

Dicho de otra manera, es suficiente que unas de las condiciones sea falsa
para que el resultado sea falso.
Condición 1 - A Condición 2 - B Resultado A AND B
Falso Falso Falso

Falso Verdadero Falso
Verdadero Falso Falso
Verdadero Verdadero Varadero
Ejemplo: si a = 9; b = 2; c =5; d = 3
Expresión Lógica Resultado
(a > b) AND (b<= c)

Verdadero
{V} {V}
( C > d ) AND (c = a)
Falso
{V} {F}
b = ( c – d ) AND ( a + b) > = ( c * d )
Verdadero
{V} {V}
(c = 5) AND (c >b) AND (a <= d)

Falso
{F} {F} {F}
(C = 5) AND (b < c) AND (a >= d)

Verdadero
{V} {V} {V}
OR: es el operador lógico de disyunción. La expresión que se evalúa da como

resultado falso sí y solo sí todas las condiciones son falsas. Dicho de otra
manera, es suficiente que una de las condiciones sea verdadera para que el
resultado sea verdadero.
Condición1 A Condición 2 B Resultado A OR B
Falso Falso Falso

Falso Verdadero Verdadero
Verdadero Falso Verdadero
Verdadero Verdadero Verdadero

Ejemplo: si a = 9; b = 2; c =5; d = 3
Expresión Lógica Resultado
(a > b) OR (b<= c)
Verdadero
{V} {V}
( C > d ) OR (c = a)
Falso
{V} {F}
b = ( c – d ) OR ( a + b) > = ( c * d )
Verdadero
{V} {V}
(c > 5) OR (c >b) OR (a <= d)

Falso
{F} {F} {F}
(C <> 5) OR (b < c) OR (a >= d)

{V} {V} {V} Verdadero
NOTA:
Es el operador lógico de negación. Afecta a una sola expresión, a cambio su
estado lógico: si era falso se convierte en verdadero y viceversa.
Condición 1 - A Resultado - Not A
FALSO VERDADERO
VERDADERO FALSO
EJEMPLOS: A =9, B: 2, C: 5, D: 3
Expresión lógica Resultado
NOT (A < B) {F} VERDADERO
NOT (( B + D) > C ) {F} FALSO
NOT ( C = D ) {V} VERDADERO

d. ALFANUMERICO: se utilizan para unir datos alfanuméricos.
SIGNO SIGNICADO
+ CONCATENACION
EJEMPLOS: SI NOMBRE = “JUAN¨” Y APELLIDO = “PEREZ”
EXPRESION ALFANUMERICA RESULTADO
NOMBRE+APELLIDO “JUANPEREZ”
“NOMBRE:“” +APELLIDO “JUAN PEREZ”
“5“ +“17” “517”
Orden de evaluación (Reglas de prioridad)
El orden de evaluación de los operadores en una expresión es el siguiente:

1) Paréntesis (comenzando por lo más internos)
2) Potencias
3) Productos y divisiones
4) Sumas y restas
5) Concatenación
6) Relacionales
7) NOT
8) AND
Operadores
9) OR
Aritmeticos Relacionales Logicos
Suma < Menor que

> Mayor que NOT
Resta AND
Multiplicacion = Igual a
<= Menor o igual que OR
Division
Potenciacion >= Mayor o igual que
Agrupar operaciones <> Distinto de

1. ¿Cuál es la diferencia entre constante y variable?

2. ¿Qué es una palabra reservada y cual es su importancia?
3. Menciona 3 funciones internas del lenguaje VBA.
4. Elabore 2 ejercicios en vba que contenga los operadores mas utilizados.

06
TAREA 06: UTILIZAR HERRAMIENTAS PARA EL DISEÑO Y
ANÁLISIS DE ALGORITMOS.

 Elaborar los algoritmos con el programa de diseño.
 Analizar el proceso de construcción de un algoritmo.
 Desarrollar casos prácticos con el programa de diseño.
"No hay secretos para el éxito. Este se alcanza

preparándose, trabajando arduamente y aprendiendo del
fracaso......”……. Colin Powell.
 Elaborar los algoritmos con el programa de diseño.
 Analizar el proceso de construcción de un algoritmo.
 Desarrollar casos prácticos con el programa de diseño.

OPERACIONES
OPERACIÓN:
ELABORAR LOS ALGORITMOS CON EL PROGRAMA DE DISEÑO.
Crear un DF en FreeDFD para mostrar en pantalla los n primeros números

naturales, siendo n un valor ingresado por el usuario.
Crear un DF en FreeDFD para calcular el área de un círculo en base al valor

del radio ingresado por el usuario.
Ingrese los valores iniciales para variables y constantes.

Diagrama completo:
OPERACIÓN:
ANALIZAR EL PROCESO DE CONSTRUCCIÓN DE UN ALGORITMO.
Crear un diagrama con el programa FreeDFD que solicite al usuario una
cantidad de números a ingresar y al final debe de mostrar en pantalla cual es el
mayor y el menor numero de los n ingresados.
Paso 1:
Primero ingrese una salida para mostrar al usuario lo que hara el diagrama.

Paso 2:
Asignamos los valores iniciales para los n números que ingresara el usuario,
otra variable que almacenara el mayor numero el cual inicia en cero(0) y otra
variable que mostrara el menor numero al cual se le da un numero grande
como por ejemplo 1000000000000… tal como se muestra en la siguiente
imagen.
Paso 3:
Solicitar al usuario mediante una
salida cuantos números desea
ingresar y evaluar.
Paso 4:
Ingresar una entrada de datos el cual almacenara los valores que el usuario
ingrese almacenándolos en la variable N la cual será evaluada con las
variables mator y menor respectivamente.

Paso 5:
Luego se solicita al usuario que ingrese la cantidad de números que indico en
el paso anterior.
Paso 6:
Ingresar un proceso repetitivo para que solicite al usuario el ingreso de los n
números.
Paso 7:
Dentro del proceso repetitivo estará el
ingreso de números.
Paso 8:
Luego del ingreso de números debe de agregar una decisión la cual evaluara si
el numero ingresado es mayor a la variable mayor a la cual se le asigno un
valor inicial 0. La primera ves se cumplirá y la variable mayor será el primero

numero ingresado, para que posteriormente el siguiente numero se evalue con

el nuevo contenido de esta variable mayor.
Paso 9:
Igual que en el caso anterior, se agregara una decisión pero esta ves para
calcular el número menor.
Se evalua el numero preguntando si es menor que la variable menor, recuerde

que la variable menor tiene un numero alto 100000000…lo cual es muy
probable que casi siempre el numero ingresado sea menor que el valor de esta
variable inicial, siendo el nuevo numero menor el primer valor ingresado.
Paso 10:
Por ultimo, después de que termina el proceso repetitivo, se muestra en

pantalla el reporte final inficando cual es el numero menor y el mayor de los n
números ingresados.

OPERACIÓN:
DESARROLLAR CASOS PRÁCTICOS CON EL PROGRAMA DE DISEÑO.
Crear un diagrama con el programa FreeDFD que solicite al usuario ingresar

una cadena de texto y la salida debe de ser los 2 primeros caracteres de esta
cadena.

Crear un diagrama con el programa FreeDFD que permita ingresar al usuario

un número y el resultado debe indicar si el número ingresado es Par o impar.
Crear un diagrama con el programa

FreeDFD que permita calcular la suma
de los n primeros números naturales
siendo n un valor ingresado por el
usuario.

Crear un diagrama con el programa FreeDFD que permita imprimir los números
del 1 al 10 de formas ascendente y descendente, el criterio de orden será
ingresado por el usuario al iniciar el programa.
ELABORAR LOS ALGORITMOS CON EL PROGRAMA DE DISEÑO.
DIAGRAMAS DE FLUJO: FREEDFD.

DFD es un programa de libre disposición para ayuda al diseño e
implementación de algoritmos expresados en diagramas de flujo (DF). Además
incorpora opciones para el depurado de los algoritmos, lo que facilita
enormemente la localización de los errores de ejecución y lógicos más
habituales.

Su utilización es muy sencilla, al tratarse de una herramienta gráfica, y además

incluye un menú de ayuda muy completo, por lo que en estas notas nos vamos
a centrar en el uso básico de las herramientas de diseño y depuración. El resto
de opciones (detalles de sintaxis más avanzados, operadores y funciones
disponibles), puede consultarse directamente en la ayuda del programa.
INICIO DE DFD.
La ejecución de DFD presenta la pantalla de inicio siguiente.
Barra de herramientas.
Ventana de edición.
Barra de herramientas.
Ejecución
Depuración Zoom
Botones de objetos Subprogramas
Aunque puede accederse a todas las opciones que comentaremos a

continuación a través del menú, y con atajos de teclado, en estas notas las
describiremos a través de los botones correspondientes.
 El bloque de botones de objetos nos permite seleccionar los distintos

elementos (objetos) que vamos a introducir en el DF: sentencias de
asignación, selección, iteración.
 El bloque de ejecución permite poner en funcionamiento el algoritmo.
 El bloque de depuración se utiliza, en caso de funcionamiento incorrecto,
para detectar errores en la construcción del algoritmo y corregirlos.

 Los botones de subprogramas permiten introducir funciones definidas por el

programador.
 Los restantes botones tienen una funcionalidad similar a la de las restantes
aplicaciones Windows: abrir fichero, guardar fichero, cortar, pegar. Puede
verse su tarea asociada acercando el cursor del ratón (sin hacer clic) al
botón correspondiente.
Reconocer los elementos de trtabajo:

Operadores Aritmeticos en DFD.
En el programa FreeDFD, se usan diferentes tipos de

Operadores, entre los que encontramos Matemáticos,
Relacionales, Lógicos y con operaciones sobre Cadenas.
A continuación, encontrarás una lista de los operadores, el tipo al que

pertenecen y su sintaxis:
Operadores Matemáticos:
Operación Símbolo Sintaxis
Suma + valor1 + valor2
Resta - valor1 – valor2
Multiplicación * valor1 * valor2
División / valor1 / valor2
Residuo mod valor1 mod valor2
Potencia ^ valor1 ^ valor2
Raíz Cuadrada sqrt sqrt(valor)
Valor Absoluto abs abs(valor)
Seno sin sin(valor)
Coseno cos cos(valor)
Tangente tan tan(valor)

Arco Seno asin asin(valor)
Arco Coseno acos acos(valor)
Arco Tangente atan atan(valor)
Seno Hiperbólico sinh sinh(valor)
Coseno Hiperbólico cosh cosh(valor)
Tangente Hiperbólico tanh tanh(valor)
Logaritmo Decimal log log(valor)
Logaritmo Neperiano ln ln(valor)
Exponencial de e exp exp(valor)
Número Aleatorio random random(valor)
Entero más cercano round round(valor)
Parte entera trunc trunc(valor)
Operadores Relacionales:
Mayor que > valor1 > valor2
Menor que < valor1 < valor2
Mayor igual que >= valor1 >= valor2
Menor igual que <= valor1 <= valor2
Igual que = valor1 = valor2
Diferente de != valor1 != valor2

Operadores Lógicos
No not not valor
Y and valor1 and valor2
O or valor1 or valor2
O exclusivo xor valor1 xor valor2
No Y nand valor1 nand valor2
No O nor valor1 nor valor2
No O exclusivo xnor valor1 xnor valor2
Tanto los operadores relacionales como los operadores lógicos, retornan

valores de tipo lógico o booleano, en el caso de FreeDFD, retornan “.V.”
(Verdadero o 1) o “.F.” (Falso o 0).
Operadores con Cadenas
Para este caso tenemos dos operadores que podemos usar en FreeDFD, que
son:
 Obtener la longitud de una cadena: len. Por ejemplo: len(‘hola’) es igual a 4,
que es la cantidad de caracteres en la cadena.
 Obtener parte del contenido de una cadena: substring.
Por ejemplo:
Substring(‘pingüino’,5,4) es igual a ‘üino’, ya que “ü”, es el carácter numero 5
de la palabra “pingüino” y el operador devolverá los cuatro caracteres
siguientes al quinto incluido el mismo.
Objeto Asignación.

El objeto Asignación asigna valores a campos variables. Al ser ejecutado,

puede realizar hasta tres asignaciones.
El cuadro de dialogo del objeto Asignación contiene espacio para tres

asignaciones, cada asignación consta de un espacio para el campo variable
situado siempre a la izquierda, el símbolo de asignación y un espacio para la
expresión situada siempre a la derecha.
Esto indica que al campo variable se le asigna el resultado de la evaluación de

la expresión. Debe realizarse por lo menos una asignación.
Objeto Decisión.
El objeto decisión selecciona el flujo a seguir de acuerdo al valor lógico de una

condición.
La condición debe ser siempre una expresión que al ser evaluada de como
resultado un valor de tipo de dato Lógico.
Ejemplo:
n<5 , z >3 AND valor1*15 < 300*conta.

El objeto Decisión esta asociado a dos bloques de objetos ubicados a lado y

lado de este, y un objeto Cierre Decisión ubicado a continuación de ambos
bloques.
Si al evaluar la condición se obtiene el valor lógico Verdadero, se ejecuta el
bloque rotulado con la palabra Si, en caso contrario se ejecuta el bloque
rotulado con No. En ambos casos la ejecución continúa en el objeto Cierre
Decisión.
El cuadro de dialogo del objeto Decisión contiene espacio para la expresión

que conforma la condición, y dos casillas por medio de las cuales se puede
especificar por cual lado continuara el flujo en caso de que la condición sea
verdadera.
Objeto Lectura.
Este objeto Lectura permite la entrada de valores constantes desde el teclado y

se los asigna a campos variables. Podrá ser leída cualquier cantidad de
variables utilizando un objeto Lectura. Al ejecutarse, el objeto despliega un
cuadro de diálogo por cada variable presente en la lista, este cuadro de diálogo
espera que el usuario introduzca un valor constante que será asignado a la
respectiva variable.

El cuadro de diálogo para la edición del objeto contiene un espacio para

ingresar una lista de variables separadas por comas. Debe existir por lo menos
una variable.
Objeto Salida.
El objeto Salida muestra valores por pantalla. Puede ser visualizada cualquier
cantidad de valores utilizando un objeto Salida. Al ejecutarse, este objeto
evalúa cada una de las expresiones que contienen y despliegan un cuadro de
diálogo que muestra el valor obtenido en cada una de las expresiones en su
respectivo orden.
Objeto Ciclo Mientras.
Este objeto Ciclo Mientras tiene como función el ejecutar un bloque de objetos
mientras que una condición sea verdadera.
La condición debe ser siempre una expresión que al ser evaluada de como
resultado un valor de tipo de dato Lógico.
Ejemplo:
A>5, x >0 AND y = z, Valor*15 < 300*Contador.
Si al evaluar la condición se obtiene el valor .F. la ejecución del algoritmo

continuará a partir del objeto que sigue al Cierre.
El cuadro de dialogo del objeto Ciclo Mientras contiene espacio para la

expresión que conforma la condición.
Objeto Ciclo Paral.
Su función es ejecutar un bloque de objetos mientras que la variable contadora

no alcance el límite establecido por el valor final. El contador es siempre una
variable de tipo de dato Real. Contiene además un valor inicial que será
asignado al contador al iniciar la ejecución del ciclo, un valor final y un valor de
incremento. Si el contador excede el valor final, la ejecución continuará a partir
del objeto que sigue al Cierre. En caso contrario, se ejecutará el cuerpo del
ciclo y el contador será incrementado en el valor indicado por el incremento.

El cuadro de diálogo del objeto Ciclo para contiene espacio para la variable
contador, valor inicial, valor final y el valor de incremento en su respectivo
orden.
Objeto Llamada.
La función de este objeto es realizar una llamada a un subprograma, el cual

debe encontrarse en el diagrama en edición. En
la llamada deben encontrarse los argumentos
que han de ser pasados al subprograma, la
cantidad, el orden y el tipo de los argumentos
deben coincidir con los parámetros del
subprograma.
Una vez que el subprograma haya sido
ejecutado la ejecución continuará en el objeto
siguiente a la llamada.
El cuadro de diálogo para la edición de este objeto contiene el espacio para el

nombre del subprograma a llamar y el espacio para la lista de argumentos.
Dichos argumentos deben estar separados por comas.
Objeto Subprograma.
Es el primer objeto a ser ejecutado cuando un subprograma es llamado. Al ser

ejecutado, el objeto Subprograma transfiere el control al siguiente objeto.

El cuadro de diálogo del objeto Subprograma contiene un espacio para la

descripción o comentarios acerca del mismo; contiene un espacio para el
nombre del subprograma y un espacio para los parámetros. Estos parámetros
(si existen) deben estar separados por comas. El nombre de un subprograma
debe comenzar por una letra seguida de letras, números ó el caracter ( _ ).
Ejemplo:
Factorial, Leer, Sub1, sub_programa.

No se tiene en cuenta la diferencia entre mayúsculas y minúsculas para el
nombre de un subprograma, es decir, SUB equivale a sub.
Objeto Fin.
Este objeto junto con el objeto Inicio, delimita el cuerpo del procedimiento
principal.
Solo existe un objeto Fin en el diagrama; la ejecución de este objeto finaliza la
ejecución del algoritmo.

Objeto Cierre Ciclo.
Este objeto delimita el cuerpo de un ciclo, al culminar la ejecución del ciclo el

control se transfiere al objeto que sigue al objeto Cierre Ciclo.
ANALIZAR EL PROCESO DE CONSTRUCCIÓN DE UN ALGORITMO.
Un primer ejemplo de diseño con DF

Construiremos un primer ejemplo sencillo de algoritmo para ilustrar
lascapacidades más básicas de DFD. Dicho algoritmo consistirá en pedir un
número al usuario y presentarlo por pantalla.
La operación básica será la de inserción de objetos. En primer lugar,
insertaremos una sentencia de salida que le pida al usuario el número que
posteriormente se va a imprimir. Para ello pulsamos el botón correspondiente al
objeto que se desea insertar.
y llevamos el ratón al punto donde vamos a insertarlo. La inserción se realiza

pulsando el botón izquierdo, con lo que tendremos una situación como la
siguiente:
Los puntos azules indican qué objeto se acaba de insertar. Para introducir en la
sentencia de salida el mensaje que queremos imprimir será necesario EDITAR
dicho objeto, haciendo doble clic sobre el mismo. De este modo se abre una
ventana donde podemos dicho mensaje (por ejemplo 'Buenos días. Dígame un
número, por favor').

Como el mensaje es una cadena de caracteres, no debemos olvidarnos de las

comillas simples al inicio y final de la misma.
Seguidamente vamos a insertar una sentencia de ENTRADA, para almacenar
en una variable el valor del número que nos proporcione el usuario. Para ello
pulsaremos el botón correspondiente
y lo insertaremos a continuación de la sentencia de salida anterior. Si editamos

el objeto, haciendo doble clic sobre el mismo, aparecerá una pantalla cuyo
cuadro de texto nos permitirá darle nombre a la variable donde vamos a
guardar el valor (en este ejemplo la variable se va a llamar número):
Para finalizar, mostraremos al usuario el número que ha introducido, para lo

cual insertaremos una nueva sentencia de SALIDA, que editaremos para que
muestre el siguiente mensaje:

con lo que el algoritmo tendrá el siguiente aspecto en pantalla:
Ejecución con DF.

Tras haber diseñado el algoritmo podemos probar a ejecutarlo, al objeto de
detectar posibles errores en él. Para ello utilizaremos los botones de ejecución,
y enparticular el botón EJECUTAR
que pondrá en marcha el algoritmo.

La primera sentencia en ejecutarse será la de SALIDA, que mostrará en
pantalla el mensaje correspondiente:

Seguidamente la de ENTRADA, que nos muestra un cuadro de texto donde

introduciremos el valor que queramos darle a la variable (por ejemplo, 123.45):
y, finalmente, la última sentencia de SALIDA:
Cuando el algoritmo finaliza su ejecución sin error se muestra el siguiente

mensaje:

Dado que el algoritmo es correcto, lo guardamos por ejemplo, con el nombre

entradasalida. La opción de guardar es similar a la de cualquier aplicación
Windows.
Unicamente recordar que en general, durante el proceso de elaboración de un
algoritmo (que puede ser largo) debemos guardar frecuentemente en disco el
diseño, al objeto de prevenir posibles fallos o errores que dejen inutilizado el
ordenador y provoquen la pérdida del trabajo realizado.
DESARROLLAR CASOS PRÁCTICOS CON EL PROGRAMA DE DISEÑO.
Diseñar el algoritmo en FreeDFD que muestre el mayor de 3 números

ingresados.
Ingrese una entrada de datos:
Lo mismo para los 3 números.

Ingrese la Decisión:
Al final el diagrama completo será como la siguiente imagen:

Diseñar el algoritmo en FreeDFD que permita calcular el promedio de dos

notas ingresadas y el programa debe mostrar el mensaje “APROBADO” si
el promedio es mayor o igual a 11, caso contraro debe mostrar el mensaje
“DESAPROBADO”.
Ingrese un mensaje solicitando al usuario la

primera nota.
Ingrese una entrada para que el usuario digite la primera nota.

Luego de hacer lo mismo para la segunda nota ingrese el proceso para calcular
el promedio.
Despues de calculado el promedio ingrese la decisión de la cual dependerá el

mensaje a mostrar.
Por ultimo ingrese el mensaje final al usuario.
El diagrama completo se puede ver en la siguiente

imagen:

1. Elaborar un diagrama en FreeDFD para resolver el siguiente enunciado:
En un hospital existen tres áreas: Ginecología, Pediatría, Traumatología. El

presupuesto anual del hospital se reparte conforme a la siguiente tabla:
Área Porcentaje del presupuesto

Ginecología 40%
Traumatología 30%
Pediatría 30%
Obtener la cantidad de dinero que recibirá cada área, para cualquier monto
presupuestal.
2. Hacer un DF en FreeDFD que pida 10 numeros y luego indique cuantos

fueron pares y cuantos impares.
3. Realizar un DF que determine el número intermedio de 3 números enteros

ingresados por teclado.
4. Elaborar un diagrama en FreeDFD para resolver el siguiente enunciado:
Ingresar 3 notas, calcular el promedio y mostrar en pantalla lo siguiente:

Si el promedio es menor a 11 - "Reprobado",
Si el promedio es mayor a 11 y menor a 15 - "Aprobado - Regular".
Si el promedio es mayor a 15 y menor o igual a 20 - "Aprobado -
Excelente".
NOTA: Si cualquier nota ingresada es un numero negativo o es mayor a

20, debera mostrar el mensaje "Existe un ingreso incorrecto".

07
TAREA 07: ANALIZAR EL CONCEPTO DE FUNCIONES,
PARÁMETROS Y PROCEDIMIENTOS.
 Aprender a utilizar parámetros en una función.

 Analizar las normas generales de uso de parámetros.
 Construir un procedimiento utilizando variables locales y globales.
 Definir las ventajas de utilizar procedimientos y funciones.
"No hay secretos para el éxito. Este se alcanza

preparándose, trabajando arduamente y aprendiendo del
fracaso..........” Colin Powell.
 Aprender a utilizar parámetros en una función.
 Analizar las normas generales de uso de parámetros.
 Construir un procedimiento utilizando variables locales y globales.
 Definir las ventajas de utilizar procedimientos y funciones.
 Utilizar la recursividad en el uso de procedimientos y funciones.

OPERACIÓN:
APRENDER A UTILIZAR PARÁMETROS EN UNA FUNCIÓN.
Pasos para crear una función que reciba como parámetros un rango de
celdas u el resultado sea la concatenación de las mismas.
Paso 1:
Cree un nuevo archivo de Excel y elabore el siguiente diseño:
Paso 2:
Abra el editor VBA e inserte un modulo.

Paso 3:
Ingrese el siguiente código.
Function CONCATENARCELDAS(Rango As Range)
'Bucle para recorrer todas las celdas del rango

For Each celda In Rango.Cells
'Si la celda NO está vacía, entonces concatenarla

If celda.Value <> "" Then
resultado = resultado & "; " & celda.Value
End If
Next celda
'Se remueve el ; y espacio inicial

resultado = Right(resultado, Len(resultado) - 2)
CONCATENARCELDAS = resultado
End Function
Paso 4:
Utilice la función para
unir los nombres de
las personas que
trabajan por sede.

RESULTADO FINAL.
Pasos para crear una función que se utilice para contar las celdas que
tienen un determinado color de fondo en un rango.
Paso 1:
Cree un nuevo archivo de Excel e ingrese datos de
prueba como lo muestra el siguiente diseño:
Paso 2:
Abra el editor VBA e ingrese un modulo con la siguiente función.
Function ContarColorFondo(rngCeldaColor As Range, rngRangoAContar As

Range) As Long
Dim rngCelda As Range
For Each rngCelda In rngRangoAContar

If rngCelda.Interior.ColorIndex = rngCeldaColor.Cells(1,
1).Interior.ColorIndex Then ContarColorFondo = ContarColorFondo + 1
Next rngCelda
Set rngCelda = Nothing

End Function

Paso 3:
Ingrese la función tal como lo muestra la siguiente imagen:
La función CONCATENARCELDAS recibe como argumento un rango y recorre cada una de las
celdas para concatenar sus valores. Solo en caso de que la celda no tenga un valor será
excluida de la concatenación.
Ya que en el primer ciclo del bucle la variable resultado está vacía, mi cadena siempre
empezará con un punto y coma. Es por eso que usando las funciones Right y Len remuevo esa
primera aparición del punto y coma y del primer espacio en blanco.
RESULTADO:
La función se encargara de contar cuantas celdas del rango B2:B6 tienen el
color de referencia de la celda B2.

OPERACIÓN:
ANALIZAR LAS NORMAS GENERALES DE USO DE PARÁMETROS.
Pasos para crear una función que muestre las iniciales de un nombre
completa en una celda.
Paso 1:
Creamos un nuevo archivo de Excel con el siguiente diseño:
Paso 2:
Insertamos un modulo con la siguiente función:
Function Iniciales_Nombres(Texto As String) As String

Dim longitud As Long, i As Long
Dim cadena_inicial As String
longitud = Len(Texto)
For i = 1 To longitud
If Asc(Mid(Texto, i, 1)) >= 65 And Asc(Mid(Texto, i, 1)) <= 90 Then
cadena_inicial = cadena_inicial & Mid(Texto, i, 1)
End If
Next i
Iniciales_Nombres = cadena_inicial
End Function
Paso 3:
Nos posicionamos en la celda C2 e insertamos la función dando como único
parámetro la celda donde se encuentra el nombre completo.

Función Len
Esta función nos devuelve el número de caracteres de una cadena, por lo tanto
retorna un número entero y recibe un parámetro que es un tipo de dato string.
Su sintaxis es: Len([cadena de caracteres])
Ejemplo: Si Texto="hola como estas" Len(Texto) devuelve el valor 15.
Función Asc
Con la función Asc podemos obtener el código ASCII de un caracter
Función Mid
Extrae partes de una cadena y recibe 3 parámetros.
Sintaxis: Mid(cadena, inicio, longitud)
El parámetro cadena es la cadena a extraer caracteres.
Inicio es el carácter desde donde se comienza la extracción.
Longitud es la cantidad de caracteres devueltos a partir del carácter de inicio.
Pasos para crear una función que reciba 2 notas como parámetros y
deberá calcular el promedio, la función deberá mostrar un mensaje
distinto dependiento del promedio calculado.
Paso 1:
Cree un nuevo archivo de Excel y elabore el siguiente diseño.

Paso 2:
Abra el editor de VBA e inserte un modulo con la siguiente función.
Function promedio_notas(n1 As Double, n2 As Double) As String
p = (n1 + n2) / 2
If p < 11 Then
promedio_notas = "Malo"
End If
If p >= 11 And p <= 14 Then

promedio_notas = "Regular"
End If
If p > 14 And p <= 17 Then

promedio_notas = "Bueno"
End If
If p > 17 Then
promedio_notas = "Excelente"
End If
End Function
Paso 3:
Ingrese la función en las celdas que desea mostrar el mensaje según el
promedio.
Por ejemlo en la celda D2 ingrese la siguiente función indicándole como
parámetros las dos notas que tiene ese primer registro.
=promedio_notas(B2;C2)

RESULTADO:
OPERACIÓN:
CONSTRUIR UN PROCEDIMIENTO UTILIZANDO VARIABLES LOCALES Y
GLOBALES.
Variable Local.
Pasos para crear un modulo que contenga 2 procedimientos, en el primero se
definirá una variable local y en el segundo se utilizara la misma variable del
procedimiento 1, el sistema debe evaluar el ámbito de la variable e indicar si
esta o no definida en el segundo procedimiento.
Paso 1:
Cree un nuevo archivo de Excel, y en el editor de VBA ingrese los siguientes
procedimientos.
Sub Procedimiento1()
Dim n As String
n = "senati"
MsgBox "El valor de n es " & n
End Sub
If n = "" Then
MsgBox "La variable n no esta definida"
Else
MsgBox "La respuesta es " & n
End If
End Sub
Paso 2:
Inserte dos formas en la hoja de Excel y vincule cada forma con un
procedimiento distinto.
Paso 3:
Ejecute ambos botones vinculados, en el primer caso mostrara el valor de la
variable local, en el segundo caso el procedimiento verifico que no existe y
mostrara un mensaje de advertencia.

Variable Global.
Ejercicio con la misma lógica que el ejemplo anterior con el cambio del ámbito
de la variable, ya que en este caso la variable estará definica como global.
Crear un nuevo archivo de Excel e ingresar las siguientes funciones con la

definición de la variable.
Dim n As String
n = "senati"
MsgBox "El valor de n es " & n
End Sub
If n = "" Then
MsgBox "La variable n no esta definida"
Else
MsgBox "La respuesta es " & n
End If
End Sub
Luego de ejecutar desde los vinculas en la hoja se podrá apreciar el mismo
mensaje en ambos procedimientos ya que la variable esta definida como global
y puede ser vista desde cualquier procedimiento en el modulo.
NOTA:
La variable toma el valor “Senati” cuando se ejecuta el primer procedimiento, si al abrir el libro
se ejecuta primero el segundo procedimiento se mostrara el mensaje de no definido.
Resultado al ejecutar el Procedimiento 1

OPERACIÓN:
DEFINIR LAS VENTAJAS DE UTILIZAR PROCEDIMIENTOS Y FUNCIONES.
Pasos para crear un modulo que al ejecutar muestre y liste todos los nombres
de las hojas de Excel.
Paso 1:
Cree un nuevo archivo de Excel y cree el siguiente procedimiento:
Sub CrearIndiceDelLibro()
Pregunta = MsgBox("Desea crear el índice en una hoja nueva?", _
vbExclamation + vbYesNoCancel, "Donde crear el índie...")
If Pregunta = vbCancel Then Exit Sub

If Pregunta = vbYes Then Worksheets.Add Before:=Worksheets(1)
With [B2]
.Value = "Contenido de este libro": .Font.Size = 12
.Font.Bold = True: .Font.Underline = xlUnderlineStyleSingle
End With
For Each Hoja In Worksheets

If Hoja.Name <> ActiveSheet.Name Then
INCREMENTO = INCREMENTO + 1
ActiveSheet.Hyperlinks.Add _
Anchor:=ActiveSheet.Cells(3 + INCREMENTO, 3), _
TextToDisplay:=Hoja.Name, _
SubAddress:=Hoja.Name & "!A1", _
Address:=""
End If
Next
End Sub

Paso 2:
Inserte una forma y vincule el objeto con el procedimiento creado en el paso

anterior.
Paso 3:
Ejecute la macro desde la forma y dele clic en si para que el índice se cree en
una nueva hoja.
RESULTADO:
Se creara en una nueva hoja el índice creado por el procedimiento.
El índice lista los nombres de las hojas y crea un vionculo a cada una de ellas.
NOTA:
Esta macro es útil cuando se tiene un libro con bastantes hojas, facilitando asi el despliegue
entre ellas.

OPERACIÓN:
UTILIZAR LA RECURSIVIDAD EN EL USO DE PROCEDIMIENTOS Y

FUNCIONES.
Pasos para crear un procedimiento que permitirá encontrar el área de las tres
figuras gemoetricas mas utilizadas (cuadrado, triangulo y circulo).
El modulo tendrá un procedimiento principal el cual se encargara de evaluar

una variable y dependiendo del tipo de figura invocara la ejecución de otro
procedimiento distinto.
Ademas se creara otro modulo el cual tendrá un procedimiento que se

encargue de registrar la función y agregar los detalles de la misma.
Paso 1:
Cree un nuevo archivo de Excel y elabore el siguiente diseño:
Paso 2:
Abra el editor de VBA y cree dos modulos asignándoles a ambos los nombres
que se indican en la siguiente imagen:

Paso 3:
En el modulo Mi_funcion_areas_figuras ingrese los siguientes procedimientos:
Function area_figura(figura As String, lado As Integer, base As Integer, _

altura As Integer, radio As Integer) As Double
If (figura = "cuadrado") Then
area_figura = area_cuadrado(lado)
ElseIf (figura = "triangulo") Then
area_figura = area_triangulo(base, altura)
ElseIf (figura = "circulo") Then
area_figura = area_circulo(radio)
Else
MsgBox ("Figura no definida para esta funcion." + Chr(13) + Chr(13) _
+ "Ingrese solo las siguiente figuras: " + Chr(13) _
+ "cuadrado - triangulo - circulo")
End If
End Function
Public Function area_cuadrado(lado)

area_cuadrado = lado * lado
End Function
Public Function area_triangulo(base, altura)

area_triangulo = (base * altura) / 2
End Function
Public Function area_circulo(radio)

Const pi As Double = 3.1416
area_circulo = pi * radio * radio
End Function

Paso 4:
En el modulo Descripcion_mi_funcion ingrese el siguiente código:
Sub FunctionDescription()
'------------------------------------------------------------------------
'Este procedimiento agrega descripcion de ayuda a la funcion creada,
'Ademas agrega la funcion a una categoria existente.
'Por sistemas_mr@hotmail.com
'Date: 05/11/2013
'------------------------------------------------------------------------
'Declarando las variables necesarias

Dim NombredeFuncion As String 'FuncName
Dim DescripcionFuncion As String
Dim CategoriaFuncion As Variant
Dim NombredeMiCategoria As String
'La funcion area_figura tiene 5 parametros

Dim DescripcionArgumentos(1 To 5) As String
'"FrictionFactor" is the name of the function.

NombredeFuncion = "area_figura"
'Se agrega la descripcion de la funcion.

DescripcionFuncion = "Calcula el area de la figura geometrica indicada"
'Cada categoria tiene un numero asignado.

'En este ejemplo le asignaremos el numero 3.
CategoriaFuncion = 3
'Puede agregar directamente el nombre de la categoria.

'De forma opcional puede agregar un evento para buscar
'el nombre de la categoria segun el numero ingresado.
'FuncCat = "My VBA Functions"
NombredeMiCategoria = "Mis Funciones Personales"
'Here we add the description for the function's arguments.

DescripcionArgumentos(1) = "Ingrese solo las figuras: cuadrado, triangulo o circulo"
DescripcionArgumentos(2) = "Lado del cuadrado, si la figura ingresada no es un cuadrado, entonces ingrese cero(0)"
DescripcionArgumentos(3) = "Base de la figura, si la figura ingresada no es un triangulo, entonces ingrese cero(0)"
DescripcionArgumentos(4) = "Altura de la figura, si la figura ingresada no es un triangulo, entonces ingrese cero(0)"
DescripcionArgumentos(5) = "Radio del circulo, si la figura ingresada no es un circulo, entonces ingrese cero(0)"

'Opcionalmente puede cambiar la variable NombredeMiCategoria por CategoriaFuncion

'si desea que su funcion se ubique en una categoria propia de Excel.
Application.MacroOptions _
Macro:=NombredeFuncion, _
Description:=DescripcionFuncion, _
Category:=NombredeMiCategoria, _
ArgumentDescriptions:=DescripcionArgumentos
'Categorias existentes.
Select Case CategoriaFuncion
Case 1: CategoriaFuncion = "Financial"
Case 2: CategoriaFuncion = "Date & Time"
Case 3: CategoriaFuncion = "Math & Trig"
Case 4: CategoriaFuncion = "Statistical"
Case 5: CategoriaFuncion = "Lookup & Reference"
Case 6: CategoriaFuncion = "Database"
Case 7: CategoriaFuncion = "Text"
Case 8: CategoriaFuncion = "Logical"
Case 9: CategoriaFuncion = "Information"
Case 10: CategoriaFuncion = "Commands"
Case 11: CategoriaFuncion = "Customizing"
Case 12: CategoriaFuncion = "Macro Control"
Case 13: CategoriaFuncion = "DDE/External"
Case 14: CategoriaFuncion = "User Defined default"
Case 15: CategoriaFuncion = "Engineering"
Case Else: CategoriaFuncion = CategoriaFuncion
End Select
'Informacion para que el usuario sepa que se agrego los datos de la nueva funcion.
MsgBox "Mi funcion (" & NombredeFuncion & ") fue agregada satisfactoriamente a la categoria " &
NombredeMiCategoria, vbInformation, "Done"
End Sub
Paso 5:
Ingrese los valores necesarios para calcular por ejemplo el área de un
cuadrado e ingres la función en la celda C13:
Tome en cuenta que solo debe ingresar los valores que necesite, por ejemplo
para el cuadrado solo se necesitaran los valor.es de las celdas C7 y C8, en los
demás valores ingrese el cero(0)

NOTA:
Si utiliza herramienta para insertar función podrá observar los detalles asignados a las
propiedades de la función nueva.
Los procedimientos creados en el paso 3 es una muestra de que los códigos se

pueden crear en bloques para que su mantenimietno y entendimiento sea mas
efectivo.

Aprender a utilizar parámetros en una función.
Una de las herramientas más importantes en cualquier lenguaje de

programación son las funciones. Una función es un conjunto de instrucciones
que a lo largo del programa van a ser ejecutadas multitud de veces. Es por ello,
que este conjunto de instrucciones se agrupan en una función. Las funciones
pueden ser llamadas y ejecutadas desde cualquier punto del programa.
Además, una función puede recibir parámetros externos de los cuales dependa
el resultado de dicha función. Es decir, según el parámetro o parámetros con
los que se invoque a la función, ésta devolverá un resultado u otro.
Las funciones deben estar definidas antes de realizar la llamada a la función
(como es lógico).
Sintaxis general para declarar una función:

function nombre (parámetro1, parámetro2, …, parámetroN) {
instrucción1
instrucción2
.
Instrucción N
}
Para llamar (hacer que se ejecute) la función usaremos esta sintaxis: nombre
(parámetros);
Definición de parámetro.
Un parámetro es una orden o valor que se le pasa a la función y esta variará su
comportamiento. Por ejemplo se puede crear un a función que se llame
"NombreDeUsaurio($id);", esta función cuando sea llamada se le pasará un
valor numérico dentro de la variable $id y la función dependiendo de este
identificador de usuario retornará un nombre u otro valor.
Ejemplo:
Se escribe dentro de la programación:
Buenos días usuario NombreDeUsaurio(48022).

Esto mostrará:
Buenos días usuario "Diaz"
Las Funciones retornan valores o no. Si el usuario 1456 no hubiese sido

encontrado en la base de datos la función no hubiese retornado nada o el
programador podría haber previsto esto y mostrar un mensaje de error o
advertencia (usuario 48022 no ha sido encontrado).
NOTA:
Diferencia entre parámetro y argumento en programación
En general las palabras argumento y parámetro son tomadas como sinónimos; en realidad hay
diferencia: los parámetros aparecen en la definición del procedimiento, los argumentos
aparecen en los llamados a procedimientos.
Ejemplo de función en entorno web (PHP)

Escriba ahora este código en un bloc de notas y guárdelo con el nombre de
archivo como “ejemplo1.php”. A continuación, suba el fichero a un servidor de
pago, gratuito o local y visualice el resultado.
<?php //Ejemplo funciones 1

function mostrarTexto($texto) {
echo "<strong>El texto a mostrar es el siguiente: </strong>";
echo $texto;
}
mostrarTexto("Me gusta mucho la web de aprenderaprogramar.com");
?>
RESULTADO:
En este ejemplo hemos visto cómo hemos definido una función cuyo nombre es
mostrarTexto. Esta función espera un parámetro cuando es invocada
(parámetro que se ha denominado $texto). Una vez se ejecuta, la función
ejecuta una serie de instrucciones y devuelve el control al punto desde el que
fue invocada.

La utilidad fundamental de las funciones es no tener que repetir partes de

código comunes, que sería necesario repetir varias veces. Esas partes de
código comunes se agrupan en funciones y simplemente llamaremos a la
función cada vez que necesitamos ejecutar ese código. De esta manera,
evitamos la repetición que hace más largo y difícil de entender un programa o
desarrollo web.
Analizar las normas generales de uso de parámetros.

Ejemplo 1:
Crear un archivo de Excel y diseñar la siguiente hoja.
Habilitar el editor de vba, insertar un modulo y crear la siguiente función.
Public Function Descuento(Precio, porcentaje As Double)

Descuento = Precio - (porcentaje / 100 * Precio)
End Function
Ingresar la función y darle los parámetros que necesita para calcular el nuevo
precio final.
Tambien puede utilizar la herramienta para insertar función de Excel.

Ejemplo 2:
Crear un archivo de Excel y diseñar la siguiente hoja.
Habilitar el editor de vba, insertar un modulo y crear la siguiente función.
Ingrese la función en la celda B2 utilizando la función CalculaImpuesto, la cual

recibirá como parámetro el Monto y devolverá el igv.
Explicacion de la función CalculaImpuesto:

Todas las funciones que creemos se deben colocar entre las secciones
“Function …. End Function“, para este caso CalculaImpuesto, es el nombre de
nuestra función y será el nombre que ocupemos para llamarla en nuestra hoja
de calculo. La sección “(Valor As Double)” indica que la función recibe un
parámetro (o valor) de tipo Double y con nombre Valor (Double es un tipo de
datos numérico e indica que contendrá un numero posiblemente con
decimales), la parte As Double, indica que el resultado de la formula también
sera de tipo Double.
Dim calculo As Double, declara una variable llamada calculo y que sera de tipo
double, la linea calculo = Valor * 0.18, realiza el calculo de la formula
multiplicando por 0.13 el valor que se recibe como parámetro y lo almacena en

la variable Calculo. Finalmente en la linea CalculaImpuesto = calculo, indica

que la función regresa el valor almacenado en la variable calculo (esto es el
resultado Valor * 0.13).
NOTA:
Un parámetro representa un valor que el procedimiento espera que se transfiera cuando es
llamado. La declaración del procedimiento define sus parámetros.
Cuando se define un procedimiento Function o Sub, se especifica una lista de parámetros entre
paréntesis que va inmediatamente después del nombre de procedimiento. Para cada
parámetro, se especifica un nombre, un tipo de datos y un mecanismo para pasar argumentos.
También puede indicar que un parámetro es opcional. Esto significa que el código de llamada
no tiene que transferir un valor.
El nombre de cada parámetro actúa como una variable local en el procedimiento. El nombre del
parámetro se utiliza del mismo modo que cualquier otra variable.
Para definir un parámetro de procedimiento.

1. En la declaración del procedimiento, agregue el nombre de parámetro a la
lista de parámetros del procedimiento, separándolo de otros parámetros
mediante comas.
2. Decida el tipo de datos del parámetro.
3. Inserte una cláusula As después del nombre de parámetro para especificar
el tipo de datos.
4. Decida el mecanismo para pasar los argumentos que desea para el
parámetro. Normalmente los parámetros se transfieren por valor, a menos
que desee que el procedimiento pueda cambiar su valor en el código de
llamada.
5. Anteponga ByVal (Visual Basic) o ByRef (Visual Basic) al nombre del
parámetro para especificar el mecanismo para pasar argumentos.
6. Si el parámetro es opcional, anteponga Optional (Visual Basic) al mecanismo
para pasar argumentos y, detrás del tipo de datos del parámetro, incluya un
signo igual (=) y un valor predeterminado.
En el ejemplo siguiente se define el esquema de un procedimiento Sub con tres

parámetros. Los dos primeros parámetros son obligatorios, mientras que el
tercero es opcional.
Las declaraciones de parámetros están separadas en la lista de parámetros
mediante comas.
Sub updateCustomer(ByRef c As customer, ByVal region As String,

Optional ByVal level As Integer = 0)
' Insert code to update a customer object.

End Sub
Ejemplo en Visual Basic
CONSTRUIR UN PROCEDIMIENTO UTILIZANDO VARIABLES LOCALES Y

GLOBALES.
ÁMBITO DE LAS VARIABLES.

El ámbito de una variable determina el módulo y el procedimiento en el que se
puede usar una variable.
Ámbito Cómo se declara una variable en este

ámbito
Un procedimiento Incluye instrucciones Dim, Static o Private dentro del

procedimiento.
Al nivel de módulo Incluye una instrucción Dim antes del primer procedimiento de un
módulo.
Todos los módulos Incluye una instrucción Public antes del primer procedimiento de
un módulo.
Variables Locales.
Las variables Locales son aquellas que se declaran dentro de un módulo o
procedimiento y sólo pueden ser utilizadas en éste.
Éstas dejan de existir una vez que el procedimiento termina su ejecución. Se
pueden usar en otros módulos o procedimientos pero sus características nada
tienen que hacer con la declaración dada en otro módulo o procedimiento.
Para declararlas se debe usar la sentencia DIM.
Por ejemplo:
Sub procedimiento()
Dim nDat As Integer
Dim Cadena As String
Sentencias ....
End Sub

Variables a nivel de módulo.

Algunas veces se deseará que una variable esté disponible para todos los
procedimientos de un módulo. Para ello, se declara la variable antes del primer
procedimiento del módulo (fuera de cualquier procedimiento o función).
DIM fecha As Date

Sub Dias()
´Aquí va el código
End Sub
Sub Meses()
End Sub
Variables Public.
Para que una variable esté disponible para todos los procedimientos de un
proyecto de VBA, se declara la variable a nivel de módulo con el uso de la
palabra public.
Public InteresAnual as Long
Variables Static.
Las variables estáticas son un caso especial. Se declaran a nivel de
procedimiento y retienen su valor después de que el procedimiento finaliza.
Sub Ejemplo()
Static Counter As Integer
End Sub
Procedimientos.
Un procedimiento está formado por un conjunto de sentencias que permite
resolver un problema. Un módulo está formado por uno o más procedimientos.
Un procedimiento se declara a través de la sentencia Sub y puede ser Privado,
Público o Estático.

Procedimiento Privado.
Un procedimiento privado sólo es accesible por otros procedimientos dentro del
mismo módulo. Su sintaxis es:
Private Sub Procedimiento (Argumento1,Argumento2,.....)

[sentencias]
End Sub
Procedimiento Público.
Un procedimiento público es accesible por todos los procedimientos de todos
los módulos VBA de un proyecto, su sintaxis es:
Public Sub Procedimiento(Argumento1,Argumento2,.....)

[Sentencias]
End Sub
Procedimiento Estático.
Para que las variables de un procedimiento se conserven una vez terminada su
ejecución, éste debe definirse como Estático:
Static Sub Procedimiento(Argumento1,Argumento2,.....)

[Sentencias]
End Sub
La sentencia Sub y End Sub son obligatorias al definir cualquier procedimiento.

Los argumentos y las sentencias Private, Public y Static son opcionales. Es
importante mencionar que al definir un procedimiento sin ninguna de las
sentencias anteriores, por defecto éste se define como Público, es decir:
Sub Procedimiento(argumento1,argumento2,.....)
[Sentencias]
End Sub

Es equivalente a:
Public Sub Procedimiento(argumento1,argumento2,.....)
[Sentencias]
End Sub
Existe una instrucción que permite terminar la ejecución de un procedimiento,

ésta es la instrucción Exit Sub. Por ejemplo, si tenemos el siguiente
procedimiento:
Sub Procedimiento(argumento1,argumento2,.....)
[Sentencias]
Exit Sub
[Sentencias]
End Sub
Llamar a un procedimiento desde otro
Para llamar a un procedimiento desde otro procedimiento, se puede utilizar la

sentencia Call o simplemente el nombre del procedimiento. Por ejemplo:
Sub Proced1 (Argumento1,Argumento2,.....)

[Sentencias]
Proced2
[Sentencias]
End Sub
En este caso, el procedimiento Proced1 llama al procedimiento Proced2.
La sentencia Call se utiliza cuando se requiere llamar a un procedimiento al

cual hay que pasarle un argumento, por ejemplo:
Sub Procedimiento1(argumento1,argumento2,.....)
[Sentencias]
indice= ........

Call Proced2(indice)
[Sentencias]
End Sub
En este caso, el procedimiento Procedimiento1 llama al procedimiento

Procedimiento2 al cual se le debe pasar el argumento indice.
Es recomendable utilizar siempre la sentencia Call para llamar a otro
procedimiento, aunque a éste no se le tengan que pasar argumentos, esto
permite identificar más fácilmente las llamadas a otros procedimientos.
Ejemplo para crear procedimiento con variable local.
Sub Variable_local()
Dim x As Integer, y As Integer
x=5
y = 20
MsgBox "el valor de x es " & x & _

Chr(13) & "el valor de y es " & y
End Sub
Ejemplo de ámbito de una variable local.

Sub Macro1()
Dim x As Integer
x = 10
MsgBox "x, según se ve en Macro1 es " & x
'la siguiente línea ejecuta Macro2
Macro2

End Sub
Sub Macro2()
MsgBox "x, según se ve en Macro2 es " & x
End Sub
Al ejecutar el resultado seria el siguiente:
Si modificamos el ejemplo anterior y declaramos las variables al inicio del

modulo indicando que son globales, tal como lo muestra el siguiente código:
Al ejecutar el procedimiento tendríamos las siguientes ventanas de alerta como

resultado.
Se puede apreciar que la variable tiene un alcance de todo el modulo, por tal
motivo se puede saber su valor desde la Macro1 y la Macro2.

Definir las ventajas de utilizar procedimientos y funciones.
Las ventajas y desventajas del uso de funciones y procedimientos:

Las funciones y procedimientos son dos de las herramientas de la caja de
herramientas de cada programador que le permiten escribir un código más
eficiente. Mientras que puede ser un inconveniente el uso de estas opciones de
programación, las ventajas superan con mucho cualquier desventaja. Mediante
la implementación de funciones y procedimientos en tu programa, el
programador reduce el tiempo de codificación y el tiempo de depuración,
reduciendo así el tiempo total de desarrollo.
Procedimientos y funciones.
Los procedimientos y funciones operan sobre
el mismo principio de escribir un pequeño
fragmento de código que se puede llamar, en
lugar de escribir el mismo código en varios
lugares en tu programa. Esta práctica, por lo
menos, reduce el tamaño del programa, y
normalmente mejora la legibilidad del
programa.
La mayoría de los lenguajes de programación

contienen funciones incorporadas, y apoyan la capacidad para crear
procedimientos y funciones en tu código.
Reducción del tiempo de codificación.

Una ventaja de utilizar funciones y
procedimientos es que el tiempo de
codificación se reduce.
Si sólo tienes que escribir una rutina una
vez y sentencias de código que la llaman, te
ahorras tiempo de codificación de la misma
rutina varias veces, incluso si optas por
cortar y pegar la rutina. La reducción del
tiempo de codificación ayuda a reducir el tiempo de entrega del proyecto.

Reducción del tiempo de depuración.

Además de reducir el tiempo de programación,
utilizar procedimientos y funciones ayuda a
reducir el tiempo de depuración.
Cuando se pone el mismo código en varios
lugares, a veces es difícil hacer cambios de
depuración en todos esos lugares.
Si hace el cambio a un solo lugar, pero no lo

hace en los otros dos lugares, es fácil
confundirse. Esto hace que sea difícil encontrar
el problema y eliminarlo de todos los lugares del
programa.
Efectos de mantenimiento.
Los efectos sobre el mantenimiento del
programa, que es la más costosa de las etapas
de desarrollo, pueden ser tanto buenos como
malos.
Al igual que con la depuración, si el problema se

encuentra en un procedimiento llamado,
entonces puedes encontrarlo una vez y
eliminarlo rápidamente. Sin embargo, si el
programador que escribió el código, usó procedimientos y funciones en exceso,
el programa puede ser más difícil de entender. Entre más difícil sea de
entender, más tiempo se necesita para arreglar un programa.
Utilizar la recursividad en el uso de procedimientos y funciones.

Crear funciones y procedimientos por separado puede ser muy útil cuando
necesitamos organizar y reutilizar procesos asi como también optimizar el
tiempo de mantenimento del mismo.
La programación modular es un paradigma de programación que consiste en
dividir un programa en módulos o subprogramas con el fin de hacerlo más
legible y manejable.

Programacion Modular.
Se presenta históricamente como una evolución de la programación
estructurada para solucionar problemas de programación más grandes y
complejos de lo que ésta puede resolver.
Al aplicar la programación modular, un problema complejo debe ser dividido en
varios subproblemas más simples, y estos a su vez en otros subproblemas más
simples. Esto debe hacerse hasta obtener subproblemas lo suficientemente
simples como para poder ser resueltos fácilmente con algún lenguaje de
programación.
Un módulo es cada una de las partes de un programa que resuelve uno de los
subproblemas en que se divide el problema complejo original. Cada uno de
estos módulos tiene una tarea bien definida y algunos necesitan de otros para
poder operar. En caso de que un módulo necesite de otro, puede comunicarse
con éste mediante una interfaz de comunicación que también debe estar bien
definida.
Si bien un módulo puede entenderse como una parte de un programa en
cualquiera de sus formas y variados contextos, en la práctica se los suele
tomar como sinónimos de procedimientos y funciones. Pero no necesaria ni
estrictamente un módulo es una función o un procedimiento, ya que el mismo
puede contener muchos de ellos, no debe confundirse el término "modulo" (en
el sentido de programación modular) con términos como "función" o
"procedimiento", propios del lenguaje que lo soporte.
Orígenes de la programación estructurada.

A finales de los años 1970 surgió una nueva forma de programar que no
solamente daba lugar a programas fiables y eficientes, sino que además
estaban escritos de manera que facilitaba su mejor comprensión, no sólo
proveyendo ventajas durante la fase de desarrollo, sino también posibilitando
una más sencilla modificación posterior.
El teorema del programa estructurado, propuesto por Böhm-Jacopini,
demuestra que todo programa puede escribirse utilizando únicamente las tres
instrucciones de control siguientes:
 Secuencia.
 Instrucción condicional.
 Iteración (bucle de instrucciones) con condición al principio.
Solamente con estas tres estructuras se pueden escribir todos los programas y
aplicaciones posibles. Si bien los lenguajes de programación tienen un mayor
repertorio de estructuras de control, éstas pueden ser construidas mediante las
tres básicas citadas.

Ventajas de la programación estructurada.
Ventajas de la programación estructurada

comparada con el modelo anterior (hoy
llamado despectivamente código
espagueti).
Los programas son más fáciles de
entender, pueden ser leídos de forma
secuencial y no hay necesidad de hacer
engorrosos seguimientos en saltos de
líneas (GOTO) dentro de los bloques de
código para intentar entender la lógica.
La estructura de los programas es clara, puesto que las instrucciones están
más ligadas o relacionadas entre sí.
Reducción del esfuerzo en las pruebas y depuración. El seguimiento de los
fallos o errores del programa ("debugging") se facilita debido a su estructura
más sencilla y comprensible, por lo que los errores se pueden detectar y
corregir más fácilmente.
Reducción de los costos de mantenimiento. Análogamente a la depuración,
durante la fase de mantenimiento, modificar o extender los programas resulta
más fácil.
Los programas son más sencillos y más rápidos de confeccionar.
¿Por qué descomponer un problema en partes?
Experimentalmente está comprobado que:

Un problema complejo cuesta más de resolver que otro más sencillo (de
Perogrullo).
La complejidad de un problema global es mayor que el valor de las

complejidades de cada una de sus partes por separado.
Según esto, merece la pena el esfuerzo de dividir un problema grande en

subproblemas más pequeños. Si el objetivo es elaborar un programa para
resolver dicho problema grande, cada subproblema (menos complejo) podrá
ser resuelto por un módulo (subalgoritmo) relativamente fácil de implementar
(más que el programa global No dividido).

NOTA
Programacion recursiva.
En programación avanzada se dice que algo es recursivo si se define en función de sí mismo o
a sí mismo. También se dice que nunca se debe incluir la misma palabra en la definición de
ésta.
El caso es que las definiciones recursivas aparecen con frecuencia en matemáticas, e incluso
en la vida real. Un ejemplo: basta con apuntar una cámara al monitor que muestra la imagen
que muestra esa cámara. El efecto es verdaderamente curioso, en especial cuando se mueve
la cámara alrededor del monitor.
Por otra parte, la recursividad también puede ser indirecta, si tenemos un procedimiento P que
llama a otro Q y éste a su vez llama a P. También en estos casos debe haber una condición de
parada.
En el siguiente procedimiento se utiliza la recursividad para calcular el factorial de su

argumento original.
Function factorial(ByVal n As Integer) As Integer

If n <= 1 Then
Return 1
Else
Return factorial(n - 1) * n
End If
End Function
Codigo en Visual Basic
1. ¿En que consiste un parámetro en programación?
2. ¿Qué criterios se deben de tomar en cuenta al momento de crear un

parametro?
3. ¿Cuál es la ventaja de utilizar funciones en un sistema?
4. ¿En que consiste la programación modular?
5. Elabore un caso práctico donde utilice más de una función.

Fundamentos de Programación PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Fundamentos de Programación PDF

Cargado por

Copyright:

Formatos disponibles

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 5

FUNDAMENTO TEÓRICO ...................................................................................................................... 128

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 6

 Establecer los fundamentos de programación.

" Culminar tus estudios es como correr en una prueba de

 Computadora con microprocesadores core 2 Duo ó de mayor capacidad.

 Establecer los fundamentos de programación.

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 7

Un programa es un conjunto de órdenes para un ordenador.

Estas órdenes se le deben dar en un cierto lenguaje, que el ordenador sea

El problema es que los lenguajes que realmente entienden los ordenadores

Por eso, en la práctica se emplean lenguajes más parecidos al lenguaje

Puedes sentarte, llorar y esperar a que alguien programe esa aplicación... o

Tu ordenador es una máquina que acepta y ejecuta órdenes. Estas órdenes

Ordenador, quiero que me bajes esa caja de la estantería, la roja a la derecha.

No lo entenderá. En cambio, si escribes algo así, puede que te preste atención:

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 8

Organizadas en párrafos especiales, todas las líneas de órdenes conforman lo

Como los idiomas naturales, también los lenguajes de programación tienen su

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 9

Las máquinas solo hablan con

SWI "OS_WriteS" EQUS "Hola" EQUB 0 ALIGN MOV PC,R14

Te estarás preguntando quién puede preferir Ensamblador frente a otros

Hay cientos de lenguajes de programación, y, al igual que ocurre con los

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 10

Aprender a programar es un objetivo que se

El problema para los no iniciados es muchas veces que la programación es un

Frente a esta situación, y para todos aquellos que quieren empezar a

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 11

Vamos a reflexionar sobre lo que consideramos son opciones adecuadas y

a) Aprender con un libro ó con apuntes de

b) Realizar un curso sobre fundamentos de programación: consideramos

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 12

c) Realizar estudios oficiales en el área de informática – programación:

d) Empezar a programar directamente con un lenguaje o entorno (Java,

e) Aprender a programar apoyándonos en un sitio web de confianza:

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 13

f) Otras vías: aprender con un amigo, familiar,

Cuando encendemos una computadora el circuito de control llamado BIOS

Algunos de los componentes de vital importancia que son revisados son:

Pasado el POST, el BIOS tiene como función la búsqueda de un sistema de

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 14

El software es un término genérico para los programas que funcionan en el

El hardware es también un término genérico para todos los componentes

Las computadoras están integrados por una serie de componentes electrónicos

• Unidad central de procesos (CPU): es el cerebro del PC.

• Memoria RAM o memoria principal: es la memoria

• Memoria ROM: es la memoria solo para lectura. Es la

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 15

permiten iniciar el funcionamiento cada vez que se enciende la computadora.

• Disco duro: es el dispositivo de almacenamiento

• Caché: es una unidad pequeña de memoria ultrarápida

• Tarjeta madre: es la tarjeta de circuitos que

• CD-ROM - DVD-ROM: esta unidad sirve para leer

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 16

tasa de transferencia de datos y el tiempo de

Cómo funciona un procesador.

El microprocesador, o simplemente procesador, es el circuito integrado central

El procesador es un circuito integrado constituido por millones de componentes

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 17

Desde el punto de vista funcional es, básicamente, el

Esta unidad central de procesamiento está constituida,