leanelshark

EN ESTE POST SE ENSEÑARA A REALIZAR LOS COSTOSOS INFORMES DE LECTURA PARA LOGRAR APROBAR ESOS EXAMENES DE LA UNIVERSIDAD DE LA MATANZA... ESPERO Q LES SEA DE AYUDA... SEMINARIO DE COMPRENSIÓN Y PRODUCCIÖN DE TEXTOS AL comenzar un Informe de Lectura (IL) lo primero que debemos hacer es olvidarnos de la primera persona. ya sea (yo, me , mi ,etc. ) No debemos decir EL TEXTO NOS DICE, EL TECTO NOS HABLA, etc... YA QUE EL TEXTO NO PUEDE HABLAR NI TAMPOCO DECIR NADA... es el autor quien nos dice y quien nos transmite las cosas. Esos consejos son basicos... ahora les escribire los pasos de la lectura critica....lo cual nos guiara a la hora de realizar un buen informe de lectura... LECTURA CRITICA 1) Lectura global, comenzando por los paratextos (titulos,subtitulos,fechas y lugares de publicacion). EN ESTA PARTE NOS DEBEMOS PREGUNTAR : ¿De qué trata el texto? 2)Lectura por partes/ por parrafos. EN ESTA PARTE NOS DEBEMOS PREGUNTAR: ¿Cuál es el subtema o el aspecto del tema general?. Tambien debemos subrayar ideas importantes, hacer anotaciones en los margenes (la profe me dijo que la evaluacion es nuestra...ellos no se fijan en lo que surayamos o lo que escribimos en los margenes sino en lo que escribimos y como lo escribimos) 3)Si el texto es argumentativo deberemos: buscar la hipotesis/ tesis del autor /la idea central con la posicion que afirma/ argumentos que sostiene y demas. GENEROS DISCURSIVOS Bueno esto de lo que tanto se habla durante la cursada es lo sigiente ... Son formas de comunicación o gérneros. Ej: discursos políticos, religiosos, publicitarios, cientificos, academicos, etc.etc.etc. A su vez se dividen en otras partes. DISCURSO PERIODISTICO------/ se divide en: articulo de opinion, cronicas, reportajes, el editorial, la entrevista DISCURSO ACADEMICO--------/ monografias, articulo academico, tesis, informe de lectura, manual MANERA DE DIFERENCIARLOS se pueden diferenciar mediante SU TEMA: es decir el asunto que desarrolla ( un articulo periodistico no te va a hablar de la celula eucariota por ejemplo) SU ESTILO VERBAL: tipo de enunciacion ( esto se refiere a la clase de palabras que se utilizan, si son faciles de comprender es obvio que es periodistico ya que la funcion de los articulos periodisticos es que las personas se enteren de algo... y para ello no usaran palabras que nadie entienda. DE lo contrario si usan palabras dificiles ahi estariamos hablando de un discurso academico, echo por profesionales para profesionales o de un maestro para su alumno) SU ESTRUCTURA: forma que se organiza la informacion ( bue este es facil de entender) TAMBIEN SE PUEDE DIFERENCIAR POR: LOS TEMAS ACTUALES---- los periodicos SON TEMAS DE ACTUALIDAD Y DE INTERES GENERAL PARA LA GENTE...EN CAMBIO LOS ACADEMICOS son temas vinculados a las disciplinas cientificas y echos para especialistas o aspirantes a serlo GERUNDIO UNO DE LOS ERRORES MAS GRANDES QUE SE COMETEN EN LOS IL ES LA UTILIZACION DE GERUNDIOS... ES DECIR DE LAS PALABRAS TERMINADAS EN "ANDO" Y "ENDO" NO LOS USEN NUNK redonden con otras palabras o cambien todo, diganlo de otra forma en la que no los usen!!! CLASIFICACION DE GENEROS EXTERNOS-------//// condiciones de produccion y circulacion, finalidad, si es o no masivo INTERNOS-------//// tema, estructura, y estilo verbal AHORA SI COMO CONSTRUIR EL INFORME DE LECTURA INTRODUCCIÓN: 1) presentación del autor, presentación de texto, tema general, 2)tipo de texto, y su genero 3)cual es la intención del texto/ cual es su finalidad/ cual es su propósito 4) Hipótesis del autor/ su perspectiva/ su punto de vista/ su opinión (SI ES QUE TIENE) 5)ponerle y ubicar la dentro de un MARCO TEÓRICO O CAMPO DISCIPLINAR (político, sociopolitico, socioeconomico, social, etc) 6)y finalmente antes de empezar el desarrollo poner EL PUNTO DE VISTA NUESTRO osea del informante un ej podría ser: "el autor logra en su articulo" "Brindando sólidos y veraces argumentos" osea todas cosas que califiquen el texto o su contenido... así demostramos nuestro punto de vista. DESARROLLO: 1) síntesis de las ideas centrales ( macrroestructura + delegación de la vos ) 2) reformular todo ( no sacar textual las cosas del texto para hacerlo propio, de lo contrario seria un resumen y no un IL ) 3)usar un registro académico, no usar palabras mochas por asi decirlo, usar un lenguaje correcto y adecuado al ámbito académico 4)vuelvo a repartir usar tercera persona, nunca usar la primera ni la segunda... 5)describir y evaluar los argumentos utilizados por el autor, demostrando su punto de vista sobre la situación. 6)describir también las herramientas estratégicas que usa, su estructura. CONCLUSIÓN: 1)retoma el tema central 2)no agregar nunca ideas nuevas 3)no agregar argumentos nuevos BUE AHI CONCLUYE SUS PARTES!!! SEGUIMOS CON : DELEGAR LA VOS este termino se refiere a que nosotros debemos siempre mencionar al autor en nuestro IL podemos usar para ello los sigientes terminos: "segun él", "el autor sostiene que", "el autor afirma que"," apellido o nombre del autor" o para mencionar el texto y no al autor usar los siguientes segun corresponda: "se afirma que", "se compara" , "en este articulo se describe" , "en este articulo se plantea", o ambos: "en este texto, el autor analiza/describe/sintetiza/desarrolla/ect." o para mencionar la finalidad del articulo: "para ello", "con el fin de", "su finalidad es" BIBLIOGRAFÍA: con esto se inicia cada informe de lectura, es una breve descripción de que vamos a leer, de donde se extrajo, cuando se publico, quien lo publico, etc. APELLIDO,NOMBRE DEL AUTOR. "titulo de lo que leemos", donde se publicó. Cuando se publico ejemplos: Ramonet, Ignacio."informarse cuesta", en Le Monde Diplomatique en español. Enero de 2006 ejemplo 2: Miranda, MIriam. "Las recetas de desarrollo de los organismos internacionales", en Revista América Latina en movimiento. 15 de Julio de 2008 BUE ESPERO Q LES SIRVA ....ME FALTARON AGREGAR COSAS PERO NO TENGO TIEMPO AHORA DE SEGUIR ESCRIBIENDO!!!!CHAU!!! SUERTE EN LOS EXAMENES!!!

EN ESTE POST SE ENSEÑARA A REALIZAR LOS COSTOSOS INFORMES DE LECTURA PARA LOGRAR APROBAR ESOS EXAMENES DE LA UNIVERSIDAD DE LA MATANZA... ESPERO Q LES SEA DE AYUDA... SEMINARIO DE COMPRENSIÓN Y PRODUCCIÖN DE TEXTOS AL comenzar un Informe de Lectura (IL) lo primero que debemos hacer es olvidarnos de la primera persona. ya sea (yo, me , mi ,etc. No debemos decir EL TEXTO NOS DICE, EL TECTO NOS HABLA, etc... YA QUE EL TEXTO NO PUEDE HABLAR NI TAMPOCO DECIR NADA... es el autor quien nos dice y quien nos transmite las cosas. esos consejos son basicos... ahora les escribire los pasos de la lectura critica....lo cual nos guiara a la hora de realizar un buen informe de lectura... LECTURA CRITICA 1) Lectura global, comenzando por los paratextos (titulos,subtitulos,fechas y lugares de publicacion). EN ESTA PARTE NOS DEBEMOS PREGUNTAR : ¿De qué trata el texto? 2)Lectura por partes/ por parrafos. EN ESTA PARTE NOS DEBEMOS PREGUNTAR: ¿Cuál es el subtema o el aspecto del tema general?. Tambien debemos subrayar ideas importantes, hacer anotaciones en los margenes (la profe me dijo que la evaluacion es nuestra...ellos no se fijan en lo que surayamos o lo que escribimos en los margenes sino en lo que escribimos y como lo escribimos) 3)Si el texto es argumentativo deberemos: buscar la hipotesis/ tesis del autor /la idea central con la posicion que afirma/ argumentos que sostiene y demas. GENEROS DISCURSIVOS bueno esto de lo que tanto se habla durante la cursada es lo sigiente ... Son formas de comunicación o gérneros. Ej: discursos políticos, religiosos, publicitarios, cientificos, academicos, etc.etc.etc. A su vez se dividen en otras partes. DISCURSO PERIODISTICO------/ se divide en: articulo de opinion, cronicas, reportajes, el editorial, la entrevista DISCURSO ACADEMICO--------/ monografias, articulo academico, tesis, informe de lectura, manual MANERA DE DIFERENCIARLOS se pueden diferenciar mediante SU TEMA: es decir el asunto que desarrolla ( un articulo periodistico no te va a hablar de la celula eucariota por ejemplo) SU ESTILO VERBAL: tipo de enunciacion ( esto se refiere a la clase de palabras que se utilizan, si son faciles de comprender es obvio que es periodistico ya que la funcion de los articulos periodisticos es que las personas se enteren de algo... y para ello no usaran palabras que nadie entienda. DE lo contrario si usan palabras dificiles ahi estariamos hablando de un discurso academico, echo por profesionales para profesionales o de un maestro para su alumno) SU ESTRUCTURA: forma que se organiza la informacion ( bue este es facil de entender) TAMBIEN SE PUEDE DIFERENCIAR POR: LOS TEMAS ACTUALES---- los periodicos SON TEMAS DE ACTUALIDAD Y DE INTERES GENERAL PARA LA GENTE...EN CAMBIO LOS ACADEMICOS son temas vinculados a las disciplinas cientificas y echos para especialistas o aspirantes a serlo GERUNDIO UNO DE LOS ERRORES MAS GRANDES QUE SE COMETEN EN LOS IL ES LA UTILIZACION DE GERUNDIOS... ES DECIR DE LAS PALABRAS TERMINADAS EN "ANDO" Y "ENDO" NO LOS USEN NUNK redonden con otras palabras o cambien todo, diganlo de otra forma en la que no los usen!!! CLASIFICACION DE GENEROS EXTERNOS-------//// condiciones de produccion y circulacion, finalidad, si es o no masivo INTERNOS-------//// tema, estructura, y estilo verbal AHORA SI COMO CONSTRUIR EL INFORME DE LECTURA INTRODUCCIÓN: 1) presentación del autor, presentación de texto, tema general, 2)tipo de texto, y su genero 3)cual es la intención del texto/ cual es su finalidad/ cual es su propósito 4) Hipótesis del autor/ su perspectiva/ su punto de vista/ su opinión (SI ES QUE TIENE) 5)ponerle y ubicar la dentro de un MARCO TEÓRICO O CAMPO DISCIPLINAR (político, sociopolitico, socioeconomico, social, etc) 6)y finalmente antes de empezar el desarrollo poner EL PUNTO DE VISTA NUESTRO osea del informante un ej podría ser: "el autor logra en su articulo" "Brindando sólidos y veraces argumentos" osea todas cosas que califiquen el texto o su contenido... así demostramos nuestro punto de vista. DESARROLLO: 1) síntesis de las ideas centrales ( macrroestructura + delegación de la vos ) 2) reformular todo ( no sacar textual las cosas del texto para hacerlo propio, de lo contrario seria un resumen y no un IL ) 3)usar un registro académico, no usar palabras mochas por asi decirlo, usar un lenguaje correcto y adecuado al ámbito académico 4)vuelvo a repartir usar tercera persona, nunca usar la primera ni la segunda... 5)describir y evaluar los argumentos utilizados por el autor, demostrando su punto de vista sobre la situación. 6)describir también las herramientas estratégicas que usa, su estructura. CONCLUSIÓN: 1)retoma el tema central 2)no agregar nunca ideas nuevas 3)no agregar argumentos nuevos BUE AHI CONCLUYE SUS PARTES!!! SEGUIMOS CON : DELEGAR LA VOS este termino se refiere a que nosotros debemos siempre mencionar al autor en nuestro IL podemos usar para ello los sigientes terminos: "segun él", "el autor sostiene que", "el autor afirma que"," apellido o nombre del autor" o para mencionar el texto y no al autor usar los siguientes segun corresponda: "se afirma que", "se compara" , "en este articulo se describe" , "en este articulo se plantea", o ambos: "en este texto, el autor analiza/describe/sintetiza/desarrolla/ect." o para mencionar la finalidad del articulo: "para ello", "con el fin de", "su finalidad es" BIBLIOGRAFÍA: con esto se inicia cada informe de lectura, es una breve descripción de que vamos a leer, de donde se extrajo, cuando se publico, quien lo publico, etc. APELLIDO,NOMBRE DEL AUTOR. "titulo de lo que leemos", donde se publicó. Cuando se publico ejemplos: Ramonet, Ignacio."informarse cuesta", en Le Monde Diplomatique en español. Enero de 2006 ejemplo 2: Miranda, MIriam. "Las recetas de desarrollo de los organismos internacionales", en Revista América Latina en movimiento. 15 de Julio de 2008 BUE ESPERO Q LES SIRVA ....ME FALTARON AGREGAR COSAS PERO NO TENGO TIEMPO AHORA DE SEGUIR ESCRIBIENDO!!!!CHAU!!! SUERTE EN LOS EXAMENES!!! DESPUES VOY A ESCRIBIR ALGUNAS INFORMES PARA Q LES AYUDE MAS!

