manual de aprendizajevirtual.senati.edu.pe/curri/file_curri.php/curri/prcd/89001536... · aprender...

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL

MANUAL DE APRENDIZAJE

CÓDIGO: 89001536

Profesional Técnico

FUNDAMENTOS DE

PROGRAMACIÓN

COMPUTACIÓN E

INFORMÁTICA

FUNDAMENTOS DE PROGRAMACIÓN

ESCUELA DE TECNOLOGÍAS DE LA INFORMACIÓN 5

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 FUNDAMENTO TEÓRICO ........................................................................................................................ 58 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 FUNDAMENTO TEÓRICO ........................................................................................................................ 80 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



FUNDAMENTO TEÓRICO ...................................................................................................................... 128 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 FUNDAMENTO TEÓRICO ...................................................................................................................... 157 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 FUNDAMENTO TEÓRICO ...................................................................................................................... 195 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



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.

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:


Analizar las computadoras y su programación.



" 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.

01



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".



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.

Las máquinas solo hablan con ceros y unos, un lenguaje incomprensible para un humano



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.

http://www.profesormolina.com.ar/electronica/componentes/int/comp_log/image002.png



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:


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.

http://www.okpedia.es/computadora



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.




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.


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.

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?

Ejercicios y tareas de investigación



TAREA 02: ANALIZAR LA ESTRUCTURA GENERAL DE UN

PROGRAMA.


Definir el concepto y partes de un programa.

Elaborar la documentación de un programa.




Acceso a internet.


Orden de Ejecución:



02

" Un fracaso es sólo una cicatriz, un mapa hacia la

victoria...”……. ANONIMO.



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.


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.



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

Aquí aprenderás a comunicarte con el usuario a través de las interfaces de usuario los cuales tienen unos procedimientos que te

Estructura de un programa

En esta parte se define el orden en el que se escriben, en qué consisten, cuáles son obligatorias y cuáles no, cómo se relacionan



permiten leer y escribir datos en la salida y entrada estándar respectivamente.

unas con otras, etc.

Sentencias y expresiones

Los operadores se utilizan para construir expresiones que calculan valores; las expresiones son los componentes centrales de las sentencias; las sentencias se pueden agrupar en bloques.

Variables y constantes

Constantes: Tienen un valor fijo que se le da cuando se define la constante y que ya no puede ser modificado durante la ejecución.

Variables: El valor puede cambiar durante la ejecución del algoritmo, pero nunca varía su nombre y su tipo.

Control del flujo

En esta parte aprenderá a que sus programas puedan variar el orden de su ejecución si se cumplen ciertas condiciones (sentencias selectivas). Y también aprenderá a repetir algo varias veces (sentencias iterativas).

Tipos de datos

Es uno de los conceptos fundamentales de cualquier lenguaje de programación. Estos definen los métodos de almacenamiento disponibles para representar información, junto con 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


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

http://www.monografias.com/trabajos11/basda/basda.shtml



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.




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




Acceso a internet.





Elaborar diagramas de flujo.

Construir Pseudocodigos

03

" El triunfo del verdadero hombre surge de las cenizas del

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



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

y B

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

y C

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





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.


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

Terminal

Representa el inicio y fin de un programa.

También puede representar una parada o

interrupción programada que sea necesaria

realizar en un programa.

Entrada / salida

Cualquier tipo de introducción de datos en

la memoria desde los periféricos o registro

de información procesada en un periférico.

Proceso

Cualquier tipo de operación que pueda

originar cambio de valor, formato o posición

de la información almacenada en memoria,

operaciones aritméticas, de

transformaciones, etc.

Decisión

Indica operaciones lógicas o de

comparación entre datos (normalmente

dos) y en función del resultado de la misma

determina (normalmente si y no) cual de los

distintos caminos alternativos del programa

se debe seguir

Conector

Misma Página

Sirve para enlazar dos partes cualesquiera

de un diagrama a través de un conector en

la salida y otro conector en la entrada. Se

refiere a la conexión en la misma pagina del

diagrama

Indicador de

dirección o

línea de flujo

Indica el sentido de la ejecución de las

operaciones

Salida

Se utiliza en ocasiones en lugar del símbolo

de salida. El dibujo representa un pedazo

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.




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




Acceso a internet.






Desarrollar casos prácticos de programación.

04

" Antes que toda otra cosa la preparación es la clave para el éxito.....”……. Alexandre Graham Bell.



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.



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:



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.




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.




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.




Acceso a internet.







05

" El fracaso es una parte importante del éxito......” Anonimo.



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