LESSON 6 Present Simple (Presente del Indicativo) Se utiliza para hablar de acciones habituales, genéricas, que tienen lugar con cierta frecuencia, sin hacer referencia a si en el momento actual se están realizando. I study English. Yo estudio inglés; empecé hace algún tiempo y continúo, aunque puede que en el momento presente no esté realizando esta actividad. He plays tennis. El juega al tenis; practica este deporte con cierta asiduidad, pero no significa que en el momento presente esté en la pista de tenis jugando. I work in a bank. Yo trabajo en un banco; ésta es mi profesión, aunque puede que en el momento actual yo esté de vacaciones, descansando en mi casa. También se utiliza para hablar de acciones futuras que ya han sido planificadas, especialmente al referirse a viajes. I leave Madrid tomorrow morning. Me voy de Madrid mañana por la mañana La forma del "present simple" coincide con la del infinitivo sin la partícula "to", salvo en la 3ª persona del singular en la que se le añade una "s". Infinitivo I / you / we / they He / she / it To eat (comer) eat eats To run (correr) run runs Si el verbo termina en "ss", "sh", "ch", "x", "o", al formar la 3º persona del singular se le añade "-es". Infinitivo I / you / we / they He / she / it To kiss (besar) I kiss He kisses To watch (observar) I watch He watches Si el verbo termina en "y" tras consonante, al formar la 3ª persona del singular se sustituye esta "y" por una "i", seguida de la terminación "es". Infinitivo I / you / we / they He / she / it To carry (llevar) I carry He carries To envy (envidiar) I envy He envies Las oraciones negativas se forman con el auxiliar "to do", habitualmente en sus formas contraídas: "don´t" (= do not) para las personas "I, you, we, they", y "doesn´t" (= does not) para las personas "he, she, it". I don't play tennis. Yo no juego al tenis She doesn´t go to the cinema. Ella no va al cine We don´t know the answer. Nosotros no sabemos la respuesta La forma interrogativa se forma también con el auxiliar "to do" al comienzo de la oración ("do" con las personas "I, you, we, they"; "does" con "he, she, it". Do you play tennis? ¿ Juegas al tenis ? Does she go to the cinema? ¿ Va ella al cine ? Do we know the answer? ¿ Conocemos la respuesta ? VOCABULARIO Mesa Table Almohada Pillow Silla Chair Sábana Sheet Sofá Sofa Manta Blanket Cuadro Painting Colchón Mattress Alfombra Carpet Colcha Bedspread Espejo Mirror Mesilla de noche Bedside table Lámpara Lamp Mecedora Rocking chair Jarrón Vase PROXIMO .... PRESENTE CONTINUO..... SI TENES ALGUNA DUDA MANDA UN MP

Cómo aprender a programar y no morir en el intento – Parte 9 Nota: Como siempre, les recomendamos, si es que no lo han hecho, leer los números anteriores de esta guía, los cuales pueden ser encontrados en nuestra categoría de programación. Si recuerdan el número anterior, en esta ocasión veremos: Contenidos: Iteración Switch. Vectores. Matrices. Continuación de la confección de un terminal de venta. Así que vamos de lleno a la guía de hoy: 1.- Iteración Switch: En el número anterior, veíamos las iteraciones condicionales if y else, las cuales nos permitían tomar distintos caminos dentro de un programa, dependiendo de una condición determinada. Además, cuando veíamos los números sobre pseudo-lenguaje, conocímos una iteración llamada Switch, la cual presentaba una funcionalidad bastante similar, pero tal como explicábamos aquella vez, es bastante mejor para usar en casos determinados. El funcionamiento de esta iteración, ya lo hemos detallado en números anteriores, por lo que no adentraremos en repetir lo mismo, si no que veremos como funciona en lenguaje C. Ahora, una buena pregunta, es ¿Cuándo usar if/else y cuándo usar switch?. La verdad, es que como todo en la programación, es cosa de gustos. A pesar de que pueden haber casos en los que sea más cómodo y/o ordenado usar una iteración sobre otra, las 2 cumplen la misma funcionalidad, por lo que pueden ser usadas sin problemas. En lo personal, lo cual en ningún sentido es un estándar, prefiero usar iteraciones de tipo Switch cuando en los programas definimos algún tipo de menú, por un tema de orden. En un ejemplo más adelante podremos apreciar porque. Entonces, usando switch en C, lo primero que necesitamos es una variable que tome un valor (todo switch debe ser inicializado por una variable) y conocer los valores, o la mayoría de ellos, que pudiése tomar, como veremos en el siguiente ejemplo. Además, dentro de los casos, podemos definir un caso por defecto, el cual cubrirá todas las opciones no definidas. Esto es muy útil para prevenir que el usuario ingrese un valor que no tenemos cubierto dentro de nuestras opciones. Veamos un ejemplo. Ejemplo: Plantearemos un pequeño menú, y definiremos cada caso, utilizando una iteración de tipo switch. #include <stdlib.h> #include <stdio.h> #include <conio.h> int opcion; int main() { /* A continuación escribimos nuestro menú, tabulando y dando saltos de línea */ printf(“tMenu”); printf(“n1.- Mostrar hola mundo”); printf(“n2.- Dar los buenos dias”); printf(“n3.- Salir”); printf(“nIngrese su opcion: “); scanf(“%d”,&opcion); /* Leemos la opción que ingrese el usuario */ switch(opcion) // Activamos el switch con la variable opción. { case 1: printf(“nHola mundo”); /* En el caso que ingrese 1 */ break; case 2: printf(“nBuenos dias”); /* En el caso que ingrese 2 */ break; case 3: break; /* En el caso que ingrese 3 */ default: printf(“nOpcion no valida”); /* Caso por defecto */ break; } getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */ } Como podemos ver, al final de cada caso, debemos incluir la sentencia break;, que indicará que después de ejecutar las sentencias correspondientes al caso, se debe salir del switch. Compilamos y probamos. Ahora, como podrán apreciar, este switch solo se ejecuta una vez. En caso de que quisieramos hacerlo repetitivo hasta que se diga salir, podemos insertarlo dentro de un ciclo y poner como condición que se ejecute mientras no se seleccione la opción de salida. Así de simple es la iteración switch. Es de gran utilidad para ordenar nuestras opciones y en especial para utilizarlo con menús, así que es muy recomendable aprender a usarlo y manejarlo para los programas que vayamos a desarrollar. 2.- Vectores: Tal como veíamos en pseudo-lenguaje, en la programación existen unas variables especiales conocidas como arreglos, las cuales presentan la facultad de almacenar múltiples valores, ya sea unidimensionalmente o bidimensionalmente. Los vectores representan los primeros. En C, también podemos utilizar vectores, de la misma forma en la que los planteabamos para pseudocódigo, es decir, declarándolos y rellenándolos según su posición, así como las mismas condiciones para recorrerlos y leerlos. Tal como en todos los casos, no entraremos a repetir las definiciones que hemos hecho en guías anteriores y sólo nos preocuparemos de su uso en lenguaje C. Veamos un pequeño ejemplo, para que nos quede todo más claro: Ejemplo: Declararemos un vector, lo rellenaremos y luego mostraremos su contenido: #include <stdlib.h> #include <stdio.h> #include <conio.h> int vector[5]; // Declaramos el vector int main() { for(int i=0; i<5; i++) /* Definimos un ciclo para llenar el vector */ { printf(“nIngrese el valor de la posicion %d del vector: “,i); scanf(“%d”,&vector); /* Leemos los datos de cada posición */ } printf(“nLos valores ingresados fueron: “); /* Mostramos los valores */ for(int i=0;i<5; i++) { printf(“%dt”,vector); } getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */ } Como podemos ver, el procedimiento es el mismo que usabamos para pseudo-código, utilizando ciclos tanto para rellenar posiciones secuencialmente, como para leerlas, accediendo mediante el índice que marcamos con la variable i, que se va moviendo a lo largo del vector. Ahora, si nos fijamos en el ejemplo, podemos ver que dentro del ciclo for, hemos definido la variable i y no al principio del programa. Esto es posible en este tipo de ciclos, pero esa variable solamente vive dentro del búcle y no después (por eso la volvemos a declarar en el segundo ciclo). Esta es una gran forma de matar variables rápidamente después de su uso y no gastar espacio innecesariamente. 3.- Matrices: En el caso de las matrices, utilizamos procedimientos bastante similares a los de los vectores, salvo que, siendo arreglos bidimensionales, para recorrer una matriz necesitaremos de 2 ciclos, uno para las filas, y 1 para las columnas. La definición también varía en el número de dimensiones que declaramos. Si para los vectores hacíamos una declaración del tipo “vector [5]“ por su unidimensionalidad, para las matrices aplicamos una definición del tipo “matriz [5[[5]“, la primera relacionada con sus filas, y la 2da con sus columnas. Veamos un ejemplo para que nos quede más claro. Ejemplo: Repetiremos el ejemplo anterior, pero en este caso utilizaremos una matriz: #include <stdlib.h> #include <stdio.h> #include <conio.h> int matriz[3][3]; // Declaramos la matriz int main() { for(int i=0; i<3; i++) /* Definimos un ciclo para las filas */ { for(int j=0; j<3; j++) /* Otro ciclo para las columnas */ { printf(“nIngrese el valor para la fila %d y la columna %d: “,i,j); scanf(“%d”,&matriz); } } printf(“Los valores ingresados son:n “); for (int i=0; i<3; i++) /* Mostramos los valores ingresados, tabulando y dando salto de línea para hacer la forma de la matriz */ { for (int j=0; j<3; j++) { printf(“%dt”,matriz); } printf(“n”); } getch(); /* Ponemos el programa en pausa hasta que se presione una tecla */ } El procedimiento es el mismo, pero solo nso enfocamos en recorrer 2 dimensiones en vez de una. A medida que vayamos utilizando vectores y matrices en nuestros programas nos iremos acostumbrando cada vez más a su funcionamiento. 4.- Terminal de venta: Si recuerdan, al final del número anterior, realizamos la confección de un terminal de venta, en el cual listabamos unos productos y realizabamos una venta, especificando el vuelto correspondiente al cliente. Hoy, seguiremos trabajando sobre ese terminal, añadiendo la funcionalidad de poder vender más de un producto en una venta y de realizar más de una venta. Si recordamos, teníamos este código: include <stdlib.h> #include <stdio.h> #include <conio.h> int codigo, cantidad, valor, total, vuelto, pago; int main() { printf(“t Lista de productosn”); printf(“Codigot Nombret Precion”); printf(“1t Sillat 100n”); printf(“2t Puertat 350n”); printf(“3t Sillont 200n”); printf(“nIngrese el codigo del producto que desea llevar: “); scanf(“%d”,&codigo); printf(“nIngrese la cantidad que desea llevar: “); scanf(“%d”,&cantidad); if(codigo==1) valor=100; if(codigo==2) valor=350; if(codigo==3) valor=200; total=valor*cantidad; printf(“nEl total es de: %d”,total); printf(“nIngrese el pago: “); scanf(“%d”,&pago); if(pago<total) printf(“nEl pago no es suficiente”); else { vuelto=pago-total; printf(“nEl vuelto es de: %d”,vuelto); } printf(“nVenta finalizada”); getch(); } Y ahora, añadiendole algunos ciclos, tendremos un código como este: #include <stdlib.h> #include <stdio.h> #include <conio.h> /* Incluimos las librerías */ int codigo, cantidad, valor, total, vuelto, pago; /* Declaramos las variables que usaremos en el proceso */ int ok=1; /* Adicionalmente declaramos una variable ok, que nos servirá de bandera para un ciclo que usaremos */ int opcion=1; /* Declaramos una variable opcion, que regulara si queremos hacer más de una venta */ int main() { while(opcion==1) { while(codigo!=4) /* Definimos un ciclo que se ejecute siempre que el usuario no presione la tecla para finalizar la venta */ { printf(“t Lista de productosn”); /* Listamos los productos */ printf(“Codigot Nombret Precion”); printf(“1t Sillat 100n”); printf(“2t Puertat 350n”); printf(“3t Sillont 200n”); printf(“nPara cerrar la venta, presione 4″); /* Añadimos la opción para cerrar la venta */ printf(“nIngrese el codigo del producto que desea llevar: “); /* Pedimos el código del producto */ scanf(“%d”,&codigo); /* Leemos el código del producto */ if(codigo==4) /* Si el código es igual a 4, significa que la venta está finalizada, así que cerramos el proceso de venta */ break; printf(“nIngrese la cantidad que desea llevar: “); /* Pedimos la cantidad */ scanf(“%d”,&cantidad); /* Leemos la cantidad */ if(codigo==1) /* Igualamos el código para asignar el precio */ valor=100; if(codigo==2) valor=350; if(codigo==3) valor=200; total=total+(valor*cantidad); /* A total le asignamos, el total acumulado hasta ahora, más el nuevo valor y nueva cantidad, multiplicados entre sí */ } printf(“nEl total es de: %d”,total); /* Saliendo de la venta, indicamos el total */ while(ok==1) /* Declaramos un ciclo con la variable ok, para el proceso de pago y vuelto, así se ejecutará hasta que se pague la cantidad correcta */ { printf(“nIngrese el pago: “); /* Solicitamos el pago */ scanf(“%d”,&pago); /* Leemos el pago */ if(pago<total) /* Si el pago es inferior al total, mostramos un mensaje de error */ printf(“nEl pago no es suficiente”); else /* De lo contrario, cambiamos el valor de ok para romper el ciclo y mostramos los mensajes de vuelto */ { ok=0; vuelto=pago-total; printf(“nEl vuelto es de: %d”,vuelto); } } printf(“n¿Desea hacer otra venta? (1=Si , 0=No): “); /* Preguntamos si desea hacer otra venta */ scanf(“%d,”,&opcion); /* Leemos la respuesta */ } printf(“nVenta finalizada”); /* Mensaje final */ getch(); /* Programa en pausa hasta pulsar una tecla */ } Como podemos apreciar en esta nueva versión, hacemos uso de algunos ciclos. De esta forma, podemos hacer una venta de múltiples productos, y validamos el pago hasta que sea el correcto, para así completar de forma correcta la venta. Además, luego de finalizar una venta, podemos hacer otra automáticamente al señalarlo y de esta forma no necesitamos volver a ejecutar el programa cada vez que queramos vender algo. Recordemos que nuestro programa lo vamos construyendo de a poco, aún hay muchos puntos que pueden ser mejorados y eso es lo que iremos haciendo en los próximos números. Por ahora lo dejaremos aquí, pero los incentivamos a que vayan añadiendo nuevas cosas de lo que hemos ido aprendiendo. En la próxima edición de “Cómo aprender a programar y no morir en el intento”: Método de ordenamiento: El método de la burbuja. Método de busqueda: Búsqueda secuencial. Funciones. Continuación del términal de ventas: Añadiendo un menú. Cualquier duda o comentario que puedan tener, los animamos a dejarnos unas líneas en el área habilitada a continuación. Esperamos que este tutorial haya sido de utilidad para Uds. Muchas gracias por leer y será hasta una próxima oportunidad. http://www.taringa.net/posts/info/14028919/Como-aprender-a-programar-y-no-morir-en-el-intento_.html http://www.taringa.net/posts/info/14029060/Como-programar-y-no-morir-en-el-intento-parte-2.html http://www.taringa.net/posts/info/14030260/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-3.html http://www.taringa.net/posts/info/14030386/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-4.html http://www.taringa.net/posts/info/14030572/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-5.html http://www.taringa.net/posts/info/14030711/Como-aprender-a-programar-y-no-morir-en-el-intento--Parte-6.html http://www.taringa.net/posts/info/14030957/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-7.html http://www.taringa.net/posts/info/14031158/Como-programar-y-no-morir-en-el-intento-parte-8.html

En la última edición de esta saga, dimos por concluído el aprendizaje de Pseudo-código, un paso importante al momento de aprender a programar. Tan importante como el que prometimos que daríamos ahora, el ingreso al mundo de los lenguajes reales de programación. Hoy, y en las próximas ediciones, nos adentraremos de lleno en la programación en C, donde intentaremos cubrir todo lo posible para que podamos convertirnos en unos aces de la programación. Todo el detalle, como siempre, después del salto. Cómo aprender a programar y no morir en el intento – Parte 7 Viendo que ahora ingresaremos a la programación propiamente tal, es bueno indicar los: Implementos necesarios: Un entorno de programación en C (recomendamos Dev C/C++ de Bloodshed, un buen entorno de programación que además es gratuito. Ese es el que utilizaremos a través de los siguientes tutoriales. Pueden descargarlo en este enlace). Con todo eso claro, vamos a los contenidos que cubriremos hoy: Contenidos: Introducción al lenguaje C. Librerías. Variables en C. Funciones básicas. Primer programa en C. 1.- Introducción al Lenguaje C: Nota: La instalación del entorno de programación, hemos decidido no cubrirla, ya que es bastante estándar en lo que a instalaciones de programas se refiere. Les recomendamos hacer la instalación de forma normal, dándole siguiente en las ventanas y dejando las opciones que vienen por defecto. Más adelante indicaremos si es necesario hacer cambios sobre esto. Y bueno, llegamos al momento que tanto esperabamos: Empezar a trabajar con lenguajes reales de programación. Para comenzar, hemos optado por el lenguaje C, debido a que por su forma y paradigma, es un buen y simple lenguaje para continuar el aprendizaje. Además, como iremos viendo a medida que nos adentremos en los siguientes capitulos, tiene mucha similitud con el Pseudo-código que hemos visto hasta ahora. C es un lenguaje de programación que fue creado en 1972 en los laboratorios Bell. Utiliza un paradigma estructurado (también denominado como imperativo y/o procedural) y presenta una eficiencia notable en su código, además de características de bajo nivel que permiten controlar algunos aspectos de memoria y perifericos, por lo que se convierte en la elección favorita e idónea al momento de desarrollar aplicaciones e incluso desarrollos para Sistemas Operativos. Los programas desarrollados en C, presentan una estructura bastante similar a la que habíamos visto hasta el momento en Pseudo-código, con algunas adiciones (como las librerías, que ya veremos) y uno que otro cambio, sobretodo en las palabras reservadas y algunas formas de definir cosas. Todo esto lo iremos viendo a su debido tiempo. En resumen, algunos puntos a considerar para el futuro: Los programas en lenguaje C, se escriben en entornos de programación, en realidad si queremos podemos escribirlos en block de notas, pero los entornos de programación presentan funcionalidades que nos hacen la vida mucho más fácil, desde la detección de errores hasta la orientación sobre algunas palabras reservadas y/o comandos. En C, tal como en otros lenguajes, al momento de terminar nuestros programas, en el entorno de programación podemos “compilarlos”, lo que significa que el entorno hará una revisión del programa completo en busca de errores y nos advertirá sobre ellos para poder corregirlos. Entre los tipos de errores que se pueden presentar al momento de compilar o terminar un programa, principalmente tenemos 2: los léxicos y los sintácticos. Los primeros se refieren a cuando tenemos algo dentro de nuestro programa que está mal escrito, por ejemplo si en vez de un ciclo while escribimos whlie. Por otro lado tenemos los errores sintácticos, que se refieren a cuando lo que hemos escrito no tiene sentido, por ejemplo el querer asignar un valor numérico a una variable de tipo carácter o algo por el estilo. Iremos viendo más sobre estas y otras consideraciones y detalles a medida que vayamos avanzando en nuestro aprendizaje. 2.- Librerías: Un punto muy importante dentro de la programación, en especial en el lenguaje C, son las famosas y nunca bien ponderadas librerías. ¿Qué es una librería? Una librería es una plantilla que contiene una serie de funciones, las cuales pueden ser utilizadas por un programa que ha invocado esta librería al inicio. Las librerías normalmente representan una “categoría” de funciones (por ej. existe una librería donde están todas las funciones matemáticas más comunes) y de acuerdo a eso las invocamos. El lenguaje C nos proporciona múltiples librerías para nuestras necesidades, por lo que cada vez que necesitemos realizar una determinada acción, podemos hacer una búsqueda de la función y por ende librería correspondiente. Adicionalmente, podemos crear nuestras propias librerías y utilizarlas libremente (así como otras que han sido creadas por otros usuarios y puestas a disposición en Internet). Podemos reconocer las librerías por su extensión que es la letra “h”. Por ejemplo, si tuviéramos la librería comolohago, la encontraríamos como comolohago.h. Estas librerías se encuentran en el directorio include de nuestra instalación correspondiente al entorno de programación. Tal como indicabamos en la definición, las librerías deben ser invocadas o en estricto rigor “incluidas” en el programa donde las vayamos a utilizar. Para esto, al inicio, en las primeras líneas de nuestro programa, debemos utilizar la sentencia #INCLUDE y el nombre de la librería entre < y >. Por ejemplo, si quisiéramos incluir la librería “ejemplo.h”, pondríamos al inicio de nuestro programa: #INCLUDE <ejemplo.h> Podemos incluir las librerías que queramos (siempre que existan). Sin embargo, no es recomendable incluir librerías que no vayamos a utilizar, ya que es un gasto extra sobre el programa. En caso de que alguna de las funciones, o sentencias de nuestro programa necesite de una librería que no hayamos incluido, al momento de compilar nos lanzará un error avisándonos del hecho. Antes de concluir con el capítulo sobre las librerías, es bueno añadir que las más comunes que se usan en prácticamente el 100% de los programas en C son las librerias stdlib.h y stdio.h, por lo que siempre es bueno añadirlas. Otra de las comunes es la conio.h, pero no es utilizada todo el tiempo y probablemente no la requeriremos hasta que vayamos mucho más adelante. 3.- Variables en C: Al igual que en Pseudo-código, en lenguaje C, así como en otros lenguajes, contamos con variables para almacenar, operar y mostrar datos. No entraremos en detalles sobre definiciones de que es una variable, porque esos temas ya los hemos cubierto en números anteriores. Nos dedicaremos de lleno a cubrir las variables en C, las cuales son muy similares a las que utilizabamos en Pseudo-lenguaje. Entre las más comunes que utilizaremos: int: Se utilizan para almacenar y operar con números enteros (correspondiente al conjunto Z de las matemáticas). Pueden almacenar tanto enteros positivos como negativos hasta un cierto rango (-32768 a 32767). Existen 2 variaciones que son el short int y el long int, los cuales varían en el rango permitido. char: Se utilizan para almacenar caracteres, tal como el tipo Letra de Pseudo-código. float: Se utilizan para almacenar y operar con números decimales (correspondiente al conjunto Q de las matemáticas). Adicionalmente se pueden utilizar para almacenar números enteros, pero no es lo recomendable. Su rango va entre 3,4 *E-38 (elevado a) hasta 3,4 * E+38 (elevado a). boolean: Almacenan datos de tipo booleano. Pueden tener 2 valores: true o false. Esas son las variables principales que utilizaremos al programar. Iremos conociendo otras y viendo variaciones de estas mismas a medida que vayamos adentrándonos más y viendo más ejemplos. 4.- Funciones básicas: En nuestros primeros programas de Pseudo-código, utilizamos una serie de funciones básicas para leer datos desde teclado o mostrarselos al usuario, así como operaciones matemáticas y otras cosas similares que nos ayudaron a llevar a cabo nuestros programas más simples. En C tenemos estos mismos operadores y funciones, con unas leves diferencias como veremos a continuación: a) La Función Principal: En Pseudo-código utilizabamos la función principal ( ) que era donde escribíamos el cuerpo del programa. En C también tenemos una función principal, pero la diferencia es que aqui tiene un tipo (tipo int) y su nombre es main. Entonces, para declarar la función principal decimos: int main( ) { código del programa } Adicionalmente, podemos decir que la función main de C, cuenta con 2 parámetros como argc (de tipo int) y argv (de tipo char, es un vector). Estos parámetros corresponden a argumentos que nosotros le podemos dar a un programa particular, siendo el primero un entero que indica el número de argumentos, y el segundo un vector de tipo char que contiene en cada posición los argumentos que enviamos. Esto es un poco avanzado, así que no lo veremos aún, pero podremos apreciar que es bastante útil. b) Mostrando información por pantalla: Cuando queríamos mostrar algún tipo de información en pseudo-código, utilizabamos la sentencia mostrar. En C, utilizaremos printf, la cual se utiliza de la misma forma que la veníamos utilizando hasta ahora, es decir: printf(“mensaje”); o bien printf(“%tipo de variable”,nombre de la variable); Se puede utilizar una combinatoria de ambas. En la parte de %tipo de variable, utilizamos los tipos definidos en el lenguaje C, como por ejemplo: %d: Si la variable es un entero (int). %f: Si la variable es un decimal o punto flotante (float). %c: Si la variable es un caracter (char). c) Leyendo información desde teclado: Tal como debemos recordar, en pseudo-código utilizabamos la sentencia leer. En lenguaje C, utilizaremos scanf, que funciona de la misma forma que la hemos utilizado hasta ahora, es decir: scanf(“%tipo de variable”,&nombre de la variable); Como podemos apreciar, hay una diferencia con el caso de printf, y es que acá al momento de hacer un scanf, al lado del nombre de la variable añadimos un &. Esto es necesario, ya que así le decimos al programa que guarde la información en el área de memoria que asignamos para esa variable cuando la declaramos. A esa área de memoria accedemos con &. Cuando incluimos una sentencia de tipo scanf, el programa se detiene hasta que el usuario ingresa datos y presiona enter, por lo que tenemos la seguridad que el resto del programa no se ejecutará hasta que se cumpla esa acción. d) Operadores matemáticos y lógicos: Son bastante similares a los que utilizabamos en pseudolenguaje, o sea: +: Suma. -: Resta. *: Multiplicación. /: División. <: Menor que. >: Mayor que. ==: Igual a. (un solo igual es asignación de valor, no comparación). !=: Distinto que. %: Módulo, o resto de la división. ++: Incremento en uno. –: Decremento en uno. Existen otros que iremos viendo a medida que los vayamos necesitando. 5.- Primer programa en C: Para terminar con el capitulo de hoy, nos tomaremos un pequeño descanso de tanta teoría, y realizaremos nuestro primer programa en C. Para eso, crearemos un archivo fuente donde estará nuestro código en nuestro entorno de programación (Si instalaron Dev-C++ vamos al menú Archivo > Nuevo > Archivo Fuente o bien presionamos CTRL + N) con lo que se abrirá una plantilla en blanco. Ahí es donde escribiremos el código. Entonces bien, tal como fue clásico en pseudo-código, aquí lo seguirá siendo, así que haremos nuestro nunca bien ponderado Hola Mundo, pero ahora en C. El código a continuación, y los comentarios como siempre, en negrita, cursiva y entre /* y */: #include <stdlib.h> #include <stdio.h> /* Partimos por incluir las librerías stdlib.h y stdio.h mediante #include */ int main() /* Declaramos la función principal */ { printf(“Hola Mundo”); /* Mostramos el mensaje */ } Con el código escrito, no nos queda más que probar nuestro programa. Así que primero vamos al menú Ejecutar > Compilar o bien presionamos CTRL + F9 en nuestro teclado. Esto nos pedirá guardar el programa y se abrirá una ventana, ahí colocamos como nombre holamundo.c (o bien el que uds quieran pero con la extensión .c) y en tipo seleccionamos C source files (*.c). Guardamos y el entorno de programación compilará (o sea revisará el programa que escribimos en busca de errores). Si encuentra algún error, nos indicará abajo donde está la falla. De lo contrario nos dirá que está listo y sin errores, por lo que presionamos Cerrar en la ventana de aviso. Luego, vamos al menú Ejecutar > Ejecutar o bien CTRL + F10 en nuestro teclado, y nuestro programa correrá (no saldrá corriendo, sino que se ejecutará). ¿Funcionó?, ¿Se ejecutó y desapareció?, no se asusten. No hay nada malo con el programa. Es el entorno de programación que por defecto cuando un programa termina, cierra la ventana de ejecución. Por ahora haremos un pequeño truco para poder visualizar nuestro programa de forma correcta. Añadiremos luego del mensaje, una función básica de C llamada getch();, la cual cumple la función de dejar el programa en espera hasta que el usuario presione una tecla, así podremos ver el resultado. Así que nuestro nuevo código quedaría de la siguiente forma: #include <stdlib.h> #include <stdio.h> int main() { printf(“Hola mundo”); getch(); } Compilamos y ejecutamos de nuevo y veremos la ventana con el resultado de nuestro programa, o sea, el mensaje “Hola Mundo”. Para cerrar solo presionamos una tecla. Y con eso terminamos por hoy, donde hemos dado nuestros primeros pasos en el lenguaje C e incluso hemos realizado nuestro primer programa. En la próxima edición: Leyendo datos de teclado. Iteraciones condicionales. Ciclos o búcles. Cualquier duda o comentario, pueden dejarnos unas líneas en el área habilitada a continuación. Esperamos que este tutorial haya sido de utilidad para Uds. Muchas gracias por leer y será hasta una próxima oportunidad. http://www.taringa.net/posts/info/14028919/Como-aprender-a-programar-y-no-morir-en-el-intento_.html http://www.taringa.net/posts/info/14029060/Como-programar-y-no-morir-en-el-intento-parte-2.html http://www.taringa.net/posts/info/14030260/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-3.html http://www.taringa.net/posts/info/14030386/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-4.html http://www.taringa.net/posts/info/14030572/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-5.html http://www.taringa.net/posts/info/14030711/Como-aprender-a-programar-y-no-morir-en-el-intento--Parte-6.html