Aritméticos

Operadores de

comparación

Operaciones de

concatenación

Operadores

lógicos

Operador ^ < (Menor que) & Operador And

Operador * <= (Menor o

igual que) + Operador Eqv

Operador / > (Mayor que) Operador Imp

Operador \ >= (Mayor o

igual que) Operador Not

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.



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

almacenamiento

Intervalo

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)

Entero largo de 4

bytes

-2,147,483,648 a 2,147,483,647

Single

(coma flotante/

precisión simple)

Decimal de 4 bytes -3,402823E38 a –1,401298E-45 para

valores negativos; 1,401298E-45 a

3,402823E38 para valores positivos

Double

(coma flotante/

precisión doble)

Decimal de 8 bytes -1.79769313486231E308 a

-4,94065645841247E-324 para valores

negativos; 4,94065645841247E-324 a

1,79769313486232E308 para valores

positivos

Currency

(entero a escala)

Entero de 8 bytes -922.337.203.685.477,5808 a

922.337.203.685.477,5807

Decimal Números reales con

decimales hasta de

28 dígitos (14 bytes)

+/-

79.228.162.514.264.337.593.543.950.335

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

8 bytes

1 de enero de 100 a 31 de diciembre de

9999

Object 4 bytes Cualquier referencia a tipo Object

String

(longitud

variable)

Usado para datos de

texto de 10 bytes

Desde 0 a 2.000 millones



String

(longitud fija)

Como el anterior pero

de longitud fija

Desde 1 a 65.400 aproximadamente

Variant

(con números)

Usado como tipo de

dato genérico de 16

bytes

Cualquier valor numérico hasta el

intervalo de un tipo Double

Variant

(con caracteres)

22 bytes + longitud de

la cadena

El mismo intervalo que para un

tipo String de longitud variable

Definido por el

usuario

(utilizando Type)

Número requerido por

los elementos

El intervalo de cada elemento es el

mismo que el intervalo de su tipo de

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 As String

Usados para contener datos literales

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.


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




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

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_JavaScript/Palabras_reservadas#function

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_JavaScript/Palabras_reservadas#return



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


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

OR

NOT

Producto lógico (y)

Suma lógica (0)

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

Verdadero

Verdadero

Falso

Verdadero

Falso

Verdadero

Falso

Falso

Falso

Varadero

Ejemplo: si a = 9; b = 2; c =5; d = 3

Expresión Lógica Resultado

(a > b) AND (b<= c)

{V} {V} Verdadero

( C > d ) AND (c = a)

{V} {F} Falso

b = ( c – d ) AND ( a + b) > = ( c * d )

{V} {V} Verdadero

(c = 5) AND (c >b) AND (a <= d)

{F} {F} {F} Falso

(C = 5) AND (b < c) AND (a >= d)

{V} {V} {V} Verdadero

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

Verdadero

Verdadero

Falso

Verdadero

Falso

Verdadero

Falso

Verdadero

Verdadero

Verdadero



Ejemplo: si a = 9; b = 2; c =5; d = 3

Expresión Lógica Resultado

(a > b) OR (b<= c)

{V} {V} Verdadero

( C > d ) OR (c = a)

{V} {F} Falso

b = ( c – d ) OR ( a + b) > = ( c * d )

{V} {V} Verdadero

(c > 5) OR (c >b) OR (a <= d)

{F} {F} {F} Falso

(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

9) OR

Operadores

Aritmeticos

Suma Resta

Multiplicacion Division

Potenciacion Agrupar operaciones

Relacionales

< Menor que > Mayor que

= Igual a <= Menor o igual que >= Mayor o igual que

<> Distinto de

Logicos

NOT AND OR



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.




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.




Acceso a internet.



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.

06

"No hay secretos para el éxito. Este se alcanza preparándose, trabajando arduamente y aprendiendo del fracaso......”……. Colin Powell.



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.

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.

Ventana de edición.

Barra de herramientas.

Botones de objetos Subprogramas

Zoom Depuración

Ejecución



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".




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.




Acceso a internet.





Construir un procedimiento utilizando variables locales y globales.


Utilizar la recursividad en el uso de procedimientos y funciones.

07

"No hay secretos para el éxito. Este se alcanza preparándose, trabajando arduamente y aprendiendo del fracaso..........” Colin Powell.



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 [email protected]

'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.





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.


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.




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.


manual de aprendizajevirtual.senati.edu.pe/curri/file_curri.php/curri/prcd/89001536... · aprender...

Documents