Debido a que me preguntaron por mp voy a responder esta inquietud... que es HOLA MUNDO.... O para que se usa.... HOLA MUNDO En informática, un programa Hola mundo (o Hello World, en inglés) es el que imprime el texto «¡Hola, mundo!» en un dispositivo de visualización (generalmente una pantalla de monitor). Se suele usar como introducción al estudio de un lenguaje de programación, siendo un primer ejercicio típico. Se considera uno de los programas fundamentales desde el punto de vista didáctico. El Hola Mundo se caracteriza por su sencillez, especialmente cuando se utiliza en programas de línea de comandos. En interfaces gráficas este programa suele tener una complejidad mayor. Un programa Hola Mundo puede ser útil como prueba de configuración para asegurar que el compilador, el entorno de desarrollo y el entorno de ejecución están instalados correctamente y funcionando. Configurar un conjunto de herramientas básicas completo desde cero hasta el punto donde hasta los programas triviales puedan ser compilados y ejecutados puede involucrar una cantidad de trabajo sustancial. Por esta razón, generalmente es usado un programa muy simple para probar un conjunto de herramientas nuevo. En los sistemas basados en microcontroladores empleados para el aprendizaje, se suele considerar "Hola mundo" al programa que permite poner en modo intermitente un led.1 El programa consiste en mandar alternativamente un nivel alto y uno bajo por uno de los puertos del sistema, dando a cada uno de dichos niveles un valor de retardo. #!/usr/bin/perl -w use strict; use Gtk2 '-init'; # Create main window: my $mw = Gtk2::Window->new('toplevel'); # Create main positioning table: my $t = Gtk2::Table->new (1,2,0); $mw->add($t); # 'Hello world!' label: my $label = Gtk2::Label->new('Hello world!'); $t->attach_defaults($label,0,1,0,1); $label->show; # Button to quit: my $button = Gtk2::Button->new('Quit'); $t->attach_defaults($button,0,1,1,2); $button->signal_connect( 'clicked' => sub { exit } ); $button->show; # Main loop: $mw->show_all; Gtk2->main; 0; Ejemplos De Implementacion del Inglés Hola Mundo in Diferentes Lenguajes En ABAP / IV INFORME HolaMundo. ESCRIBIR "¡Hola, mundo! '. En ABC ESCRIBIR "¡Hola mundo!" En ActionScript rastro ( "¡Hola, Mundo!" ) ; En ActionScript 3.0 Opción 1 paquete { importación . flash de la pantalla . Sprite ; pública la clase principal se extiende Sprite { pública la función principal ( ) { trace ( "¡Hola, Mundo!" ) ; } } } Opción 2 paquete { importación . flash de la pantalla . Sprite ; importación flash. texto . TextField ; pública la clase principal se extiende Sprite { pública la función principal ( ) { var = txtField nueva TextField ( ) ; . txtField texto = "¡Hola, Mundo!" ; addChild ( txtField ) ; } } } En Ada con Ada. Text_IO ; procedimiento de Hola_Mundo se empiezan a Ada. Text_IO . Ponga ( "¡Hola, Mundo!" ) ; finales Hola_Mundo; En ALGOL BEGIN ARCHIVO F (TIPO = A DISTANCIA); EBCDIC ARRAY E [doce y doce minutos]; SUSTITUIR POR E "Hola mundo!"; MIENTRAS los verdaderos BEGIN ESCRIBIR (F, *, E); END; FIN. En AppleScript Mostrar el diálogo de "Hola, Mundo!" botones { "OK" } botón predeterminado { "OK" } En ASP <HTML> <BODY> <% Respuesta . Escribir ( "Hola Mundo" ) %> </ BODY> </ HTML> En AutoIt MsgBox ( 0 , "" , "Hola Mundo!" ) En Autoplay Media Studio Dialog.Message ("Noticia", "Hola, Mundo!", MB_OK, MB_ICONINFORMATION, MB_DEFBUTTON1); En AWK #! / Bin / awk-f BEGIN { print "¡Hola, mundo!"; } En Bash #! / Bin / bash echo "Hola mundo" En Basic print "Hola Mundo"; En lotes @ echo off echo ¡Hola mundo ! En Boo #! / Usr / bin / booish impresión "Hola Mundo" En Brainfuck ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>. En C # Include int principal ( ) { printf ( "¡Hola, mundo! n " ) ; vuelta 0 ; } En C + + # Include usando espacio de nombres std ; int principal ( ) { cout << "¡Hola, mundo!" << endl ; vuelta 0 ; } En C + + / CLI Opción 1 int principal ( ) { System :: Console :: WriteLine ( "Hola, Mundo!" ) ; vuelta 0 ; } Opción 2 # Include using namespace std ; void principal ( ) { cout << "Hola mundo n " ; } En C # con Sistema ; clase MainClass { pública estática nula principal ( ) { Sistema . consola . WriteLine ( "¡Hola, Mundo!" ) ; } } En Centura Llamar SalMessageBox ('Hola Mundo', 'Saludo', MB_ICONEXCLAMATION | MB_OK) En Clipper ? "Hola Mundo!" In CLIPS ( printout t "Hola Mundo" crlf ) En COBOL IDENTIFICACIÓN DE LA DIVISIÓN. PROGRAMA-ID. HOLA. División de Medio Ambiente. Datos de la División. Procedimiento de división. DISPLAY "Hola mundo". STOP RUN. En ColdFusion <CFSET variable="Hola Mundo"> <cfoutput> # variable # </ cfoutput> En CSS (2,0 en Adelante) Solo para Navegadores Que cumplan Con El Estándar CSS 2.0 en Adelante. cuerpo : después de { el contenido : . Hola Mundo " ; } En D importación std. stdio ; void principal ( ) { writefln ( "Hola mundo" ) ; } En Delphi programa de PHolaMundo , utiliza diálogos , comenzar a MessageDlg ( 'Hola Mundo' , mtInformation , [ mbOK ] , 0 ) ; final . En Juegos DIV Studio y GNU Fenix PROGRAMA Hola Mundo ; PRIVADO fuente1 ; BEGIN fuente1 = load_fnt ( "ayuda help.fnt" ) ; escritura ( fuente1 , 160 , 100 , 4 , "Hola Mundo" ) , LOOP FRAME ; END END En DOS En Sistemas Operativos de la Familia DOS COMO MS-DOS o PC-DOS Que USAN COMO shell El intérprete de Comandos COMANDO. COM o CMD. EXE ( OS / 2 y de Windows de la rama NT) sí pueden CREAR Archivos de Proceso Por Lotes Extensiones estafadores y BAT CMD respectively, Con El Siguiente Contenido..: @ echo ¡Hola, Mundo ! En Eiffel clase HOLA_MUNDO crear hacer cuentan que es hacer io. put_string ( " % n Hola mundo % N " ) final final - HOLA_MUNDO En ensamblador de PowerPC párrafo Mac OS X # Hola - ppc . S párrafo Mac OS X # Gcc - nostdlib hola - ppc . S - o hola - ppc de datos. ; Datos hola : . ascii "Hola, mundo n" hola_len = . - hola . texto ; here vive el Código . globl inicio inicio : li r0 , 4 ; Llamada al Sistema 4 (sys_write) r3 li , 1 ; arg. 1: Descriptor de Archivo (stdout) lis r4 , HA16 ( hola ) ; arg. 2: puntero uno la Cadena (Parte Alta) adi r4 , r4 , lo16 ( hola ) ; Sumamos la Parte Baja del Mismo li r5 , hola_len ; arg. 3: Longitud de la Cadena sc , llamamos al Sistema nop li r3 , 0 ; El Valor Que Vamos A Devolver li r0 , 1 ; Llamada al Sistema sys_exit sc nop En ensamblador de PowerPC párrafo GNU / Linux # Hola - ppc . S párrafo GNU / Linux # Gcc - nostdlib hola - ppc . S - o hola - ppc . datos de # Datos hola : . cadena "Hola Mundo n" hola_len = . - hola . texto # aqui vive el Código . mundial _start _start : Li 0 , 4 # Llamada al Sistema 4 ( sys_write ) li 3 , 1 # arg . 1 : Descriptor de Archivo ( stdout ) lis 4 , hola @ ha # arg . 2 : un puntero la Cadena ( Parte Alta ) adi 4 , 4 , hola @ l # Sumamos la Parte Baja del Mismo li 5 , hola_len # arg . 3 : Longitud de la Cadena sc # llamamos al Sistema nop li 3 , 0 # Que El Valor Vamos A Devolver Li 0 , 1 # Llamada al Sistema sys_exit sc nop En ensamblador de x86 DOS párrafo . Modelo de pequeña . pila de datos. cadena1 DB 'Hola Mundo $. código. Programa : mov ax , @ datos mov ds , ax mov dx , offset cadena1 mov ah , 9 int 21h fines Programa En ensamblador de x86 párrafo GNU / Linux Nasm: sección . datos msg db "¡Hola Mundo!" , 0Ah len equ $ - msg sección . texto mundial _start _start : mov eax , 04h mov ebx , 01h mov ecx , msg mov edx , len int 80h mov eax , 01h mov ebx , 00h int 80h Gas: . sección . Rodata . MSG . cadena "¡Hola Mundo!" . sección . texto . globl principal principal : movl $ . MSG , ( % esp ) llamada pone movl $ 1 ,% eax movl $ 0 ,% ebx int $ 0x80 En Erlang -Módulo (hola). A la exportación ([hola_mundo / 0]). hola_mundo () -> io: fwrite ("Hola mundo n". En Fortran PROGRAMA HOLA IMPLICIT NINGUNA PRINT * , '¡Hola, mundo! " FIN En Google Go paquete principal importar "fmt" función principal ( ) { fmt. println ( "Hola mundo" ) } En Groovy println "Hola Mundo!" En GWBasic print "Hola Mundo" En Haskell HolaMundo :: IO () HolaMundo = putStrLn "Hola mundo!" En HQ9 + H En HTML < html > < cabeza > < título > Hola Mundo < / titulo > < / cabeza > < cuerpo > ¡Hola Mundo! < / cuerpo > < / html > En Icon procedimiento principal () write ("Hola Mundo"; final En IDL imprimir, 'Hola Mundo! " En INTERCAL NOTA Hola mundo en INTERCAL DO, 1 <- # 13 DO, 1 SUB # 1 <- # 238 DO, 1 SUB # 2 <- # 28 DO, 1 SUB # 3 <- # 192 DO, 1 SUB # 4 <- # 176 DO, 1 SUB # 5 <- # 82 DO, 1 SUB # 6 <- # 48 POR FAVOR, 1 SUB # 7 <- # 78 DO, 1 SUB # 8 <- # 8 DO, 1 SUB # 9 <- # 56 DO, 1 SUB # 10 <- # 80 DO, 1 SUB # 11 <- # 48 DO, 1 SUB # 12 <- # 114 DO, 1 SUB # 13 <- # 52 POR FAVOR, LEER, 1 Por favor, ceda En iHTML <CACHE iHTML! = TRUE> <ISET mensaje = "Hola Mundo" > < html > < cabeza > < título > : mensaje < / titulo > < / cabeza > < cuerpo > ¡: Mensaje < / cuerpo > < / html > En Java pública de clase HolaMundo { públicas estáticas vacíos principales ( String args [ ] ) { System . a cabo . de impresión ( "Hola Mundo" ) ; } } En JavaScript < tipo de script = "text / javascript" > documento. escribir ( "¡Hola, Mundo!" ) ; </ script de > En JCL / / Paso1 EXEC PGM = T9971591 / / DD en DDUNO %% Hola mundo En JSP <DOCTYPE html PUBLIC "- / / W3C / / DTD XHTML 1.0 Strict / / EN" " http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd "> <html> <%! Cadena hola = "Hola mundo";%> <head> <title> <% =% Hola> </ Title> </ Head> <body> <% =% Hola> </ Body> </ html> En Korn Shell ! # Usr / bin / ksh de impresión "Hola Mundo" ; En Liberty BASIC de impresión "¡Hola, mundo!" En LISP ( formato de t "¡Hola, Mundo!" ) En Logo Opción 1 escribe [¡Hola mundo!] Opción 2 Rótula "Hola GD 90 SL Av. 50 rótula" Mundo En LOLCODE HAI PUEDE TIENE STDIO? VISIBLE "MUNDO Hai!" KTHXBYE En Malbolge (= <`: 9876Z4321UT.-Q + *)? M &% $ H" ~} | Bzy = | {z] KwZY44Eq0 / {MLK ** hKs_dG5 [{m_BA-Y;?; Vb'rR5431M} / zHGwEDCAA @ 98 6543W10/.R, + O <. En Maple "Hola mundo"; En mIRC Scripting el 1: inicio: { echo ! ¡Hola Mundo } En Modula-2 MÓDULO de Hola; DE WriteString InOut IMPORT; BEGIN WriteString ("Hola Mundo"; FIN Hola. En Natural ESCRIBIR "Hola Mundo" En ObjectPAL método HolaMundo () msgInfo ("", "¡Hola Mundo!" endMethod método run (Evento EventInfo var) msgInfo ("", "¡Hola Mundo!" endMethod En Object Pascal procedimiento TForm1.Button1Click ( emisor : TObject ) ; / / Despues de CREAR y presionar El Botón "button1" comenzar ShowMessage ( 'Hola Mundo' ) ; final; final. En OpenInventor # Inventor V2.1 ascii Text3 { cadena "Hola mundo" } En Pascal Programa HolaMundo; Comience Escribir ( '¡Hola, Mundo! " ) ; End . En Pauscal 'Pauscal: Lenguaje de Programación en Español Importar "Pauscal.prp" Mensaje ( "¡Hola Mundo!" ) En Peón principal ( ) { print ( "Hola, mundo! n " ) ; } En Perl imprimir "Hola, mundo n " ; En PL / 1 Hola: opciones de procedimiento (principal); puesto Ignorar la lista ("¡Hola Mundo! '); fin de Hola; En PL / SQL BEGIN DBMS_OUTPUT . Put_Line ( 'Hola Mundo' ) ; END ; En SAPScript PRINCIPAL P1 Hola Mundo / En Seed7 $ Include "seed7_05.s7i"; proc const: función principal es comenzar writeln ("Hola Mundo"; poner fin a funciones; En SQL Variante de Oracle : SELECT 'Hola Mundo' DE DOBLE; Otros SQL ( MySQL , Microsoft SQL Server , etc) SELECT 'Hola Mundo' ; imprimir ( "Hola Mundo" ) En Unlambda `` `S `` sii` ki `` S `` s `ks `` S `` s `ks `` s` k `s` kr `` S `k` si `` s `k` s `k `D `` `` `` `` `` ``. Hola,. . Mundo! k k `K `` s `` s` k `KSK. * En Visual Basic Private Sub Form_Load () MsgBox "Hola Mundo" End Sub En Visual Basic. NET Private Sub Form_Load ( ) Maneja Form1. carga de mensajes. espectáculo ( "¡Hola, Mundo!" ) End Sub 'Modo Consola. Privado Sub Principal ( ) de la consola. WriteLine ( "¡Hola, Mundo!" ) End Sub En XUL <? Xml version = "1.0" ?> <? xml-stylesheet href = "chrome :/ / global / skin /" tipo = "text / css" > <Ventana de Identificación = "Hola" título = "Ejemplo: hola mundo" orientar = "vertical" persisten = "screenX screenY ancho de Mundo </ description > <descripción valor = "Hola mundo" estilo = "font-size: 24pt" /> <etiqueta = valor "Hola mundo" estilo = "font-size: 24pt" /> </ window > ESO FUE TODO SI ME OLVIDE ALGUNO POR FAVOR RECORDARMELO....GRACIAS HASTA EL PROX APORTE.....SALUDOS!!!!

Continuando con esta saga, hoy les traemos la 3a edición de estas guías donde estamos cubriendo el tema de la programación paso a paso desde sus principios más básicos. Ya hemos visto en los dos números anteriores toda la información básica antes de empezar a llevar código a papel, por lo que de este número en adelante nos dedicaremos de lleno a la programación en sí. Todo el detalle, como siempre, después del salto. Cómo aprender a programar y no morir en el intento – Parte 3 Nota: Recomendamos leer las primeras 2 partes de esta guía si no lo han hecho, las cuales pueden encontrarlas en: Parte 1. Parte 2. Como es habitual, partamos por revisar los contenidos de esta edición: Contenidos: Definición de variables. Leyendo datos desde teclado. Operaciones matemáticas. Iteraciones condicionales. Es harta información, así que vamos de lleno a los temas: 1.- Definición de variables En el tutorial anterior ya dimos una explicación de lo que son las variables y como se encuentran involucradas en los procesos de la programación, por lo que hoy nos enfocaremos solamente a su definición y uso dentro del código propiamente tal. Las variables tienen lo que se llama un “ciclo de vida”, que representa toda la duración de una variable a través de un programa. Este ciclo de vida se inicia con la definición o creación de la variable y termina con la finalización del programa o la liberación del área de memoria donde estaba contenida. Para crear o definir una variable en pseudocódigo siempre se utiliza la siguiente sintaxis, la cual representa fielmente la utilizada en los lenguajes de programación reales: Tipo Nombre Valor Inicial (opcional) Tal como vimos en el tutorial anterior, en los lenguajes de programación se utilizan ciertos tipos para definir los tipos (valga la redundancia) de información que puede almacenar la variable en cuestión. Les recomiendo revisar ese tutorial como recordatorio de los tipos que vimos. En pseudocódigo utilizaremos los siguientes tipos: Número: Este tipo de variables almacenarán cualquier valor de tipo número, ya sea entero (conjunto Z) o bien real (conjunto R del universo de las matemáticas, o sea, enteros más decimales). Cabe recordar que en los lenguajes reales hay distintos tipos para los enteros y para los decimales, pero aquí los agruparemos todos dentro de este mismo tipo. Letra: Este tipo de variables almacenarán cualquier valor de tipo alfanumérico, ya sean caracteres (0-9 o A-Z) o palabras y/o frases (como “gato”, o “la casa roja”). Tal como en el tipo anterior, hay que recordar que en los lenguajes de programación reales hay distintos tipos para tratar los caractéres y las cadenas de palabras, pero aquí los agruparemos dentro de un mismo tipo. Lógico: Este tipo de variables almacenarán valores de tipo lógico (verdadero o falso). En vez de almacenar las palabras “verdadero” o “falso” le asignaremos un 0 si se trata del primero y un 1 si se trata del segundo. Vale la pena mencionar, que a pesar de que las variables de tipo Letra puedan almacenar caracteres correspondientes a números, no podremos realizar operaciones matemáticas sobre ellos, por lo que si necesitamos este tipo de operaciones es recomendable almacenar en variables de tipo Número. Durante el ciclo de vida de la variable (periodo entre su declaración y su fin) podemos modificar su contenido cuantas veces queramos, siendo bastante útil al momento de querer reciclar una variable para no tener que crear otra del mismo tipo, hecho que nos termina ayudando a ahorrar memoria en uso. Tal como indicamos en la sintaxis, toda variable debe llevar un nombre, el cual puede ser cualquiera, pero debe respetar los siguientes criterios: Debe ser único. No pueden haber 2 variables con el mismo nombre. No puede empezar con un número ni un underscore. Sin embargo pueden contenerlos dentro de su nombre. Si bien no se puede nombrar variables como “2auto” o “_perro” si podemos tener otras como “auto2″ o “perro_”. No pueden llevar como nombre una palabra reservada del lenguaje. Todos los lenguajes tienen ciertas “palabras reservadas” que son utilizadas para definir tipos de variables o funciones del lenguaje propiamente tal. Por ejemplo, nunca podríamos nombrar una variable como “while” ya que los lenguajes reservan esa palabra para una función de tipo ciclo. De a poco iremos conociendo las palabras que están reservadas para cada lenguaje, aunque no hay de que preocuparse, ya que siempre nos avisará al momento de compilar el programa y nos obligará a cambiarla para que no hayan conflictos. Además, indicamos en la sintaxis que a una variable podemos asignarle opcionalmente un valor inicial. El “opcionalmente” se debe a que al momento de crear la variable podemos asignarle un valor, pero si no lo hacemos no afecta, ya que lo podemos hacer más adelante. Lo único en lo que hay que fijarse es que la variable contenga ya algún valor cuando queramos operar con ella. Por ejemplo, si deseamos sumar un valor almacenado en una variable, esta no puede estar en blanco. Veremos a continuación, algunos ejemplos que cubren todo lo que hemos visto en las líneas anteriores: Retomando el ejemplo del “hola mundo” que vimos en el tutorial anterior, ahora en vez de desplegar directamente el mensaje, lo desplegaremos con el uso de una variable. (comentarios en negrita, cursiva y entre /* y */): Inicio /* Establecemos el inicio del programa */ Letra mensaje=”Hola mundo”; /* A continuación definimos una variable de tipo “Letra”, de nombre “mensaje” y le damos un valor inicial de “Hola mundo”, el mensaje que queremos mostrar. Luego de la sentencia ponemos un punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de la sentencia */ Principal( ) /* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el tema de las funciones */ mostrar mensaje; /* Utilizamos la sentencia “mostrar” para enviar un mensaje que se despliegue en pantalla y luego la variable que contiene el mensaje, en este caso “mensaje”. Cerramos la sentencia con un punto y coma para indicar que se ejecute la línea */ Fin /* Finalizamos el programa */ Como podemos ver, en este ejemplo hemos definido una variable de tipo Letra, llamada mensaje y le hemos asignado como valor inicial el mensaje que vamos a mostrar por pantalla. Ahora, ¿Qué pasa si no queremos asignar un valor inicial, y se lo damos más adelante?, sería algo como esto: Inicio /* Establecemos el inicio del programa */ Letra mensaje; /* A continuación definimos una variable de tipo “Letra”, de nombre “mensaje”. Luego de la sentencia ponemos un punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de la sentencia */ Principal( ) /* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el tema de las funciones */ mensaje=”Hola mundo”; /* Asignamos el valor “Hola mundo” a la variable mensaje y cerramos con punto y coma*/ mostrar mensaje; /* Utilizamos la sentencia “mostrar” para enviar un mensaje que se despliegue en pantalla y luego la variable que contiene el mensaje, en este caso “mensaje”. Cerramos la sentencia con un punto y coma para indicar que se ejecute la línea */ Fin /* Finalizamos el programa */I Esos son los pasos fundamentales para ir trabajando con variables. Todo esto se irá haciendo cada vez más claro a medida que vayamos desarrollando nuestros programas. 2.- Leyendo datos desde teclado Hasta ahora, toda la información que hemos ido desplegando en nuestros programas ha sido proporcionada por nosotros mismos, algo que cuando estemos realizando programas para “terceros” nunca será suficiente, ya que muchas veces deberemos operar con información proporcionada por los usuarios que utilizan los programas o por fuentes de datos externas. Para esto se utiliza el término “Leer datos”. Leer datos se refiere a recopilar información desde una fuente externa, ya sea un usuario que los ingrese vía teclado, o de una fuente de datos como un archivo con registros o una base de datos. En esta primera etapa nos centraremos en la lectura de datos desde teclado, o sea, proporcionada por los usuarios. Los datos se leen y se almacenan en una variable de tipo concordante al dato que se ingresa, por lo que es muy importante definir el tipo de dato correcto, ya que si indicamos una variable de tipo letra y el usuario ingresa un número, se guardará como caracter. Ya veremos esto en más detalle en el ejemplo. Esta información podemos manipularla de la forma que estimemos conveniente y despues desplegarla en pantalla de la misma forma que lo hemos hecho hasta ahora. Veamos un ejemplo, basandonos en el mismo ejercicio “Hola mundo” que hemos visto hasta ahora. En vez de desplegar nosotros el mensaje, le diremos al usuario que ingrese un mensaje para mostrar. (comentarios en negrita, cursiva y entre /* y */): Inicio /* Establecemos el inicio del programa */ Letra mensaje; /* A continuación definimos una variable de tipo “Letra”, de nombre “mensaje”. Luego de la sentencia ponemos un punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de la sentencia */ Principal( ) /* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el tema de las funciones */ mostrar(“Ingrese un mensaje para mostrar: “); leer(%letra,mensaje); /* Utilizamos la función mostrar para desplegar un mensaje por pantalla . Luego con la función leer indicamos entre parentesis el tipo de dato que recolectaremos, en este caso letra (acompañado de un porcentaje, esto es netamente para ir acostumbrándonos a como leeremos los datos en lenguajes reales) y luego de la coma el segundo parámetro, correspondiente a la variable donde almacenaremos la información, o sea, mensaje. Terminamos todo con un punto y coma. */ mostrar mensaje; /* Utilizamos la sentencia “mostrar” para enviar un mensaje que se despliegue en pantalla y luego la variable que contiene el mensaje, en este caso “mensaje”. Cerramos la sentencia con un punto y coma para indicar que se ejecute la línea */ Fin /* Finalizamos el programa */ Con esto podemos recibir toda la infromación que necesitemos por parte del usuario y desplegarla sin problemas en pantalla. 3.- Operaciones matemáticas En los lenguajes de programación, una forma de realizar operaciones con los valores almacenados en las variables es mediante las operaciones matemáticas. Los lenguajes soportan las operaciones más comunes que podemos utilizar en la matemática y con ellas se puede trabajar tanto variable vs variable, como variable vs constante, y constante vs constante. Las operaciones más comunes soportadas son: +: Suma. -: Resta. *: Multiplicación. /: División. Raíz cuadrada (la sentencia depende de cada lenguaje). Potenciación (la sentencia depende de cada lenguaje). %: Módulo de la división (resto). ++: Incremento. –: Decremento. <: Menor a. >: Mayor a. ==: Igual a. (Se debe usar doble signo ya que el signo simple es para asignar valores). !=: Distinto de. &&: Y. ||: ó. Hay algunas otras que iremos viendo más adelante. Ahora veremos un ejemplo donde operaremos con un número ingresado por teclado (comentarios en negrita, cursiva y entre /* y */): Inicio /* Establecemos el inicio del programa */ Numero edad; Numero resultado; /* A continuación definimos una variable de tipo “Numero”, de nombre “edad” y luego una variable de tipo “Numero”, de nombre “resultado”. Luego de la sentencia ponemos un punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de la sentencia */ Principal( ) /* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el tema de las funciones */ mostrar(“Ingrese su edad: “); leer(%numero,edad); /* Utilizamos la función mostrar para desplegar un mensaje por pantalla . Luego con la función leer indicamos entre parentesis el tipo de dato que recolectaremos, en este caso numero (acompañado de un porcentaje, esto es netamente para ir acostumbrándonos a como leeremos los datos en lenguajes reales) y luego de la coma el segundo parámetro, correspondiente a la variable donde almacenaremos la información, o sea, edad. Terminamos todo con un punto y coma. */ resultado=edad + 10; /* En la variable resultado ahora almacenamos lo que nos dará el sumarle 10 al valor ingresado para edad */ mostrar (“Su edad en 10 años sera: %numero”,resultado); /* Utilizamos la sentencia “mostrar” para enviar un mensaje que se despliegue en pantalla, seguido del tipo de variable que desplegaremos, o sea numero y luego la variable que contiene la información, en este caso “edad”. Cerramos la sentencia con un punto y coma para indicar que se ejecute la línea */ Fin /* Finalizamos el programa */ De esta forma desplegaremos un resultado de operar con un dato ingresado por el usuario. Dentro de esas operaciones podemos hacer todas las detalladas con anterioridad. 4.- Iteraciones condicionales Dentro de la programación, en muchas ocasiones nos encontraremos con situaciones en donde se deberá seleccionar uno de dos o varios caminos a seguir dependiendo de los datos con los que se este trabajando. Para esto se cuenta con lo que se llama “iteraciones condicionales”, lo que básicamente nos dará el pie de tomar un camino a seguir dependiendo de una condición que indiquemos. Cada uno de estos caminos puede incluir una serie de operaciones que perfectamente pueden ser distintas las unas de las otras. La iteración condicional por excelencia es, en el caso del pseudocódigo el “Si” y “Si no”(if y else en los lenguajes reales). Un “Si” puede o no llevar un “Si no”, mientras que un “Si no” debe ir necesariamente a continuación de un “Si” ya que trabaja a partir de la condición especificada más arriba. Además es bueno indicar que dentro de un “Si no”, pueden ir infinitos “Si” y “Si no”. Ejemplificando un poco esto, podría ser algo así: Recogemos un dato respectivo a la edad de un usuario. Si (edad cumple una condición) sentencia 1; sentencia 2; Si no sentencia 3; sentencia 4; Veamos un ejemplo práctico sobre el uso de estas iteraciones condicionales, basándonos en el ejemplo anterior: Inicio /* Establecemos el inicio del programa */ Numero edad; /* A continuación definimos una variable de tipo “Numero”, de nombre “edad”. Luego de la sentencia ponemos un punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de la sentencia */ Principal( ) /* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el tema de las funciones */ mostrar(“Ingrese su edad: “); Si (edad > 18) mostrar “Ud. es mayor de edad”; Si no mostrar “Ud. es menor de edad”; /* Utilizamos la iteración condicional “Si” con la condición si la edad es mayor a 18, y en caso de que sea desplegamos el mensaje “Ud. es mayor de edad” con la función mostrar. Luego utilizamos “Si no” lo que significa “Si no es mayor a 18″ y mostramos el mensaje “Ud. no es mayor de edad con la función mostrar. */ Fin /* Finalizamos el programa */ Claramente el ejemplo anterior presenta una de las iteraciones condicionales más básicas. Pueden realizarse modificaciones para hacer iteraciones multiples e incluso más de una condición, ya sea excluyente o no excluyente, pero eso lo veremos en una próxima edición, ya que hoy hemos cubierto más que suficiente. En la próxima edición de “Como aprender a programar y no morir en el intento – Parte 3″: Iteraciones condicionales multiples y uso de más de una condición. Switch: Otra iteración condicional. Ciclos o búcles. Así que a armarse de paciencia, que hemos avanzado bastante pero aún queda un largo camino por recorrer. Como siempre este tutorial ha sido desarrollado, probado y documentado por el equipo de Como Lo Hago, por lo que cuenta con nuestro Sello de Garantía. Cualquier consulta o problema que puedan tener, no duden en dejarnos unas líneas a continuación. Esperamos que este tutorial haya sido de utilidad para Uds. Muchas gracias por leer y será hasta una próxima oportunidad. http://www.taringa.net/posts/info/14028919/Como-aprender-a-programar-y-no-morir-en-el-intento_.html http://www.taringa.net/posts/info/14029060/Como-programar-y-no-morir-en-el-intento-parte-2.html http://www.taringa.net/posts/info/14030260/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-3.html http://www.taringa.net/posts/info/14030386/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-4.html http://www.taringa.net/posts/info/14030572/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-5.html http://www.taringa.net/posts/info/14030711/Como-aprender-a-programar-y-no-morir-en-el-intento--Parte-6.html http://www.taringa.net/posts/info/14030957/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-7.html http://www.taringa.net/posts/info/14031158/Como-programar-y-no-morir-en-el-intento-parte-8.html http://www.taringa.net/posts/info/14031158/Como-programar-y-no-morir-en-el-intento-parte-9.html

Continuando con nuestra interminable reconocida y solicitada saga orientada a quienes se empiezan a adentrar al mundo de la programación, hoy les traemos una nueva edición, realmente la última que veremos sobre Pseudo lenguajes y además las últimas consideraciones previas a la entrada a los lenguajes reales. Todo el detalle, como siempre, después del salto. Cómo aprender a programar y no morir en el intento – Parte 6 Nota: Tal como dice el título, esta es la 6ta parte de estas guías. Para un completo entendimiento, recomendamos, si no lo han hecho, leer las partes anteriores, las cuales pueden ser encontradas en la categoría de Programación de nuestros tutoriales. Con eso claro, veamos los contenidos que cubriremos hoy: Contenidos: Funciones. Ultimas consideraciones sobre Pseudo-código. Entrando a un lenguaje real. Más sobre los paradigmas de programación. Como pueden apreciar, hay harto que cubrir, así que vamos directo a eso: 1.- Funciones. El último tema que cubriremos sobre programación en pseudo-código propiamente tal, será el de las funciones, el cual es un elemento de suma importancia tanto para estas etapas tempranas como para cuando nos adentremos aun más en la programación. Intentaremos simplificar este tema lo que más podamos. De cualquier forma, a pesar de la complejidad que puede presentar, no se preocupen si no lo entienden a la perfección en un comienzo, ya que a medida que vayamos viendo los ejemplos y en otros contenidos más avanzados iremos comprendiendo bien este tema. Hasta ahora, cada vez que escribíamos un programa y dentro de el necesitábamos tener procedimientos de cálculo o manipulación de datos, los escribíamos línea por línea estructuradamente dentro del principal de nuestro programa, algo así: Definición de variable / asignación de valor Operación 1 Operación 2 Operación 3 Asignación de resultados Si las operaciones anteriores las necesitamos utilizar más de una vez o para distintas variables, adicionalmente podíamos añadirlas dentro de un ciclo, si el tipo de variables nos lo permiten, o bien repetir las operaciones dentro del programa las veces que sean necesarias. Ahora, si la operación es de una sola línea, como una operación matemática por sí sola, no presenta mayores complejidades ni costos repetirla todas las veces que sean necesarias. Sin embargo, cuando hablamos ya de un proceso que contiene varias operaciones, y por ende varias líneas de código, es cuando el tema se vuelve mucho más complejo y engorroso, ya que nuestros programas empiezan a aumentar de tamaño y será mucho más costoso (computacionalmente hablando) ejecutarlos. Para esto es que se definen las Funciones, las cuales, como su nombre lo indica, ofrecen la funcionalidad de agrupar y ejecutar una serie de operaciones, tanto por si solas como dependiendo de ciertos parámetros que les entreguemos, y a la vez dándonos la opción de retornarnos un valor que puede ser constante o variable dependiendo de los resultados de las operaciones y cálculos internos de la función. La programación está compuesta fundamentalmente de funciones, y hasta ahora, a través de los contenidos y ejemplos, hemos utilizado una serie de ellas. Por ejemplo, la parte principal que declaramos en cada programa que hacemos es una función, es la que contiene los contenidos principales del programa que escribimos, valga la redundancia. A esa función no le entregamos ningún tipo de parámetros y no nos retorna nada. Otras funciones que hemos utilizado hasta ahora son las iteraciones condicionales (Si, Si no), los ciclos (mientras, para, haga mientras) y otras como leer, mostrar, etc. ¿Qué ventajas presentan las funciones? Principalmente orden, comodidad y economía. El uso de funciones nos permite no tener que repetir operaciones según el número de veces que las vayamos a necesitar y en vez de eso solo definirlas una vez y llamarlas cuando sea necesario. Eso también implicará que nuestro programa sea mucho más liviano al momento de ejecutarse. Existen una serie de otras ventanas que iremos descubriendo más adelante. Las funciones se escriben fuera de la función principal (normalmente por orden, se escriben después) y se definen de acuerdo a la siguiente estructura: tipo nombre_función(parámetro 1, parámetro 2, etc.) { operación 1; operación 2; sentencia 1; sentencia 2; retorno de variable; } Donde: Tipo: Detalla el tipo de valores que devuelve la función. Estos tipos pueden ser los mismos que los de las variables, los cuales han sido especificados en los números anteriores de esta saga. Sin embargo, no hay que confundirse, ya que por el hecho de que una función sea de un determinado tipo, no significa que dentro de las operaciones no puedan declararse y usarse variables de otros tipos, solo debemos fijarnos que las variables que retornamos si lo sean. Se debe definir un tipo para la función obligatoriamente. Nombre de la función: Es un nombre único, tal como si estuviésemos definiendo una nueva variable. El nombre de la función puede ser cualquiera, pero es recomendable, por orden, darle un nombre adecuado. Por ejemplo si definimos una función que encuentre el número máximo entre una serie de valores, es recomendable nombrar a esa función como numero_maximo. De esa forma, siempre podremos ver que hace cada parte de nuestro programa rápidamente cuando lo estemos revisando. Parámetros: Tal como hemos definido en distintas partes de esta saga de tutoriales, los parámetros que recibe una función son los que utilizará para operar dentro de ella y devolver resultados. Normalmente las operaciones declaradas en una función son procedimientos estándar que varían dependiendo de los valores que manejamos. En una función podemos recibir múltiples parámetros y estos pueden ser de distintos tipos, solo debemos asegurarnos de escribir primero el tipo y luego el nombre de ese parámetro, tal como si definiéramos variables. Estos nombres no pueden repetirse dentro de la función. Operaciones y sentencias: Básicamente podemos hacer lo mismo que hacemos dentro de nuestros programas, ya sea usar operadores matemáticos, iteraciones condicionales, ciclos, mostrar, leer, etc. Todo está permitido. Valor a retornar: Esto es opcional, una función puede o no retornar un valor, ya que muchas veces el resultado podemos mostrarlo directamente en pantalla con la función mostrar. Si decidimos devolver un valor, lo hacemos mediante la sentencia retornar junto al valor o variable que enviemos. Solo debemos recordar que el valor o variable retornado tiene que coincidir con el tipo de la función. Con toda la definición ya más clara, veremos un ejemplo de declaración y uso de funciones: Ejemplo: Realizaremos un programa en donde crearemos una función que defina que número es mayor entre 2 entregados como parámetros. Los comentarios, como siempre, en negrita, cursiva y entre /* y */: Inicio /* Damos inicio al programa */ Numero num1, num2, mayor; /* Declaramos 3 variables de tipo Número: num1 y num2 que serán 2 números que el usuario ingresará por teclado, y mayor, que será donde se almacenará el número mayor después de que la función nos devuelva el resultado */ principal ( ) { /* Declaramos la función principal del programa */ mostrar(“Por favor ingrese el número 1: “); leer(%numero, &num1); mostrar(“Por favor ahora ingrese el número 2: “); leer(%numero, &num2); /* Mediante mostrar y leer, recibimos por teclado los 2 números ingresados por el usuario */ mayor=numero_mayor(num1, num2); /* A la variable mayor, le asignamos el resultado de llamar a la función numero_mayor, especificada luego de la función principal, pasándole como parámetros las variables num1 y num2 */ mostrar(“El número mayor de los que ingreso es: %numero”, mayor); /* Nuestra variable mayor ya recibió el resultado de la función, así que lo desplegamos */ } numero numero_mayor(numero valor1, numero valor2) { /* Declaramos una función de tipo numero, llamada numero_mayor y que recibe como parámetro 2 variables de tipo numero, llamadas valor1 y valor2, que corresponden a los num1 y num2 enviados desde arriba */ Si(valor1 > valor2) { retornar valor1; } Si no { retornar valor2; } /* Mediante una iteración condiciional, hacemos una comparación entre los 2 números y retornamos el mayor de los 2 para que se le asigne a la variable mayor y se muestre por pantalla al usuario. */ } Fin Con este simple ejemplo hemos podido apreciar un poco el funcionamiento y uso de las funciones en la programación. Hay un importante concepto que hemos utilizado ahora, pero que detallaremos más en profundidad cuando estemos hablando de lenguajes reales, que es el paso de parámetros desde una función a otra (lo que hicimos cuando llamamos a la función y lo que esta recibe por el otro lado). Por ahora no vale la pena entrar en esos detalles, pero ya los veremos más completamente. Con las funciones sucede lo mismo, esta pasada que le hemos dado ahora es bastante superficial, pero iremos cubriendo otros aspectos y descubriendo sus usos completos y más complejos a medida que vayamos programando más y más. Por ahora es una buena técnica ir combinando los otros contenidos que hemos visto en los capítulos anteriores con esto e ir practicando. Por ahora, al siguiente tema. 2.- Últimas consideraciones sobre el Pseudo-código: En estos momentos que estamos llegando al final de nuestra cobertura sobre el pseudo-código o pseudo-lenguaje, es bueno repasar algunas consideraciones antes de adentrarnos al lenguaje real en el que decidamos programar, por ejemplo: 1.- Recordemos que el pseudo-lenguaje no es un lenguaje de programación real, y por ende, lo que hemos cubierto hasta acá no lo encontrarán en libros o puede que aparezca de forma distinta. No se preocupen, el objetivo nunca ha sido ni será que nos convirtamos en expertos de pseudo-código, si no que entendamos como se desarrollan los procedimientos en la programación y como plantearnos soluciones a los problemas mediante el entendimiento de la estructura de los programas. 2.- El pseudo-código, a pesar de no ser un lenguaje real, utiliza un paradigma estructurado y por la forma y palabras que normalmente se uilizan, se asemeja bastante al lenguaje C, por lo que es la opción natural para seguir. Veremos más de esto en el próximo punto. 3.- Lamentablemente, al no tratarse de un lenguaje real, no existe ningún software que podamos utilizar para programar y así ver nuestros errores para poder solucionarlos. Esto por un lado es bueno, ya que agudiza nuestra forma para leer el código y detectar errores, algo que nos servirá de sobremanera más adelante. 4.- Es recomendable que repasemos e intentemos entender de la mejor forma todos los puntos explicados en esta y pasadas ediciones de esta saga. Si bien hemos cubierto una pequeña parte de todo lo que comprende la programación, hasta ahora hemos visto las bases fundamentales para entender los lenguajes reales y todo el resto de aplicaciones dentro de la programación, por lo que entender de la mejor manera estas bases será esencial para que la enseñanza no se complique más adelante. 3.- Entrando a un lenguaje real: Ahora que hemos de alguna forma “terminado” con el pseudo-lenguaje ha llegado un momento importante: Decidir el lenguaje de programación que empezaremos a aprender. Esta decisión no es sencilla, y depende de varios factores, entre ellos el paradigma de programación, la facilidad del lenguaje, la extensibilidad y funcionalidades, actualización con los tiempos e incluso preferencia personal entre muchas otras razones. Al momento de elegir debemos tomar esas consideraciones, aunque también fijarnos en otras como la documentación disponible, grupos de usuarios y todo lo que nos pueda apoyar a que el aprendizaje sea más sencillo. Como experiencia personal, y el camino que seguiremos en esta saga de tutoriales, una de las mejores opciones para continuar es el lenguaje C, esto debido a lo similar que es al pseudo-código que hemos visto y porque ambos comparten el mismo paradigma estructurado, con lo que la transición se hace mucho más sencilla y así es posible pasar a otros lenguajes con mayor facilidad en el futuro. Así que prepárense, que para allá vamos. 4.- Más sobre los paradigmas de programación: Tal como veíamos en este tutorial, actualmente existen 4 paradigmas comunes de programación, como son (ojo que son definiciones básicas, para que nos hagamos la idea de cada uno): Paradigma estructurado: Es el paradigma que hemos estado viendo hasta ahora con el pseudo-lenguaje y que luego veremos con C. Este paradigma, como su nombre lo indica, expresa una declaración y funcionamiento estructurado para sus programas, en donde desde arriba a abajo en una misma “plantilla de programa” debe estar el inicio, la declaración de las variables del programa y las funciones (la principal y otras funciones). Todo definido desde su inicio a su final. Además, los lenguajes estructurados se enfocan principalmente en el tratamiento de datos, recibiéndolos, operando con ellos y mostrando resultados. No tienen más profundidad que eso. Paradigma orientado a objeto: A diferencia del estructurado, en este paradigma, todo se trata como un objeto, cada uno de ellos con atributos, tal como si habláramos de objetos del mundo real. Los lenguajes de POO (programación orientada a objetos), operan mediante distintas clases, que son plantillas que determinan el comportamiento de un objeto. Pueden haber clases donde se determine un objeto, sus atributos y los métodos (parecido a las funciones) que se aplican a ellos y otras clases donde solo se encuentre el método principal (como la función principal). Este es un paradigma mucho más complejo que no queremos detallar por ahora para no confundirnos, porque el paso desde un lenguaje estructurado a uno POO complica al principio, pero no se preocupen, ya lo veremos. Paradigma orientado a eventos: En este paradigma se habla de lenguajes que dentro de un programa, presentan una serie de acciones que están “siempre listas” y se encuentran en espera para dispararse de acuerdo a un evento que ocurra (normalmente ejecutado por un usuario). Por ejemplo, tenemos programas como Word o Excel, que en sus menús y botones cuentan con múltiples mini-programas listos para ejecutarse cuando el usuario presione el botón o seleccione el menú. Por ahora no adentraremos más en esto, por las mismas razones el caso anterior. Paradigma orientado a aspectos: Este es un paradigma que actualmente se encuentra bajo investigación, por lo que no hay gran información disponible. Decidimos mencionarlo más por anécdota que por cubrirlo propiamente tal. Quizás cuando estemos en números futuros de esta saga podamos ir adelantando más información. Con esto podemos tener un poco más claro por qué existen distintos lenguajes de programación y que los diferencia, es principalmente su paradigma. Para casos de esta saga, por las razones antes descritas, seguiremos con el lenguaje C, el cual nos servirá de base para todo el aprendizaje que tendremos que hacer. Por ahora lo dejaremos hasta aquí, ya que hemos cubierto suficiente y es momento de tomar un descanso hasta tutoriales futuros donde ya empezaremos a utilizar un lenguaje real de programación. En la próxima edición: Introducción al lenguaje C. Variables en C. Funciones básicas. Iteraciones condicionales. Esperamos que este tutorial haya sido de utilidad para Uds. Muchas gracias por leer y será hasta una próxima oportunidad. http://www.taringa.net/posts/info/14028919/Como-aprender-a-programar-y-no-morir-en-el-intento_.html http://www.taringa.net/posts/info/14029060/Como-programar-y-no-morir-en-el-intento-parte-2.html http://www.taringa.net/posts/info/14030260/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-3.html http://www.taringa.net/posts/info/14030386/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-4.html http://www.taringa.net/posts/info/14030572/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-5.html http://www.taringa.net/posts/info/14030711/Como-aprender-a-programar-y-no-morir-en-el-intento--Parte-6.html http://www.taringa.net/posts/info/14030957/Como-aprender-a-programar-y-no-morir-en-el-intento-parte-7.html http://www.taringa.net/posts/info/14031158/Como-programar-y-no-morir-en-el-intento-parte-8.html http://www.taringa.net/posts/info/14031158/Como-programar-y-no-morir-en-el-intento-parte-9.html

OPCION 1 <html> <head> <title>Problema</title> </head> <body> <form action="pagina3.php" method="post"> Dígitos verificadores:<img src="pagina2.php"> <br> Ingrese valor: <input type="text" name="numero"> <br> <input type="submit" value="Verificar"> </form> </body> </html> OPCION 2 <?php $ancho=100; $alto=30; $imagen=imageCreate($ancho,$alto); $amarillo=ImageColorAllocate($imagen,255,255,0); ImageFill($imagen,0,0,$amarillo); $rojo=ImageColorAllocate($imagen,255,0,0); $valoraleatorio=rand(100000,999999); session_start(); $_SESSION['numeroaleatorio']=$valoraleatorio; ImageString($imagen,5,25,5,$valoraleatorio,$rojo); for($c=0;$c<=5;$c++) { $x1=rand(0,$ancho); $y1=rand(0,$alto); $x2=rand(0,$ancho); $y2=rand(0,$alto); ImageLine($imagen,$x1,$y1,$x2,$y2,$rojo); } Header ("Content-type: image/jpeg"; ImageJPEG ($imagen); ImageDestroy($imagen); ?> OPCION 3 <?php session_start(); ?> <html> <head> <title>Problema</title> </head> <body> <?php if ($_SESSION['numeroaleatorio']==$_REQUEST['numero']) echo "Ingresó el valor correcto"; else echo "Incorrecto"; ?> </body> </html>

Con las Fiestas Patrias ya quedando atrás, y luego de una tonelada algunos tutoriales de cocina que les dejamos en estos días, volvemos un poco más a la normalidad en Como Lo Hago, y que mejor que trayéndoles la segunda parte de esta saga de tutoriales que hemos estado preparando para aquellos que quieren adentrarse en el mundo de la programación. Bueno sin más preambulo les digo, que como siempre, todo el detalle está después del salto. Cómo aprender a programar y no morir en el intento – Parte 2 Nota: Si por alguna razón se perdieron la primera parte de esta saga, pueden leerla en este enlace. Tenemos harto que aprender hoy, y un recuento de lo pasado sería solo acumular líneas, así que vamos, manos a la obra: Contenidos: Tal como lo prometimos en el tutorial anterior, hoy veremos los siguientes temas: Áreas de memoria alias “Como almacena un computador la información”. Introducción al Pseudo-Código. Haciendo nuestro primer programa. ¿Listos?, ¿Fueron a buscar bebida?, yo no he ido, así que esperenme -> !. 1.-Áreas de memoria. Quizás para gente más experimentada en el tema de la programación, pueda parecer algo repentino entrar a esto tan luego, pero hay una razón de fondo que es empezar a relacionarnos con el concepto de las variables de cierta forma. Pero bueno, ¿Qué son las áreas de memoria?. Para contestar esta pregunta, nos haremos otra, ¿Cómo almacena la información una máquina/equipo/computador?. Básicamente lo hace de 2 formas, o mediante el uso de 2 tipos de memoria: la volátil y la no volátil. La memoria volátil es toda aquella que una vez que apagamos el computador se vacía (Ej: Memoria RAM). Tiene la ventaja de ser de mayor acceso (lectura/escritura) y obviamente la desventaja de que su almacenamiento no es “permanente”. Por su lado la memoria no volátil es justamente lo contrario a la anterior, ya que una vez que almacenamos información ahí, quedará hasta que decidamos borrarla o “alguien” lo decida por nosotros. Ejemplos de memoria no volátil son los almacenamientos magnéticos (discos duros) o los ópticos (CD, DVD, etc). En la programación se utilizan ambos tipos de memoria. Por un lado se utiliza la memoria volátil para el trabajo con variables (explicaremos eso en detalle) y por otro lado la memoria no volátil cuando estamos trabajando con archivos o en otras situaciones que iremos viendo a medida que ocurran. En una representación gráfica, la memoria volátil que utiliza la programación (RAM), sería algo como esto, guardando las proporciones: Cada cuadradito representa un área de memoria, el cual posee una dirección expresada en valores hexadecimales (algo por ejemplo como FA2246) la cual se llama dirección de memoria, y es utilizada cuando se quiere acceder a los datos almacenados en ese “cuadradito”. ¿Se acuerdan esa vez que les dijimos que explicaríamos las variables en detalle?, que tiempos aquellos ¿no?, bueno el momento es ahora. Las variables Esta definición no intenta ser técnica ni mucho menos. Solo pretendemos que el concepto quede claro para que lo intentamos lograr. Una variable es un “enlace contenedor” de y a un dato. ¿Por qué enlace contenedor?, porque una variable esta relacionada a una dirección de memoria, por ende enlace, y contiene un valor correspondiente a un dato que podemos recibir o tomar de otro lado (usuario, otra variable, el resultado de una operación, etc), ergo contenedor. Esta definición se irá haciendo más clara a medida que vayamos avanzando. Las variables tienen ciertas características, como son: Nombre: Corresponde al identificador de la variable. Los nombres de variables dentro de un programa deben ser únicos, no empezar con un número, no contener símbolos y respetar las palabras reservadas dentro de un lenguaje de programación (Por ej: En Java, la palabra new es reservada, por lo que no se puede nombrar una variable así). Tipo: Corresponde al tipo de datos que podrán almacenarse en la variable. Si bien en lenguajes como PHP no es necesario definir el tipo, la mayoría de los otros lenguajes lo piden. Los tipos más comunes son: Int: Corresponde a números enteros (correspondiente al universo Z de las matemáticas). El rango que abarca (valores máximos y mínimos que se les puede dar) varía del lenguaje en uso. Existen 2 variaciones comunes como son el short int o short y el long int o long. Varían en el rango. Float: Corresponde a valores de punto flotante (números decimales correspondientes al universo Q de las matemáticas). En algunos lenguajes se puede utilizar como double, short double o long double. Su rango difiere del lenguaje a utilizar. Char: Corresponde a valores de caractéres alfanuméricos (0 a 9 y abecedario). Solo se puede almacenar un valor dentro de este tipo de variables. Boolean: Corresponden a valores de tipo lógico. Almacenan sólo 2 posibles valores: true o false. String: Corresponde a una cadena de caractéres, por ejemplo una palabra o frase. Su rango depende de cada lenguaje. Además debemos tener presente que las variables pueden cambiar su valor a lo largo del programa (a no ser que sean definidas como constantes, ya veremos eso más adelante) y existen observaciones sobre las operaciones que ejecutamos sobre ellas. Estos puntos los detallaremos más adelante. Dejando esa definición un poco más clara, volvemos al tema de las áreas de memoria. Cuando creamos una variable, o bien la definimos, el equipo le asigna automáticamente un área de memoria en la cual almacenará su valor. En caso de sobrepasar el área asignada, se le asignará una nueva área de memoria, y así sucesivamente. Esta sección de las áreas de memoria irá quedando cada vez más clara según vayamos avanzando. 2.- Introducción al Pseudo-Código El Pseudo-Código, como su nombre lo indica, es una especie de “lenguaje de programación” utilizado para introducir a los futuros programadores a la estructura de la realización de programas. En él, se utilizan todos los recursos de un lenguaje de programación normal, a pesar de que los nombres y conceptos puedan variar dependiendo de quien lo enseñe, y se busca principalmente practicar un poco la lógica que posteriormente debemos implementar. Lo principal que se debe entender, es que a pesar de establecer algunas reglas sobre como se operará con el pseudo-código, los únicos errores que se pueden cometer son de lógica y no como expresamos las distintas funcionalidades del programa, así que hay que irse sintiendo lo suficientemente libres para experimentar. Antes de entrar de lleno a este tema, es bueno detenernos y explicar un poco el tema de los paradigmas de programación. Paradigmas de programación En la programación existen una serie de paradigmas que se refieren principalmente al enfoque que le daremos a un problema para solucionarlo o bien “la forma en que veremos las cosas”. Los paradigmas más comunes son: Paradigma de programación estructurada. Paradigma de programación orientada a objetos. Paradigma de programación orientada a eventos. Paradigma de programación orientada a aspectos. Para las primeras etapas de estas guías nos enfocaremos en el paradigma estructurado. A medida que vayamos avanzando nos interiorizaremos más en esto. Volviendo al tema del Pseudo-código, y habiendo establecido el punto de los paradigmas, veamos el formato clásico y básico de un programa: Inicio Definición/declaración de variables Cuerpo del programa Fin A medida que vayamos haciendo programas más complejos veremos como este formato se va a ampliando. Una explicación de las partes: Inicio: Se refiere al comienzo del programa. Definición/declaración de variables: Aquí indicamos todas las variables que utilizaremos para la realización de nuestro programa, junto con su tipo y en algunos casos, su valor inicial. Cuerpo del programa: Aquí irá el desarrollo de nuestro programa, indicando información que recolectaremos, operaciones y salidas (entrega de información). Fin: Se refiere al fin del programa. Cumpliendo esos pasos básicos, podemos empezar a hacer nuestros primeros programas. Así que a tomar una hoja de papel, un lápiz y una goma, porque de seguro deberemos borrar más de alguna cosa por ahí. 3.- Haciendo nuestro primer programa Para hacer nuestro “bautizo oficial” en el mundo de la programación, partiremos por realizar el ejercicio más clásico que aparece en todos los libros de programación de aquí a la eternidad, el famoso “Hola mundo”. En este programa lo que haremos será simplemente mostrar un mensaje en pantalla que diga “Hola Mundo”. El código a continuación, y los comentarios van en negritas, cursiva y entremedio de /* y */. Ejercicio 1: Hola Mundo Inicio /* Establecemos el inicio del programa */ Principal( ) /* Definimos la función “Principal” que es donde irá el cuerpo del programa. Ya adentraremos el tema de las funciones */ mostrar “Hola Mundo”; /* Utilizamos la sentencia “mostrar” para enviar un mensaje que se despliegue en pantalla y entre comillas la frase que mostraremos, en este caso “Hola Mundo”. Luego de la sentencia ponemos un punto y coma para indicar el fin de esta, algo que utilizaremos mucho cuando estemos programando en algún lenguaje, ya que eso le indica al entorno de programación que es el fin de la sentencia */ Fin /* Finalizamos el programa */ Y así de simple. Hemos hecho nuestro primer programa enviando un mensaje “Hola Mundo” que se mostrará en la pantalla. Para este programa, como solo mostramos un mensaje, podrán ver que no hicimos uso de variables, por eso nos saltamos la parte de la definición de ellas. En posteriores ejercicios haremos uso de eso. Por hoy ya hemos visto bastante, así que es momento de asimilar la información y descansar un poco. Para recapitular, hoy hemos aprendido sobre: Áreas de memoria. Variables. Pseudo-código. Paradigmas de programación. Hicimos nuestro primer programa. ¿Bastante, no?, pues bueno, en la próxima guía nos enfocaremos principalmente en más sobre Pseudo-código: Definición de variables. Leyendo datos desde teclado (ingresados por el usuario). Iteraciones condicionales (Si, Si no). Ciclos o búcles. En una próxima edición, a la misma batihora y en el mismo baticanal. Por ahora es mi deber recordar que como siempre, este tutorial ha sido desarrollado, probado y documentado por el equipo de Como Lo Hago por lo que cuenta con nuestro infalible y a veces programable Sello de garantía. Cualquier comentario, problema o duda que puedan tener, sientanse libre de dejarnos unas líneas en el área habilitada a continuación. Esperamos que este tutorial haya sido de utilidad para Uds. Muchas gracias por leer y será hasta una próxima oportunidad.