tag:blogger.com,1999:blog-61472410357185338812024-03-12T18:15:04.182-07:00Obed_LLPObed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.comBlogger34125tag:blogger.com,1999:blog-6147241035718533881.post-44255966110434618612010-11-23T11:27:00.000-08:002010-11-23T11:31:18.357-08:00Calculo Lambda<strong>Materia: Lenguajes de Programacion.</strong><br />
<br />
<br />
<span style="color: red;">Introduccion.</span><br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj9gG-uG5R1ryZ3LFv-mSnlogc5kBgooTz5N6q2xabCpojyFjPDAz_ps7A8qi6erRMLCPhJVBTGb6TQb72OvxDep3ahe5Gbwzk4Bs9HL51N1vpQtuomkO8pXa2QueuAylXAyMhkemB8fLE/s1600/imagesCAM3UFTU.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="118" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj9gG-uG5R1ryZ3LFv-mSnlogc5kBgooTz5N6q2xabCpojyFjPDAz_ps7A8qi6erRMLCPhJVBTGb6TQb72OvxDep3ahe5Gbwzk4Bs9HL51N1vpQtuomkO8pXa2QueuAylXAyMhkemB8fLE/s200/imagesCAM3UFTU.jpg" width="200" /></a></div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">El cálculo lambda es un sistema formal diseñado para investigar la definición de función, la noción de aplicación de funciones y la recursión. Fue introducido por Alonzo Church y Stephen Kleene en la década de 1930; Church usó el cálculo lambda en 1936 para resolver el Entscheidungsproblem. Puede ser usado para definir de manera limpia y precisa qué es una "función computable". El interrogante de si dos expresiones del cálculo lambda son equivalentes no puede ser resuelto por un algoritmo general. Esta fue la primera pregunta, incluso antes que el problema de la parada, para el cual la indecidibilidad fue probada. El cálculo lambda tiene una gran influencia sobre los lenguajes funcionales, como Lisp, ML y Haskell.</div><br />
Se puede considerar al cálculo lambda como el más pequeño lenguaje universal de programación. Consiste en una regla de transformación simple (sustitución de variables) y un esquema simple para definir funciones.<br />
<br />
El cálculo lambda es universal porque cualquier función computable puede ser expresada y evaluada a través de él. Por lo tanto, es equivalente a las máquinas de Turing. Sin embargo, el cálculo lambda no hace énfasis en el uso de reglas de transformación y no considera las máquinas reales que pueden implementarlo. Se trata de una propuesta más cercana al software que al hardware.<br />
<br />
<span style="color: red;">Explicacion breve:</span><br />
<br />
El cálculo lambda es un formalismo para representar funciones, cuyo poder expresivo es equivalente a la máquina de Turing universal. <br />
<br />
El cálculo lambda trabaja con objetos llamados lambda-términos, que son cadenas de símbolos de una de las formas siguientes: <br />
<br />
• v <br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div>• λv.E1 <br />
<br />
• (E1 E2) <br />
<br />
donde v es un nombre de variable tomado de un conjunto infinito predefinido de nombres de variables, y E1 y E2 son lambda-términos. Los términos de la forma λv.E1 son llamadas abstracciones. La variable ν se llama el parámetro formal de la abstracción, y E1 es el cuerpo de la abstracción. <br />
<br />
El término λv.E1 representa la función que, si es aplicada a un argumento, liga el parámetro formal v al argumento y entonces computa el valor resultante de E1--- esto es, retorna E1, con cada ocurrencia de ν sustituido por el argumento. <br />
<br />
Los términos de la forma (E1 E2) son llamados aplicaciones. Las aplicaciones modelan la invocación o ejecución de una función: La función representada por E1 es invocada, con E2 como su argumento, y se computa el resultado. Si E1 (a veces llamado el aplicando) es una abstracción, el término puede ser reducido: E2, el argumento, se puede sustituir en el cuerpo de E1 en lugar del parámetro formal de E1, y el resultado es un nuevo término lambda que es equivalente al antiguo. Si un término lambda no contiene ningún subtérmino de la forma (λv.E1 E2) entonces no puede ser reducido, y se dice que está en forma normal. <br />
<span style="color: red;">Historia</span><br />
<br />
Originalmente, Church había tratado de construir un sistema formal completo para modelizar la matemática; pero cuando este se volvió susceptible a la paradoja de Russell, separó del sistema al cálculo lambda y lo usó para estudiar la computabilidad, culminando en la respuesta negativa al problema de la parada.<br />
<br />
<span style="color: red;">Sintáxis</span><br />
<br />
En el cálculo lambda, una expresión o término se define recursivamente a través de las siguientes reglas de formación:<br />
<br />
1. Toda variable es un término: x, y, z, u, v, w, x1, x2, y9,...<br />
<br />
2. Si t es un término y x es una variable, entonces (λx.t) es un término (llamado una abstracción lambda).<br />
<br />
3. Si t y s son términos, entonces (ts) es un término (llamado una aplicación lambda).<br />
<br />
4. Nada más es un término.<br />
<br />
Según estas reglas de formación, las siguientes cadenas de caracteres son términos:<br />
<br />
x<br />
<br />
(xy)<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjqQD6b73XOUldtWfjC4XQKBvC9H2Q5QEQTjK5vOa3-7gKUGbLTI0cUDsw9BuUFXlcxE4fISx1okWJoRzsqJPEt6Jfo5GsJ77b4BM_hC0s7S3qFG7FlVPVAmiHiDm-62_sPhABLxOscbOY/s1600/lisp-glossy.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="138" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjqQD6b73XOUldtWfjC4XQKBvC9H2Q5QEQTjK5vOa3-7gKUGbLTI0cUDsw9BuUFXlcxE4fISx1okWJoRzsqJPEt6Jfo5GsJ77b4BM_hC0s7S3qFG7FlVPVAmiHiDm-62_sPhABLxOscbOY/s200/lisp-glossy.jpg" width="200" /></a></div>(((xz)y)x)<br />
<br />
(λx.x)<br />
<br />
((λx.x)y)<br />
<br />
(λz.(λx.y))<br />
<br />
((x(λz.z))z)<br />
<br />
Por convención se suelen omitir los paréntesis externos, ya que no cumplen ninguna función de desambiguación. Por ejemplo se escribe (λz.z)z en vez de ((λz.z)z), y se escribe x(y(zx)) en vez de (x(y(zx))). Además se suele adoptar la convención de que la aplicación de funciones es asociativa hacia la izquierda. Esto quiere decir, por ejemplo, que xyzz debe entenderse como (((xy)z)z), y que (λz.z)yzx debe entenderse como ((((λz.z)y)z)x).<br />
<br />
Las primeras dos reglas generan funciones, mientras que la última describe la aplicación de una función a un argumento. Una abstracción lambda λx.t representa una función anónima que toma un único argumento, y se dice que el signo λ liga la variable x en el término t. En cambio, una aplicación lambda ts representa la aplicación de un argumento s a una función t. Por ejemplo, λx.x representa la función identidad x → x, y (λx.x)y representa la función identidad aplicada a y. Luego, λx.y representa la función constante x → y, que develve y sin importar qué argumento se le dé.<br />
<br />
Las expresiones lambda no son muy interesantes por sí mismas. Lo que las hace interesantes son las muchas nociones de equivalencia y reducción que pueden ser definidas sobre ellas.<br />
<br />
<span style="color: red;">Variables libres y ligadas</span><br />
<br />
Las apariciones (ocurrencias) de variables en una expresión son de tres tipos:<br />
<br />
1. Ocurrencias de ligadura (binders)<br />
<br />
2. Ocurrencias ligadas (bound occurrences)<br />
<br />
3. Ocurrencias libres (free occurrences)<br />
<br />
Las variables de ligadura son aquellas que están entre el λ y el punto. Por ejemplo, siendo E una expresión lambda:<br />
<br />
(λ x y z. E) Los binders son x,y y z.<br />
<br />
El binding de ocurrencias de una variable está definido recursivamente sobre la estructura de las expresiones lambda, de esta manera:<br />
<br />
1. En expresiones de la forma V, donde V es una variable, V es una ocurrencia libre.<br />
<br />
2. En expresiones de la forma λ V. E, las ocurrencias son libres en E salvo aquellas de V. En este caso las V en E se dicen ligadas por el λ antes V.<br />
<br />
3. En expresiones de la forma (E E′), las ocurrencias libres son aquellas ocurrencias de E y E′.<br />
<br />
Expresiones lambda tales como λ x. (x y) no definen funciones porque las ocurrencias de y están libres. Si la expresión no tiene variables libres, se dice que es cerrada.<br />
<br />
Como se permite la repetición del identificador de variables, cada binding tiene una zona de alcance asociada (scope de ahora en adelante) Un ejemplo típico es: (λx.x(λx.x))x, donde el scope del binding más a la derecha afecta sólo a la x que tiene ahí, la situación del otro binding es análoga, pero no incluye el scope de la primera. Por último la x más a la derecha está libre. Por lo tanto, esa expresión puede reexpresarse así (λy.y(λz.z))x.<br />
<br />
<span style="color: red;">α-conversión</span><br />
<br />
La regla de alfa-conversión fue pensada para expresar la idea siguiente: los nombres de las variables ligadas no son importantes. Por ejemplo λx.x y λy.y son la misma función. Sin embargo, esta regla no es tan simple como parece a primera vista. Hay algunas restricciones que hay que cumplir antes de cambiar el nombre de una variable por otra. Por ejemplo, si reemplazamos x por y en λx.λy.x, obtenemos λy.λy.y, que claramente, no es la misma función. Este fenómemo se conoce como captura de variables.<br />
<br />
La regla de alfa-conversión establece que si V y W son variables, E es una expresión lambda, y<br />
<br />
E[V := W]<br />
<br />
representa la expresión E con todas las ocurrencias libres de V en E reemplazadas con W, entonces<br />
<br />
λ V. E == λ W. E[V := W]<br />
<br />
si W no está libre en E y W no está ligada a un λ donde se haya reemplazado a V. Esta regla nos dice, por ejemplo, que λ x. (λ x. x) x es equivalente a λ y. (λ x. x) y.<br />
<br />
En un ejemplo de otro tipo, se ve que<br />
<br />
for (int i = 0; i < max; i++) { proc (i); }<br />
<br />
es equivalente a<br />
<br />
for (int j = 0; j < max; j++) { proc (j); }<br />
<br />
<span style="color: red;">β-reducción</span><br />
<br />
La regla de beta reducción expresa la idea de la aplicación funcional. Enuncia que<br />
<br />
((λ V. E) E′) == E[V := E′]<br />
<br />
si todas las ocurrencias de E′ están libres en E[V := E′].<br />
<br />
Una expresión de la forma ((λ V. E) E′) es llamada un beta redex. Una lambda expresión que no admite ninguna beta reducción se dice que está en su forma normal. No toda expresión lambda tiene forma normal, pero si existe, es única. Más aún, existe un algoritmo para computar la formal normal: la reducción de orden normal. La ejecución de este algoritmo termina si y sólo si la expresión lambda tiene forma normal. El teorema de Church-Rosser nos dice que dos expresiones reducen a una misma si y sólo si son equivalentes (salvo por el nombre de sus variables ligadas)<br />
<br />
<span style="color: red;">η-conversión</span><br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj-mt8jIiSvcTcyp_FBmthblFHtAiiS0Ard6vjDqv6wy5Hzm367aVfepKPr9Njs_HkEm44yxZlh5ygz8WD1tY99kiqHZt6s7bRRfOl1P4eKvelP0DE-xCSywTgdhsKLDl4VZ_fmy-y-C0o/s1600/BlueHaskellLogo.png" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="77" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj-mt8jIiSvcTcyp_FBmthblFHtAiiS0Ard6vjDqv6wy5Hzm367aVfepKPr9Njs_HkEm44yxZlh5ygz8WD1tY99kiqHZt6s7bRRfOl1P4eKvelP0DE-xCSywTgdhsKLDl4VZ_fmy-y-C0o/s200/BlueHaskellLogo.png" width="200" /></a></div>Es la tercer regla, eta conversión, que podría ser añadida a las dos anteriores para formar una nueva relación de equivalencia. La eta conversión expresa la idea de extensionalidad, que en este contexto implica que dos funciones son la misma si y solo si dan el mismo resultado para cualquier argumento. La eta conversión convierte entre λ x. f x y f siempre que x no aparezca sola en f. Esto puede ser entendido como equivalente a la extensionalidad así:<br />
<br />
Si f y g son extensionalmente equivalentes, es decir, si f a== g a para cualquier expresión lambda a entonces, en particular tomando a como una variable x que no aparece sola en f ni en g, tenemos que f x == g x y por tanto λ x. f x == λ x. g x, y así por eta conversión f == g. Entonces, si aceptamos la eta conversión como válida, resulta que la extensionalidad es válida.<br />
<br />
Inversamente, si aceptamos la extensionalidad como válida entonces, dado que por beta reducción de todo y tenemos que (λ x. f x) y == f y, resulta que λ x. f x == f; es decir, descubrimos que la eta conversión es válida.<br />
<br />
Bibliografias:<br />
<br />
<a href="http://es.wikipedia.org/wiki/C%C3%A1lculo_lambda">http://es.wikipedia.org/wiki/C%C3%A1lculo_lambda</a><br />
<br />
<a href="http://enciclopedia.us.es/index.php/C%C3%A1lculo_lambda">http://enciclopedia.us.es/index.php/C%C3%A1lculo_lambda</a><br />
<br />
<div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjqQD6b73XOUldtWfjC4XQKBvC9H2Q5QEQTjK5vOa3-7gKUGbLTI0cUDsw9BuUFXlcxE4fISx1okWJoRzsqJPEt6Jfo5GsJ77b4BM_hC0s7S3qFG7FlVPVAmiHiDm-62_sPhABLxOscbOY/s1600/lisp-glossy.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"></a></div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-11011281869044571772010-11-23T11:16:00.000-08:002010-11-23T11:16:04.223-08:00Smalltalk<span style="color: black;"><strong>Materia: Lenguajes de Programacion.</strong></span><br />
<span style="color: red;">Introduccion.</span><br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhMdNEmNMXXtsIB89eN4TKkTKq72QmkBpdXR5jch1r5mygXPtL4BmT6vc6ORfPT449s15ldzCrRxKVlWmaDHfwtBhYz71P-YG8mxC_6vf44own9uFkclGxgzpFGJ9vnnydIGLsKYgEVKvs/s1600/byte_smalltalk1.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhMdNEmNMXXtsIB89eN4TKkTKq72QmkBpdXR5jch1r5mygXPtL4BmT6vc6ORfPT449s15ldzCrRxKVlWmaDHfwtBhYz71P-YG8mxC_6vf44own9uFkclGxgzpFGJ9vnnydIGLsKYgEVKvs/s200/byte_smalltalk1.jpg" width="135" /></a></div><br />
Smalltalk es un lenguaje de programacion que pernite realizar tareas de computacion mediante la interaccion con un entorno de objetos virtuales. Metaforicamente, se puede considerar que un smalltalk es un mundo virtual donde viven objetos que se comunican mediante el envio de mensajes.<br />
<span style="color: red;">Un sistema de Smalltalk esta compuesto por:</span><br />
<br />
• Maquina virtual. <br />
<br />
• Imagen virtual que contiene todos los objetos del sistema. <br />
<br />
• Lenguaje de programacion ( tambien conocido como Smalltalk). <br />
<br />
• Biblioteca de objetos reusables. <br />
<br />
• Opcionalmente un entorno de desarrollo que funciona como un sistema en tiempo de ejecucion. <br />
<br />
<span style="color: red;">Historia del Smalltalk</span><br />
<br />
Los origenes de Smalltalk se encuentran en las investigaciones realizadas por Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg y otros durante los años setenta en el Palo Alto Research Institute de Xerox (conocido como Xerox PARC), para la creacion de un sistema informatico orientado a la educacion. El objetivo era crear un sistema que permitiese expandir la creatividad de sus usuarios proporcionando un entorno para la experimentacion, creacion e investigacion.<br />
<br />
Smalltalk es considerado el primero de los lenguajes orientados a objetos (OOP), aunque en realidad el primero en implementar programacion orientada a objetos fue Simula. En Smalltalk todo es un objeto, incluidos los numeros reales o el propio entorno de Smalltalk.<br />
<br />
<span style="color: red;">Terminología</span><br />
<br />
Un programa Smalltalk consiste únicamente de objetos, un concepto que se utiliza universalmente dentro de todo sistema Smalltalk. Prácticamente todo, desde un número natural como el 4 hasta un servidor web es considerado un objeto. Los objetos Smalltalk presentan características comunes<br />
<br />
• Tienen una memoria propia.<br />
<br />
• Poseen capacidad para comunicarse con otros objetos.<br />
<br />
• Poseen la capacidad de heredar características de objetos ancestros.<br />
<br />
• Tienen capacidad de procesamiento.<br />
<br />
Los objetos se comunican entre sí mediante el envío de mensajes.. Asimismo, un objeto puede proveer muchas operaciones (actualmente esto está determinado por cada implementación)<br />
<br />
Las definiciones de estas operaciones en los objetos son llamadas métodos. Un método especifica la reacción de un objeto cuando recibe un mensaje que es dirigido a ese método. La resolución (en el sentido de ligado) de un mensaje a un método es dinámica. La colección entera de métodos de un objeto es llamada protocolo de mensajes o interfaz de mensajes del objeto. Los mensajes pueden ser parametrizados, estos parámetros serán objetos, y el resultado o respuesta del mismo también será un objeto.<br />
<br />
Las características comunes de objetos está capturado bajo la noción de clase, de tal forma que los objetos agrupados bajo una clase son llamados instancias de ella. Las instancias son creadas durante la ejecución de un programa con algún propósito y son barridos automáticamente en el momento que no son necesitados más por el recolector de basura. Exceptuando algunos objetos especiales como los muy simples, llamados literales (números, cadenas, etc), cada objeto tiene su propio estado local y representa una instancia diferente de su clase.<br />
<span style="color: red;">Como lenguaje tiene las siguientes caracteristicas:</span><br />
<br />
• Orientacion a objetos pura. <br />
<br />
• Tipado dinamico. <br />
<br />
• Interraccion entre objetos mediante el envio de mensajes. <br />
<br />
• Herencia simple y con raiz comun. <br />
<br />
• Reflexion computacional completa. <br />
<br />
• Recolleccion de basura. <br />
<br />
• Compilacion en tiempo de ejecucion o interpretado (Dependieno de la distribucion o de el proveedor). <br />
<br />
• Multiplies implementaciones. <br />
<br />
La sintaxis de Smalltalk-80 tinde a ser minimilista. Esto significa que existe un grupo chico de palabras reservadas y declaraciones en comparacion con la mayoria de los lenguajes populares.Smalltalk posee un grupo de 5 palabras reservadas: self, nil, super, true y false.<br />
<br />
<span style="color: red;">Parte de la funcionalidad básica:</span><br />
Todas las estructuras de datos Smalltalk se representó, como objetos, y un rico repertorio de estos se encuentra disponible en su biblioteca de clases.<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhEGUoDyd4t224aSTKJVfTOJmWCwyVU0HTa4epBXKfEyPWyB7eHNgLaYzszSub8uKPgIkpoP24PyZAbkB2WFLdzyLnRpYsN9SmGn_t1Km-qWIMovx1WsW6DS_-dcvaTMFkKrn1zcAXNyBA/s1600/stShot9.gif" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="156" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhEGUoDyd4t224aSTKJVfTOJmWCwyVU0HTa4epBXKfEyPWyB7eHNgLaYzszSub8uKPgIkpoP24PyZAbkB2WFLdzyLnRpYsN9SmGn_t1Km-qWIMovx1WsW6DS_-dcvaTMFkKrn1zcAXNyBA/s200/stShot9.gif" width="200" /></a></div><br />
<br />
Object es la raíz de la herencia de la jerarquía de Smalltalk, proporcionando una funcionalidad básica a todos los objetos. Class Collection es una de las muchas subclases de objetos de clase, sino que pueden ser más especializada en una amplia gama de estructuras de datos. Establece son sólo uno de ellos, con diccionarios como una subclase. Los diccionarios se utilizan para almacenar las asociaciones entre pares de objetos. El código siguiente muestra el uso de estas estructuras de datos en un ejemplo sencillo. En primer lugar se define el diccionario, la asociación de algunos viejos amigos con una selección de las virtudes. Los mensajes se envían a este objeto, lista y la búsqueda de claves.<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgIr39S6TSkp-pwusSKXM5OD_W9UarAqj0WrNxn9BH9t-CvN68foUcuEb-i-WTs88DdJNBQ1dBLQIojHyyiSsVgXECZjMWCXHNf6V9JqnSWxypzZDj0G9WxUhwkkWDkSntjmm4ThQ_udSk/s1600/stShot10.gif" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="172" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgIr39S6TSkp-pwusSKXM5OD_W9UarAqj0WrNxn9BH9t-CvN68foUcuEb-i-WTs88DdJNBQ1dBLQIojHyyiSsVgXECZjMWCXHNf6V9JqnSWxypzZDj0G9WxUhwkkWDkSntjmm4ThQ_udSk/s200/stShot10.gif" width="200" /></a></div><br />
<br />
Smalltalk se adhiere a una interpretación muy estricta de la orientación a objetos, e incluso las estructuras de control se implementan como patrones de mensaje. Selección de los caminos alternativos de ejecución es por tanto el apoyo a través de ifTrue: ifFalse,:, y ifFalse: ifTrue: mensajes. Loops se puede especificar con whileTrue: whileFalse,:, timesRepeat:, no: a: hacer:, recoger: oa través de la recursividad. Smalltalk utiliza la noción de bloques de aplazar la evaluación. Los bloques pueden tener argumentos, puede tener variables temporales, y se utilizan para encapsular código que pueden ser evaluados más adelante. Entre otras cosas que son comúnmente usados como argumentos para controlar las estructuras. Puesto que son los propios objetos, los bloques pueden ser obligados a identificadores. El mensaje de valor de las fuerzas de la ejecución de un bloque.<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEirN7hdD1Sg_cuHkwiIqDCf1CRNieffGoYyKQvCuJiNmO-JssMJOq5apOKzuW3icXyoMszp1ICfJwueBZzSnfrgRzvD9nxvK6IaV5n_dvv9ndFldsQBJiUtJXg6BsUrR1VpcfGGS72edPM/s1600/stShot11.gif" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEirN7hdD1Sg_cuHkwiIqDCf1CRNieffGoYyKQvCuJiNmO-JssMJOq5apOKzuW3icXyoMszp1ICfJwueBZzSnfrgRzvD9nxvK6IaV5n_dvv9ndFldsQBJiUtJXg6BsUrR1VpcfGGS72edPM/s200/stShot11.gif" width="188" /></a></div><br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://es.wikipedia.org/wiki/Smalltalk<br />
<br />
<a href="http://www.cosc.canterbury.ac.nz/wolfgang.kreutzer/cosc205/smalltalk1.html">http://www.cosc.canterbury.ac.nz/wolfgang.kreutzer/cosc205/smalltalk1.html</a>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-36192353471357213492010-11-23T10:56:00.000-08:002010-11-23T10:56:05.006-08:00Paradigmas de Programacion.<div class="MsoNormal" style="margin: 0cm 0cm 10pt; tab-stops: 114.6pt;"><span style="font-family: "Times New Roman", "serif"; font-size: 12pt; line-height: 115%; mso-fareast-font-family: "Times New Roman"; mso-fareast-language: ES-MX;"><strong>Materia: Lenguajes de Programacion.</strong></span></div><span style="color: red;">Que significa paradigma?</span><br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgeholGvThyyvx1cJtb_apCVeOSzAPTc2NtzjRp20YVPC8EIAgdI_SN5c_fHXXCO0AjmyiwatEZN5G7Vbq1J2qgbwanoFdFoeOrEZWgTNlh2z_OOPnnJK-kFDccuzM6h4MVU64OHOR_AYE/s1600/paradigma.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgeholGvThyyvx1cJtb_apCVeOSzAPTc2NtzjRp20YVPC8EIAgdI_SN5c_fHXXCO0AjmyiwatEZN5G7Vbq1J2qgbwanoFdFoeOrEZWgTNlh2z_OOPnnJK-kFDccuzM6h4MVU64OHOR_AYE/s200/paradigma.jpg" width="197" /></a></div>Paradigma es un modelo o patrón en cualquier disciplina científica u otro contexto epistemológico. El concepto fue originalmente específico de la gramática; en 1900 el diccionario Merriam-Webster definía su uso solamente en tal contexto, o en retórica para referirse a una parábola o a una fábula. En lingüística, Ferdinand de Saussure ha usado paradigma para referirse a una clase de elementos con similitudes.<br />
<br />
<span style="color: red;">Introduccion.</span><br />
<br />
Un paradigma de programación es una propuesta tecnológica que es adoptada por una comunidad de programadores cuyo nucleo central es incuestionable en cuanto a que unívocamente trata de resolver uno o varios problemas claramente delimitados. La resolución de estos problemas debe suponer consecuentemente un avance significativo en almenos un parámetro que afecte a la ingeniería de software. Tiene una estrecha relación con la formalización de determinados lenguajes en su momento de definición. Un paradigma de programación está delimitado en el tiempo en cuanto a aceptación y uso ya que nuevos paradigmas aportan nuevas o mejores soluciones que la sustituyen parcial o totalmente.<br />
<br />
A paradigma de programación es un estilo fundamental de programación de la computadora. (Compare con una metodología, que es un estilo de solucionar específico tecnología de dotación lógica problemas).<br />
<span style="color: red;">Ejemplo:</span><br />
<br />
Probablemente el paradigma de programación que actualmente es el más usado a todos los niveles es la orientación a objeto. El núcleo central de este paradigma es la unión de datos y procesamiento en una entidad llamada "objeto", relacionable a su vez con otras entidades "objeto".<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjU8mAmHhlAMfI313HuYaOKLKDbn-y5MFgylOPdKn5VJX9twrSzuiVmV9is6XM5SuTINlIA2ZDhXKchKW_cxa0FjPKlH4Wz73wElXnb3lrbTRfHEivtiuK_NR6rPpfdDhtl6E8gyLgKmsQ/s1600/byte_smalltalk1.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjU8mAmHhlAMfI313HuYaOKLKDbn-y5MFgylOPdKn5VJX9twrSzuiVmV9is6XM5SuTINlIA2ZDhXKchKW_cxa0FjPKlH4Wz73wElXnb3lrbTRfHEivtiuK_NR6rPpfdDhtl6E8gyLgKmsQ/s200/byte_smalltalk1.jpg" width="135" /></a></div><br />
Tradicionalmente datos y procesamiento se han separado en áreas diferente del diseño y la implementación de software. Esto provocó que grandes desarrollos tuvieran problemas de fiabilidad, mantenimiento, adaptación a los cambios y escalabilidad. Con la orientación a objetos y características como el encapsulado, polimorfismo o la herencia se permitió un avance significativo en el desarrollo de software a cualquier escala de producción.<br />
<br />
La orientación a objeto parece estar ligado en sus origenes con lenguajes como Lisp y Simula aunque el que acuño el título de programación orientada a objetos fué Smaltalk.<br />
<br />
Tipos de paradigmas de programación más comunes<br />
<br />
• Imperativo o por procedimientos: es considerado el más común y está representado, por ejemplo, por C o BASIC.<br />
<br />
• Funcional: está representado por Scheme o Haskell. Este es un caso del paradigma declarativo.<br />
<br />
• Lógico: está representado por Prolog. Este es otro caso del paradigma declarativo.<br />
<br />
• Declarativo: por ejemplo la programación funcional, la programación lógica, o la combinación lógico-funcional.<br />
<br />
• Orientado a objetos: está representado por Smalltalk, un lenguaje completamente orientado a objetos.<br />
<br />
Si bien puede seleccionarse la forma pura de estos paradigmas al momento de programar, en la práctica es habitual que se mezclen, dando lugar a la programación multiparadigma.<br />
<br />
Actualmente el paradigma de programación más usado es el de la programación orientada a objetos.<br />
<br />
<span style="color: red;">Breve Explicacion:</span><br />
<br />
Un lenguaje de programación puede apoyar paradigmas múltiples. Por ejemplo programas escritos adentro C++ o PASCAL del objeto puede estar puramente procesal, o puramente orientado al objeto, o contenga los elementos de ambos paradigmas. Los diseñadores y los programadores del software deciden cómo utilizar esos elementos del paradigma.<br />
<br />
En programación orientada al objeto, los programadores pueden pensar en un programa como colección de objetos que obran recíprocamente, mientras que adentro programación funcional un programa se puede pensar en como secuencia de las evaluaciones apátridas de la función. Cuando computadoras o sistemas de programación con muchos procesadores, programación proceso-orientada permite que los programadores piensen de usos como sistemas de procesos concurrentes que actúan sobre compartido lógicamente estructuras de datos.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjIzX0Cc0tL__7mgqMola4AX5KJkyvMqE5n_8KCyOT8MZVET4vXHXWPN_zG0y3_CeGEGMk8FYjibtm9yHz4CQyvIiRNr5Nkg8PHryDvkY0fClSXiWmTySWbUF4aN7DYPoX7j_sIq0ZWjgg/s1600/VisualBasicLogo%255B8%255D.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="97" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjIzX0Cc0tL__7mgqMola4AX5KJkyvMqE5n_8KCyOT8MZVET4vXHXWPN_zG0y3_CeGEGMk8FYjibtm9yHz4CQyvIiRNr5Nkg8PHryDvkY0fClSXiWmTySWbUF4aN7DYPoX7j_sIq0ZWjgg/s200/VisualBasicLogo%255B8%255D.jpg" width="200" /></a></div>Apenas como diversos grupos adentro tecnología de dotación lógica abogado diferente metodologías, diferente lenguajes de programación abogado diferente paradigmas de programación. Algunas idiomas se diseñan para apoyar un paradigma particular (Palique apoya la programación orientada al objeto, Haskell apoya la programación funcional), mientras que otros lenguajes de programación apoyan paradigmas múltiples (por ejemplo PASCAL del objeto, C++, C#, Básico visual, Lisp común, Esquema, Python, Rubí y Onza).<br />
<br />
Muchos paradigmas de programación están como bien conocidos para qué técnicas ellos prohibido en cuanto a lo que él permite. Por ejemplo, la programación funcional pura rechaza el uso de efectos secundarios; programación estructurada rechaza el uso del goto declaración. En parte por esta razón, los nuevos paradigmas son mirados a menudo como doctrinaire o excesivamente rígido por ésos acostumbrados a estilos anteriores.[citación necesitada] Evitar ciertas técnicas puede hacerlo más fácil probar teoremas sobre un programa corrección-o entender simplemente su comportamiento.<br />
<br />
<span style="color: red;">Ejemplos</span><br />
<br />
• Programación de Annotative (como adentro Lengua de la llamarada) <br />
<br />
• programación Aspecto-orientada (como adentro AspectJ) <br />
<br />
• Programación Atribuir-Orientada (como adentro Java 5 anotaciones, preprocesado por la clase de XDoclet; Cualidades de C#) <br />
<br />
• Programación Autómata-Basada <br />
<br />
• Programación Bayesian <br />
<br />
• programación Clase-basada, comparado a programación Prototipo-basada (dentro del contexto de la programación orientada al objeto) <br />
<br />
• programación Componente-orientada (como adentro OLE) <br />
<br />
• Programación de Concatenative <br />
<br />
• Programación de constreñimiento, comparado a programación de la lógica <br />
<br />
• programación Contexto-orientada (como adentro ContextJ/contextos/ContextL) <br />
<br />
• Programación orientada de la cibernética <br />
<br />
• Programación del flujo de datos (como adentro hojas de balance) <br />
<br />
• Programación declarativa <br />
<br />
• Programación conducida acontecimiento <br />
<br />
• programación Fluir-basada <br />
<br />
• programación del Función-nivel <br />
<br />
• Programación funcional <br />
<br />
• programación Meta-dirigida como adentro Snobol, algo similar a Programación de la lógica <br />
<br />
• Programación imprescindible, comparado a programación declarativa <br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhbpjJRAv73Um_xkahx43HlO-xmLTrh6Rx5-qid5nbQ7V3aENR4Z2SM9FNDHo5rS0JQk6pN4__Hnn_xgMdskby0-O9F6i8mTKCa3P_EF_WGtOIPkUTlX3oDyqQyofzkZlUNCIk5-PvWou4/s1600/100px-C_plus_plus_svg.png" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhbpjJRAv73Um_xkahx43HlO-xmLTrh6Rx5-qid5nbQ7V3aENR4Z2SM9FNDHo5rS0JQk6pN4__Hnn_xgMdskby0-O9F6i8mTKCa3P_EF_WGtOIPkUTlX3oDyqQyofzkZlUNCIk5-PvWou4/s1600/100px-C_plus_plus_svg.png" /></a></div>• Programación intencional <br />
<br />
• Programación que sabe leer y escribir <br />
<br />
• Programación de la lógica (como adentro Prólogo) y Programación de la lógica de Abductive <br />
<br />
• Mensaje que pasa la programación, comparado a la programación imprescindible <br />
<br />
• Programación no determinista <br />
<br />
• Programación orientada al objeto (como adentro Palique) <br />
<br />
• Programación de la tubería (como en Línea de comando del UNIX) <br />
<br />
• programación Política-basada <br />
<br />
• Programación procesal, comparado a programación funcional <br />
<br />
• programación Proceso-orientada un modelo de la programación paralela. <br />
<br />
• Programación reactiva <br />
<br />
• Programación recurrente, comparado a programación iterativa <br />
<br />
• Programación reflexiva <br />
<br />
• Programación escalar, comparado a Programación del arsenal <br />
<br />
• Programación estructurada, comparado a programación no estructurada <br />
<br />
• programación Tema-orientada <br />
<br />
• Programación del árbol <br />
<br />
• programación del Valor-nivel, comparado a programación del función-nivel <br />
<br />
• Metaprogramming <br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://es.wikipedia.org/wiki/Paradigma_de_programaci%C3%B3n<br />
<br />
http://www.worldlingo.com/ma/enwiki/es/Programming_paradigmObed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-63514057375362566622010-11-22T06:57:00.000-08:002010-11-22T10:32:28.478-08:00RMateria: Lenguajes de Programacion.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhetSusxAb7E04I7KEfoHG-KtvZdQAkpGGN9DP845ZAPC234BTTVUrYJtnjxVSB9hEWJBUn9zYOEGTYsNLB4N9ZwZsyUs9EA-WGTW5EvcUR-ovGjYEjjfcqdrSup3isPbo1JpHXjG0MLCk/s1600/Rlogo-1.png" imageanchor="1" style="clear: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="151" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhetSusxAb7E04I7KEfoHG-KtvZdQAkpGGN9DP845ZAPC234BTTVUrYJtnjxVSB9hEWJBUn9zYOEGTYsNLB4N9ZwZsyUs9EA-WGTW5EvcUR-ovGjYEjjfcqdrSup3isPbo1JpHXjG0MLCk/s200/Rlogo-1.png" width="200" /></a></div>R es un lenguaje y entorno de programación para análisis estadístico y gráfico.<br />
Se trata de un proyecto de software libre, resultado de la implementación GNU del premiado lenguaje S. R y S-Plus -versión comercial de S- son, probablemente, los dos lenguajes más utilizados en investigación por la comunidad estadística, siendo además muy populares en el campo de la investigación biomédica, la bioinformática y las matemáticas financieras. A esto contribuye la posibilidad de cargar diferentes bibliotecas o paquetes con finalidades específicas de cálculo o gráfico.<br />
R se distribuye bajo la licencia GNU GPL y está disponible para los sistemas operativos Windows, Macintosh, Unix y GNU/Linux.<br />
<br />
<span style="color: red;">Historia</span><br />
Fue desarrollado inicialmente por Robert Gentleman y Ross Ihaka del Departamento de Estadística de la Universidad de Auckland en 1993.[<br />
] Su desarrollo actual es responsabilidad del R Development Core Team.<br />
<br />
<span style="color: red;">Caracteristicas</span><br />
R proporciona un amplio abanico de herramientas estadísticas (modelos lineales y no lineales, tests estadísticos, análisis de series temporales, algoritmos de clasificación y agrupamiento, etc.) y gráficas.<br />
Al igual que S, se trata de un lenguaje de programación, lo que permite que los usuarios lo extiendan definiendo sus propias funciones. De hecho, gran parte de las funciones de R están escritas en el mismo R, aunque para algoritmos computacionalmente exigentes es posible desarrollar bibliotecas en C, C++ o Fortran que se cargan dinámicamente. Los usuarios más avanzados pueden también manipular los objetos de R directamente desde código desarrollado en C. R también puede extenderse a través de paquetes desarrollados por su comunidad de usuarios.<br />
<br />
R hereda de S su orientación a objetos. La tarea de extender R se ve facilitada por su permisiva política de lexical scoping. Además, R puede integrarse con distintas bases de datos y existen bibliotecas que facilitan su utilización desde lenguajes de programación interpretados como Perl y Python.<br />
Otra de las características de R es su capacidad gráfica, que permite generar gráficos con alta calidad. R posee su propio formato para la documentación basado en LaTeX.<br />
R también puede usarse como herramienta de cálculo numérico, campo en el que puede ser tan eficaz como otras herramientas específicas tales como GNU Octave y su versión comercial, MATLAB.[] Se ha desarrollado una interfaz, RWeka[] para interactuar con Weka que permite leer y escribir ficheros en el formato arff y enriquecer R con los algoritmos de minería de datos de dicha plataforma.<br />
<br />
<span style="color: red;">ejemplos:</span><br />
Aqui hay un programa en r donde declaro unos numeros y de eso saco la media y la varianza.<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiMOUPNRVI6jXaX8aaJrkjp9ZUEG3R0WUL-sy0HSCext8iGbtYVzp3oBqmwn10q4otpROHVe3GxwE-T3-cJ9MY50VauCyqj3c85XahhkJ5lNsdRyR_IOwSKmH7h_wl4fAzVoWDAQUhZxOA/s1600/foto24.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiMOUPNRVI6jXaX8aaJrkjp9ZUEG3R0WUL-sy0HSCext8iGbtYVzp3oBqmwn10q4otpROHVe3GxwE-T3-cJ9MY50VauCyqj3c85XahhkJ5lNsdRyR_IOwSKmH7h_wl4fAzVoWDAQUhZxOA/s320/foto24.png" width="320" /></a></div><br />
Ademas de sacar una grafica que r te saca con una condicion. <br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhbNC-GjPkrSjTWR00iPtCAGr-fGQR8p6syo2NIwot98gMtZvY3b0erwnyCztZlcQ00xH6gODWTmczQNv_ywJOYb_-s92Dx8rikmSVxbPcr5dpIkaRLIptIz4GlF__E8U-FXs404MxXCAQ/s1600/foto23.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhbNC-GjPkrSjTWR00iPtCAGr-fGQR8p6syo2NIwot98gMtZvY3b0erwnyCztZlcQ00xH6gODWTmczQNv_ywJOYb_-s92Dx8rikmSVxbPcr5dpIkaRLIptIz4GlF__E8U-FXs404MxXCAQ/s320/foto23.png" width="320" /></a></div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-26177396329913805252010-11-22T05:15:00.000-08:002010-11-22T06:45:56.560-08:00Programa en C "Matriz"Aqui les dejo un programa que realiza una matriz:<br />
<br />
Este es el codigo fuente:<br />
<br />
<span style="font-size: x-small;">#include<stdio.h></stdio.h></span><br />
<span style="font-size: x-small;"></span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">/*Obed David Guevara Ibarra 1447478 Hora:V5</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">Matriz N*M que suma la diagonal superior*/</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">main(){</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">int N, M;</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">do{</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">printf("Proporcina el numero de Filas: ");</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">scanf("%d", &N);</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">printf("Proporcina el numero de Columnas: ");</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">scanf("%d", &M);</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}while(N!=M);</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">int A[N][M], i, j, s;</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">for(i=0;i<=N-1;i++){</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">for(j=0;j<=M-1;j++){</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">printf("A[%d][%d]= ", i+1, j+1);</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">scanf("%d", &A[i][j]);</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}//Fin de for</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">s = 0;</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">for(i=0;i<=N-1;i++){</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">for(j=0;j<=M-1;j++){</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">if(i==j) s = s + A[i][j];</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">for(i=0;i<=N-1;i++){</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">for(j=0;j<=M-1;j++){</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">printf("%d ", A[i][j]);</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">printf("\n");</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">printf("La suma de la diagonal es: %d", s);</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">getch();</span><br />
<span style="font-size: x-small;"><br />
</span><br />
<span style="font-size: x-small;">}</span><br />
<br />
<span style="font-size: xx-small;"> </span>Aqui les dejo el programa corriendo en Windows y Ubuntu <br />
<div style="border: medium none;"> </div><div style="border: medium none;">Windows: </div> <br />
<div class="separator" style="border: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjyN0kkKw6f4LT6sTOXiDojAUM6HeuP2WsxfKzbzcAOdAtPTjkGTB2lI-E6bWWHciXdSnfvcosOYetlhwjb6uGpV9LUhRjpPM_rcMNsM0ilAOq2wylVIIv_yJ2EHZJiz55xvKJ3-t5_P2Y/s1600/nose31.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="221" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjyN0kkKw6f4LT6sTOXiDojAUM6HeuP2WsxfKzbzcAOdAtPTjkGTB2lI-E6bWWHciXdSnfvcosOYetlhwjb6uGpV9LUhRjpPM_rcMNsM0ilAOq2wylVIIv_yJ2EHZJiz55xvKJ3-t5_P2Y/s320/nose31.png" width="320" /></a></div><div class="separator" style="border: medium none; clear: both; text-align: center;"><br />
</div><div class="separator" style="border: medium none; clear: both; text-align: left;">Aqui esta el programa corriendo en Ubuntu:</div><div class="separator" style="border: medium none; clear: both; text-align: left;"><br />
</div><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEic5Sr5Ozq4uLEacGPhFYfYjt-rf4OjhEv26_Vr5527nmPTS6pachQxmgtZzHw3e-DGGRSd6Ih4cS812BmiiIcPiA6ek5nIUdG3Dm_MFAlxSaEfSpnzGQsULRpSki7i7sc80RxGQEwaFqU/s1600/foto26.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEic5Sr5Ozq4uLEacGPhFYfYjt-rf4OjhEv26_Vr5527nmPTS6pachQxmgtZzHw3e-DGGRSd6Ih4cS812BmiiIcPiA6ek5nIUdG3Dm_MFAlxSaEfSpnzGQsULRpSki7i7sc80RxGQEwaFqU/s320/foto26.png" width="320" /></a></div>Saludos. <br />
<div class="separator" style="border: medium none; clear: both; text-align: left;"><br />
</div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-3387107937958293472010-11-22T05:10:00.000-08:002010-11-22T06:45:33.966-08:00Proma en C "Suma de Vectores"Aqui les dejo el programa corriendo en Ubuntu y Windows:<br />
<br />
Ubuntu<br />
Codigo fuente:<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi4ir5pckcT0Vy51aNbI_UU8uNfdVPQ87iPwf8E91Nxym3_8nKYr3E58cRVOvvD891r2hmMrTQLY95VfRvc4dRml5krIuqC1BF1iDKZqzm_DXoMGs4C-7WTUFln_DKk6CEyEOWMFCWtFXM/s1600/foto28.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi4ir5pckcT0Vy51aNbI_UU8uNfdVPQ87iPwf8E91Nxym3_8nKYr3E58cRVOvvD891r2hmMrTQLY95VfRvc4dRml5krIuqC1BF1iDKZqzm_DXoMGs4C-7WTUFln_DKk6CEyEOWMFCWtFXM/s320/foto28.png" width="320" /></a></div>Programa corriendo:<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhRdMSYI7113DNpNlpY0PEWQBCTxJzf2KTmteblrXJRy-pNBhJel9MCQ8zbHjqcxjrewnWOLFHU7No1mOkewoTRiCvCmKMda1059mzcB5u4dfalJBefgiUUAtFw8nTTdedRMF8HgGCTBAI/s1600/foto27.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhRdMSYI7113DNpNlpY0PEWQBCTxJzf2KTmteblrXJRy-pNBhJel9MCQ8zbHjqcxjrewnWOLFHU7No1mOkewoTRiCvCmKMda1059mzcB5u4dfalJBefgiUUAtFw8nTTdedRMF8HgGCTBAI/s320/foto27.png" width="320" /></a></div><br />
Windows:<br />
<br />
Codigo fuente:<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgyrWvvGIkIREMf9XWQOA5zjgRUglxKt4GGtT2pAs1AOL_Mg6Z9Wz1hXv8Pzp6NQiLhtSbX8Nj3lCmtC3BNrjHmEB0WbquDbi8lEH3GIROaS579HB4gKl59kSqvsJFBJvLU-nGdF8upQBU/s1600/nose22.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="179" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgyrWvvGIkIREMf9XWQOA5zjgRUglxKt4GGtT2pAs1AOL_Mg6Z9Wz1hXv8Pzp6NQiLhtSbX8Nj3lCmtC3BNrjHmEB0WbquDbi8lEH3GIROaS579HB4gKl59kSqvsJFBJvLU-nGdF8upQBU/s320/nose22.png" width="320" /></a></div> Programa corriendo:<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiMYGLU9HBDgKx30t-pwxPl0Ni-rtCRbFACktITKQantkZUupUYdxR_EEIdSLkHfPNzqntF3BRR6hyphenhyphenMRh0aX0dYR672D22P4K6S2h6BeQ94r5XVBANQo2OSo4xEuszMAjQnStFzkgQwUbo/s1600/nose32.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="161" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiMYGLU9HBDgKx30t-pwxPl0Ni-rtCRbFACktITKQantkZUupUYdxR_EEIdSLkHfPNzqntF3BRR6hyphenhyphenMRh0aX0dYR672D22P4K6S2h6BeQ94r5XVBANQo2OSo4xEuszMAjQnStFzkgQwUbo/s320/nose32.png" width="320" /></a></div><br />
Saludos.Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-7058680469907887962010-11-22T05:05:00.000-08:002010-11-22T06:45:09.213-08:00Programa en CAqui les dejo un progama en C que lee vectores:<br />
<br />
<br />
Este programa corre en Ubuntu:<br />
<br />
Aqui esta el codigo fuente del programa<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEisoIqe3u9GzBtz7e_dzE-n4BR5t8cgz7qZFnnCzUM44qURNMrONsmWtwoOtYMyLLZ8xRMI2dukgZ9BGpNPrjPV49ihkDtYUPdTmgKKcxI6or88CRElSQChbvPifb3oVc9YD2BBXUY9R6s/s1600/foto29.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEisoIqe3u9GzBtz7e_dzE-n4BR5t8cgz7qZFnnCzUM44qURNMrONsmWtwoOtYMyLLZ8xRMI2dukgZ9BGpNPrjPV49ihkDtYUPdTmgKKcxI6or88CRElSQChbvPifb3oVc9YD2BBXUY9R6s/s320/foto29.png" width="320" /></a></div><div class="separator" style="clear: both; text-align: center;"><br />
</div> Pantala del programa corriendo<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhD8fCB2YtTsD3bSi00dhzu4W8EvMaNe3kbY3SZOMv14bi-PzBLuwgoCOcjPOlxqcw1JtWS1VfwdUbWj7LRRfCLKZnHrwMwUGQk-pfQHHxmT2mRZgean2BVL-wdRpCQ_8tT2MliqvznRXY/s1600/foto25.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhD8fCB2YtTsD3bSi00dhzu4W8EvMaNe3kbY3SZOMv14bi-PzBLuwgoCOcjPOlxqcw1JtWS1VfwdUbWj7LRRfCLKZnHrwMwUGQk-pfQHHxmT2mRZgean2BVL-wdRpCQ_8tT2MliqvznRXY/s320/foto25.png" width="320" /></a></div><br />
Estos son en Windows:<br />
<br />
<div style="border: medium none;"> Aqui les dejo el codigo fuente y el programa corriendo</div><div style="border: medium none;"><br />
</div><div align="left" style="border: medium none; clear: both; text-align: center;"></div><div class="separator" style="border: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgx9X4ReMRsgeBEPz4AoWc3LRWkp3gQxX_ns0_g2BUvCtxuPZdxdMo-00FcNd2vp1AVzpnk8iwHJ_jcJHycbDzMO6j_VugOKQUg8a3ySEE9BoDVC_JQNQghbZ7XaIT-5laX3rKehyphenhyphennkn4E/s1600/nose29.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="177" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgx9X4ReMRsgeBEPz4AoWc3LRWkp3gQxX_ns0_g2BUvCtxuPZdxdMo-00FcNd2vp1AVzpnk8iwHJ_jcJHycbDzMO6j_VugOKQUg8a3ySEE9BoDVC_JQNQghbZ7XaIT-5laX3rKehyphenhyphennkn4E/s320/nose29.png" width="320" /></a></div><div class="separator" style="border: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEink5zlFqmPjtwA3MjRlqLkEAbhvl_FB4WXSZL05MZqM7K_xN8OJLn_qeKEvSnPKyg_JXY8OpHyG4rH_Mg_8wwuFcjgZ3lwGvoSQpts9OJMwhLd3A-QQJseF9KvAd8FQXZByDAoZxbYVak/s1600/nose30.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="161" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEink5zlFqmPjtwA3MjRlqLkEAbhvl_FB4WXSZL05MZqM7K_xN8OJLn_qeKEvSnPKyg_JXY8OpHyG4rH_Mg_8wwuFcjgZ3lwGvoSQpts9OJMwhLd3A-QQJseF9KvAd8FQXZByDAoZxbYVak/s320/nose30.png" width="320" /></a></div><div style="border: medium none;"><br />
</div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-73892390813769016662010-11-22T04:48:00.000-08:002010-11-22T04:48:30.995-08:00PerlMateria: Lenguajes de Programacion.<br />
<br />
Lenguajes de programación<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg-90Lx9mtUB5PxXUI3i6Y-hzKxAMKhl5lHcMeGJjSg-wUMc4hYAQ9XNkFpXq7kollkqtnL0Y3MiSZ8ivg2qHCQjKhiSU0MxkOsuGILkQ43itYvJYQWXBi9SlrUZFAW7ySQId6MqrmUXXc/s1600/perl_logo.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg-90Lx9mtUB5PxXUI3i6Y-hzKxAMKhl5lHcMeGJjSg-wUMc4hYAQ9XNkFpXq7kollkqtnL0Y3MiSZ8ivg2qHCQjKhiSU0MxkOsuGILkQ43itYvJYQWXBi9SlrUZFAW7ySQId6MqrmUXXc/s200/perl_logo.jpg" width="151" /></a></div><br />
<span style="color: red;">PERL</span><br />
<br />
Perl es un lenguaje de programación diseñado por Larry Wall en 1987. Perl toma características del lenguaje C, del lenguaje interpretado shell (sh), AWK, sed, Lisp y, en un grado inferior, de muchos otros lenguajes de programación.<br />
<br />
Estructuralmente, Perl está basado en un estilo de bloques como los del C o AWK, y fue ampliamente adoptado por su destreza en el procesado de texto y no tener ninguna de las limitaciones de los otros lenguajes de script.<br />
<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><span style="color: red;">HISTORIA</span></div><br />
Larry Wall comenzó a trabajar en Perl en 1987 mientras trabajaba como programador en Unisys y anunció la versión 1.0 en el grupo de noticias comp.sources.misc el 18 de diciembre de 1987. El lenguaje se expandió rápidamente en los siguientes años. Perl 2, publicado en 1988, aportó un mejor motor de expresiones regulares. Perl 3, publicado en 1989, añadió soporte para datos binarios.<br />
<br />
<span style="color: red;">NOMBRE</span><br />
<br />
El nombre es descrito ocasionalmente como "PERL" (por Practical Extraction and Report Language - Lenguaje Práctico para la Extracción e Informe). Aunque esta expansión ha prevalecido en muchos manuales actuales, incluyendo la página de manual de Perl, es un retroacrónimo y oficialmente el nombre no quiere decir nada. La ortografía de PERL en mayúsculas es por eso usada como jerga para detectar a individuos ajenos a la comunidad. Sin embargo, se han sugerido varios retroacrónimos, incluyendo el cómico Pathologically Eclectic Rubbish Lister (Contabilizador de Basura Patológicamente Ecléctico).<br />
<br />
Estructura del lenguaje<br />
<br />
Programa ejemplo<br />
<br />
En Perl, el programa canónico "Hola mundo" es:<br />
<br />
#!/usr/bin/perl<br />
<br />
print "¡Hola mundo!\n";<br />
<br />
La primera línea contiene el shebang (par de caracteres que identifica el texto que sigue), que le indica al sistema operativo dónde encontrar el intérprete de Perl. La segunda imprime el string ¡Hola mundo! y un carácter de nueva línea.<br />
<br />
El shebang es la forma normal para invocar al intérprete en los sistemas Unix. Los sistemas Windows pueden seguir utilizándolo o pueden asociar la extensión de archivo .pl con el intérprete Perl. Algunos editores de texto también usan la línea shebang como una pista sobre el modo de trabajo en que deben operar. Si el programa es ejecutado por perl y no invocado por el shell, la línea que empieza por el shebang es parseada para interpretar las opciones. En otro caso, es ignorada.<br />
<br />
<span style="color: red;">Tipos de datos</span><br />
<br />
Perl tiene tres tipos de datos: escalares, listas y hashes:<br />
<br />
• Un escalar es un solo valor; puede ser un número, un string (cadena de caracteres) o una referencia<br />
<br />
• Una lista es una colección ordenada de escalares (una variable que almacena una lista se llama array)<br />
<br />
• Un hash, o memoria asociativa, es un mapeo de strings a escalares; los strings se llaman claves y los escalares valores.<br />
<br />
Todas las variables están precedidas por un sigil, que identifica el tipo de dato que es accedido (no el tipo de dato de la misma variable). Se puede usar el mismo nombre para variables de diferentes tipos, sin que tengan conflictos.<br />
<br />
Datos escalares<br />
<br />
Los datos escalares son las variables simples y pueden contener enteros, reales, cadenas o referencias. Este tipo de variables van precedido siempre por $.<br />
<br />
En Perl las variables no se tienen porque declarar, aunque se declaran con my.<br />
<br />
Las cadenas se encierran entre comillas dobles (" "), aunque también se pueden cerrar entre comillas simples (' '). Hay caracteres especiales (retorno de carro, tabulador, etc.) que como en muchos otros lenguajes se presentan mediante la barra de escape: <br />
<br />
• \n retorno de carro a una nueva línea <br />
<br />
• \b retorno a la posición anterior <br />
<br />
• \a pitido <br />
<br />
• \t tabulación (8 espacios) <br />
<br />
• \\ el caracter \ <br />
<br />
• \" las comillas dobles (aunque si la cadena está delimita por comillas simples, no hace falta) <br />
<br />
• \' las comillas simples (aunque si la cadena está delimita por comillas dobles, no hace falta) <br />
<br />
Los operadores de comparación, son similares a los de C, pero depende si estamos comparando cadenas o datos numéricos. Los operadores para números y para cadenas son: <br />
<br />
<span style="color: red;">Comparación Números Cadenas</span><br />
<br />
igual == eq<br />
<br />
no igual != ne<br />
<br />
menor que < lt<br />
<br />
mayor que > gt<br />
<br />
menor o igual que <= le<br />
<br />
mayor o igual que >= ge<br />
<br />
En Perl también tenemos los operadores de autoincremento (++)y autodecremento (--). Y además tenemos el operador potencia **(que es muy parecido aunque muy diferente) <br />
<br />
<span style="color: red;">Estructuras de control de flujo</span><br />
<br />
Perl mantiene todas las estructuras de control de flujo que pueda tener cualquier otro lenguaje, pero con la peculariedad de que un bloque siempre debe ir entre llaves ({ }), aun cuando el bloque contenga un única sentencia. <br />
<br />
Un resumen general de las estrucuturas de control de flujo es: <br />
<br />
• if (EXPR) BLOQUE <br />
<br />
• if (EXPR) BLOQUE else BLOQUE <br />
<br />
• if (EXPR) BLOQUE elsif (EXPR) BLOQUE else BLOQUE <br />
<br />
• SENTENCIA if (EXPR); <br />
<br />
• unless (EXPR) BLOQUE <br />
<br />
• unless (EXPR) BLOQUE else BLOQUE <br />
<br />
• unless (EXPR) BLOQUE elsif (EXPR) BLOQUE else BLOQUE <br />
<br />
• SENTENCIA unless (EXPR); <br />
<br />
• while (EXPR) BLOQUE <br />
<br />
• SENTENCIA while (EXPR); <br />
<br />
• until (EXPR) BLOQUE <br />
<br />
• SENTENCIA until (EXPR); <br />
<br />
• do BLOQUE while (EXPR); <br />
<br />
• do BLOQUE until (EXPR); <br />
<br />
• for (EXPR;EXPR;EXPR) BLOQUE <br />
<br />
• foreach $var (Array) BLOQUE <br />
<br />
Donde EXPR es una expresión, BLOQUE es una sentecia o conjunto de estas encerrado entre llaves y SENTENCIA es una sola sentencia <br />
<br />
ejemplo:<br />
Aqui les dejo un programa que saca los numeros de fibonacci<br />
<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgDMwgpB29TeS3agYFc7kz7c048PsxrX86JPSH5KgB1HmZRK61uVxfTEsYum36eT6QiTK1H10xzdXYBjYYMSYT53rBOzMv2DZotj9CM2bpJ2JuW26j8n89Db10pDDVtao0_DV0y_XcZ3N4/s1600/foto8.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgDMwgpB29TeS3agYFc7kz7c048PsxrX86JPSH5KgB1HmZRK61uVxfTEsYum36eT6QiTK1H10xzdXYBjYYMSYT53rBOzMv2DZotj9CM2bpJ2JuW26j8n89Db10pDDVtao0_DV0y_XcZ3N4/s320/foto8.png" width="320" /></a></div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><br />
</div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><br />
</div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiYHS1pbSCXa_-0bO4xmU6oQjl1jOHawPtkKSzHIV5yPReau8h73rkSj9e1Cju8MbQoL3Vp2IfMD4cRIL28V6eUCeBYz4f48R30wRd71BNNmJkGTi6a1H8WysIOmsjSEagRgGMYzsWpCOQ/s1600/foto7.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiYHS1pbSCXa_-0bO4xmU6oQjl1jOHawPtkKSzHIV5yPReau8h73rkSj9e1Cju8MbQoL3Vp2IfMD4cRIL28V6eUCeBYz4f48R30wRd71BNNmJkGTi6a1H8WysIOmsjSEagRgGMYzsWpCOQ/s320/foto7.png" width="320" /></a></div><br />
<br />
<br />
<br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://es.wikipedia.org/wiki/Perl<br />
<br />
<a href="http://flanagan.ugr.es/perl/index2.htm">http://flanagan.ugr.es/perl/index2.htm</a>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-13539913711500403552010-11-22T04:40:00.000-08:002010-11-22T04:40:22.438-08:00Compiladores e Interpretes<span style="color: #cc0000;">Materia: Lenguajes de programación </span><br />
<br />
<br />
Un programa escrito en un lenguaje "compilado" se traduce a través de un programa anexo llamado compilador que, a su vez, crea un nuevo archivo independiente que no necesita ningún otro programa para ejecutarse a sí mismo. Este archivo se llama ejecutable. <br />
<br />
Un programa escrito en un lenguaje compilado posee la ventaja de no necesitar un programa anexo para ser ejecutado una vez que ha sido compilado. Además, como sólo es necesaria una traducción, la ejecución se vuelve más rápida. <br />
<br />
Sin embargo, no es tan flexible como un programa escrito en lenguaje interpretado, ya que cada modificación del archivo fuente (el archivo comprensible para los seres humanos: el archivo a compilar) requiere de la compilación del programa para aplicar los cambios. <br />
<br />
Por otra parte, un programa compilado tiene la ventaja de garantizar la seguridad del código fuente. En efecto, el lenguaje interpretado, al ser directamente un lenguaje legible, hace que cualquier persona pueda conocer los secretos de fabricación de un programa y, de ese modo, copiar su código o incluso modificarlo. Por lo tanto, existe el riesgo de que los derechos de autor no sean respetados. Por otro lado, ciertas aplicaciones aseguradas necesitan confidencialidad de código para evitar las copias ilegales (transacciones bancarias, pagos en línea, comunicaciones seguras...). <br />
<br />
La generación de código data desde la existencia de los primeros compiladores. Hasta la aparición de los primeros generadores de código comerciales u orientados a "usuarios finales"; la generación de código era exclusividad de programas compiladores especializados.<br />
<br />
En tiempos más recientes la generación de código, gracias al avance de la ingeniería del software, se ha llevado a un nivel diferente; donde se encuentran programas generadores de pantallas, reportes y consultas, estas son herramientas de gran utilidad; pero se debe, en la mayoría de los casos, Pagar una gran cantidad de dinero por ellos.<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi5TYTaSVx62pTXPi0DIYaPKxJNQhs8c0-ahd2pKHwCmEOI_vyg3LvykkO9yOFcWLOZtzfJbMF9RxHDMwxGPuPuXqmkSd0tAm5vgrIF6sdPMo-tBZtLevnVUXvIf4eFnZoP3xi9DyJm9Iw/s1600/nose38.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="114" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi5TYTaSVx62pTXPi0DIYaPKxJNQhs8c0-ahd2pKHwCmEOI_vyg3LvykkO9yOFcWLOZtzfJbMF9RxHDMwxGPuPuXqmkSd0tAm5vgrIF6sdPMo-tBZtLevnVUXvIf4eFnZoP3xi9DyJm9Iw/s320/nose38.png" width="320" /></a></div><br />
<span style="color: red;">Arquitectura de un Compilador </span><br />
<br />
Un compilador, básicamente, es un programa que lee un archivo con código fuente; este código fuente lo traduce a un lenguaje llamado lenguaje objeto. En este proceso se le indica al usuario la existencia de errores de codificación.<br />
<br />
El compilador recibe una entrada de caracteres, por lo general escrita por el programador; el compilador realiza los análisis: léxico, sintáctico y semántico, para generar seguidamente el código intermedio, el código intermedio se genera con principios de búsqueda de patrones y aplicación de reglas. Después se hace la optimización del código intermedio; seguidamente se realiza la generación de código objeto en lenguaje de máquina.<br />
<br />
Análisis léxico. Es la parte inicial de leer y analizar el código fuente. El texto es leído y dividido en tokens, cada uno de los cuales corresponde a un símbolo en el lenguaje de programación, por ejemplo, el nombre de una variable, una palabra reservada o un número.<br />
<br />
Análisis sintáctico. En esta fase se toma una lista de tokens producida por el análisis léxico y los acomoda en una estructura de árbol llamada árbol sintáctico que refleja la estructura del programa. Esta fase también se llama parsing.<br />
<br />
Análisis semántico. es posterior al sintáctico y mucho más difícil de formalizar que éste. Se trata de determinar el tipo de los resultados intermedios, comprobar que los argumentos que tiene un operador pertenecen al conjunto de los operadores posibles, y si son compatibles entre sí, etc. En definitiva, comprobará que el significado de lo que se va leyendo es válido. <br />
<br />
<span style="color: red;">Interprete</span><br />
Un lenguaje de programación es, por definición, diferente al lenguaje máquina. Por lo tanto, debe traducirse para que el procesador pueda comprenderlo. Un programa escrito en un lenguaje interpretado requiere de un programa auxiliar (el intérprete), que traduce los comandos de los programas según sea necesario. <br />
<br />
Un intérprete traduce un código fuente en lenguaje máquina también. El intérprete difiere del compilador en que ejecuta cada orden una vez que se traduce. Este proceso puede hacer más lenta la ejecución del programa, así que los intérpretes se utilizan menos que los compiladores. Un intérprete es otra manera de implementar un lenguaje de programación. La interpretación comparte muchos aspectos con el compilador. Los análisis léxico, sintáctico y verificación de tipos son exactamente los mismos que en un compilador.<br />
Pero en lugar de generar código del árbol sintáctico, el árbol sintáctico se procesa directamente para evaluar expresiones y ejecutar sentencias, y así hasta terminar. Un intérprete puede necesitar evaluar la misma parte del árbol sintáctico varias veces (por ejemplo cuando se hacen ciclos), por eso la interpretación puede ser más lenta que la ejecución de un programa compilado. Pero escribir un intérprete es más fácil de mover a una máquina diferente, así que para aplicaciones donde la velocidad no importa, lo mejor es utilizar un intérprete.<br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://es.kioskea.net/contents/langages/langages.php3Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-80986931542028870202010-11-22T04:36:00.000-08:002010-11-22T04:36:55.461-08:00JavaAqui les dejo un programa en java.<br />
<br />
Java<br />
<br />
Java es un lenguaje de programación orientado a objetos, desarrollado por Sun Microsystems a principios de los años 90. El lenguaje en sí mismo toma mucha de su sintaxis de C y C++, pero tiene un modelo de objetos más simple y elimina herramientas de bajo nivel, que suelen inducir a muchos errores, como la manipulación directa de punteros o memoria.<br />
<br />
Una de las principales características por las que Java se ha hecho muy famoso es que es un lenguaje independiente de la plataforma. Eso quiere decir que si hacemos un programa en Java podrá funcionar en cualquier ordenador del mercado. Es una ventaja significativa para los desarrolladores de software, pues antes tenían que hacer un programa para cada sistema operativo, por ejemplo Windows, Linux, Apple, etc. Esto lo consigue porque se ha creado una Máquina de Java para cada sistema que hace de puente entre el sistema operativo y el programa de Java y posibilita que este último se entienda perfectamente. <br />
<br />
Java fue pensado originalmente para utilizarse en cualquier tipo de electrodoméstico pero la idea fracasó. Uno de los fundadores de Sun rescató la idea para utilizarla en el ámbito de Internet y convirtieron a Java en un lenguaje potente, seguro y universal gracias a que lo puede utilizar todo el mundo y es gratuito. Una de los primeros triunfos de Java fue que se integró en el navegador Netscape y permitía ejecutar programas dentro de una página web, hasta entonces impensable con el HTML. <br />
<br />
Actualmente Java se utiliza en un amplio abanico de posibilidades y casi cualquier cosa que se puede hacer en cualquier lenguaje se puede hacer también en Java y muchas veces con grandes ventajas. Para lo que nos interesa a nosotros, con Java podemos programar páginas web dinámicas, con accesos a bases de datos, utilizando XML, con cualquier tipo de conexión de red entre cualquier sistema. En general, cualquier aplicación que deseemos hacer con acceso a través web se puede hacer utilizando Java. <br />
<br />
<br />
Ejemplo: Esto es el juego de piedra papel o tijera.<br />
<br />
import javax.swing.*;<br />
import java.util.Random;<br />
public class seleccion{ <br />
<br />
public static void main(String[] args){<br />
<br />
int varUs,varCom;<br />
<br />
// do{<br />
<br />
do{<br />
<br />
String Us = JOptionPane.showInputDialog(null,"Telcclee 1-Piedra, 2-Papel, 3-Tijera");<br />
<br />
varUs = Integer.parseInt(Us);<br />
<br />
}while(varUs >= 3);<br />
<br />
Random generator = new Random();<br />
varCom = (generator.nextInt(3)+1);<br />
<br />
JOptionPane.showMessageDialog(null,varUs + " " + varCom);<br />
<br />
<br />
if(varUs == 1){<br />
<br />
<br />
if(varCom == 1){<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Piedra vs Piedra: Empate!");<br />
<br />
}else{<br />
<br />
if(varCom == 2){<br />
<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Piedra vs Papel: Perdiste!");<br />
<br />
<br />
<br />
}else{<br />
<br />
<br />
<br />
if(varCom == 3){<br />
<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Piedra vs Tijera: Ganaste!"); <br />
<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
}//<br />
}else{<br />
<br />
<br />
<br />
if(varUs == 2){<br />
<br />
<br />
<br />
if(varCom == 1){<br />
<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Papel vs Piedra: Ganaste!");<br />
<br />
<br />
<br />
}else{<br />
<br />
<br />
<br />
if(varCom == 2){<br />
<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Papel vs Papel: Empate!");<br />
<br />
<br />
<br />
}else{<br />
<br />
<br />
<br />
if(varCom == 3){<br />
<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Papel vs Tijera: Perdiste!"); <br />
<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
} // <br />
<br />
}else{<br />
<br />
<br />
<br />
if(varUs == 3){<br />
<br />
<br />
<br />
if(varCom == 1){<br />
<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Tijera vs Piedra: Perdiste!");<br />
<br />
<br />
<br />
}else{<br />
<br />
<br />
<br />
if(varCom == 2){<br />
<br />
<br />
<br />
JOptionPane.showMessageDialog(null,"Tijera vs Papel: Ganaste!");<br />
<br />
<br />
<br />
}else{<br />
<br />
<br />
<br />
if(varCom == 3){<br />
<br />
}//<br />
<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
} // <br />
<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
}//<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
// String resp =JOptionPane.showMessageDialog(null,"Desea Coninuar? 1 si,,, 0 no!");<br />
<br />
<br />
<br />
// int r = Integer.parseInt(resp);<br />
<br />
<br />
<br />
// }while(r == 1);<br />
<br />
<br />
<br />
}//<br />
<br />
<br />
<br />
}<br />
<br />
<br />
<br />
Lo cargamos con javac nombre del archivo.java, despues java nombre del archivo el programa corre y luego te pide que escogas del 1 al 3 piedra, papel, tijera.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhH9sfJpbfISF929Q3_483S7MefeIwoc4QotK_AdZ3_uC_BkCL0Qejeda6nW0KMOcnFY_ojpsGm07YzNzSClak8XF6R0fGmNqpV88s4bUI4PEkK7Bm8Gkiq0WarXlK31zA6pHwkVWP-sVY/s1600/nose26.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="87" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhH9sfJpbfISF929Q3_483S7MefeIwoc4QotK_AdZ3_uC_BkCL0Qejeda6nW0KMOcnFY_ojpsGm07YzNzSClak8XF6R0fGmNqpV88s4bUI4PEkK7Bm8Gkiq0WarXlK31zA6pHwkVWP-sVY/s320/nose26.png" width="320" /></a></div><div class="separator" style="clear: both; text-align: center;">En es te caso yo escogi el 2 papel y la maquina piedra y me indica que gane.</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhfsVPgCjeu5DrP0zxAE5QaYyz4S1KfnwdmkiVtHGpOuLj-d73cs_JCtFlCWc62W0KxwFcgXyVhJUy04WOfYVGZYB_IqxrgQQy43QxGBWKS04Pwty8DSqLe4C5RFLLStTiOfRPZ_ty00_M/s1600/nose27.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhfsVPgCjeu5DrP0zxAE5QaYyz4S1KfnwdmkiVtHGpOuLj-d73cs_JCtFlCWc62W0KxwFcgXyVhJUy04WOfYVGZYB_IqxrgQQy43QxGBWKS04Pwty8DSqLe4C5RFLLStTiOfRPZ_ty00_M/s1600/nose27.png" /></a><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjwgAA14wdhIxypFYAHGyHHZehPFgUogscV7w-s_pnkd3lJR3YiDw8elZ09x4IVisCm24rG5rCePTbhGthHG7BmbZmNRYfOpKpiaJBtsPcc1uz4RBKKv_uzN46fnAnIAQRhMwyNE56qMCU/s1600/nose28.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjwgAA14wdhIxypFYAHGyHHZehPFgUogscV7w-s_pnkd3lJR3YiDw8elZ09x4IVisCm24rG5rCePTbhGthHG7BmbZmNRYfOpKpiaJBtsPcc1uz4RBKKv_uzN46fnAnIAQRhMwyNE56qMCU/s1600/nose28.png" /></a></div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-59064978652933844432010-11-22T04:28:00.000-08:002010-11-22T04:28:53.297-08:00Ejemplos de Recursividad e iteratividadMateria de Lenguajes de Programacion.<br />
<br />
Estos son unos programas en perl donde saco el factorial recursivamente e iterativamente<br />
<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"> Este es el ejemplo recursivo:</div><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgbXhgGGWHiG5OOxhOSvca9y475T6r8J5xbtqakt9gx7uCioJWmXpGNXnG0u4cQKgkeOIIV9ror7zMcwYR84T0-tEgIJGGu0mLZVBgyAGaDImkNj2JVQyyoC0hrTpMg8R5x0DL2CxZBDVM/s1600/nose34.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="191" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgbXhgGGWHiG5OOxhOSvca9y475T6r8J5xbtqakt9gx7uCioJWmXpGNXnG0u4cQKgkeOIIV9ror7zMcwYR84T0-tEgIJGGu0mLZVBgyAGaDImkNj2JVQyyoC0hrTpMg8R5x0DL2CxZBDVM/s320/nose34.png" width="320" /></a></div><br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"> Su terminal.-</div><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjvPusDMGjpIJ9r_aXrqSm774wnJd4uyL8MkJaKCqvE_CeMc9ZUJ_uCcvAyAx1kjVMHmLFcXN_PGzLoab9mVKyF8-HHdm-aLyZshvy5-84Qzx1Q5U_kl9yQauAuTfjlqWyZdgzZpYEhWhM/s1600/nose36.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="191" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjvPusDMGjpIJ9r_aXrqSm774wnJd4uyL8MkJaKCqvE_CeMc9ZUJ_uCcvAyAx1kjVMHmLFcXN_PGzLoab9mVKyF8-HHdm-aLyZshvy5-84Qzx1Q5U_kl9yQauAuTfjlqWyZdgzZpYEhWhM/s320/nose36.png" width="320" /></a></div><br />
<br />
Este es el ejemplo iterativo:<br />
<div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiUDMo04FKLfGNvuFsJ1kgu-BUhVnWDppfpz-ENklgWnVHvuRca73rycud6lsWoumNr_Agp5yJXhrt3LiOoq8lSdSznDUFzQxCbAleBXoh01qADFeFZ0xUZz1VobhYwNqk_g0BmfWU2pI4/s1600/nose35.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="191" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiUDMo04FKLfGNvuFsJ1kgu-BUhVnWDppfpz-ENklgWnVHvuRca73rycud6lsWoumNr_Agp5yJXhrt3LiOoq8lSdSznDUFzQxCbAleBXoh01qADFeFZ0xUZz1VobhYwNqk_g0BmfWU2pI4/s320/nose35.png" width="320" /></a></div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;">Su terminal.-</div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><br />
</div><div class="separator" style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none; clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj8XjXSBV-zafBRc2NgAepuuK8e-kUKTySfJBDQztVaKfpq1B_NLsebLLaeUOjLcHaDDPKKmRnpFj7STYafVfmxo_BF6ro_koTrquuI0AzvHyWlu_aw8TRy9TgeCAQ5HcgaXPzPzpdhGWU/s1600/foto19.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj8XjXSBV-zafBRc2NgAepuuK8e-kUKTySfJBDQztVaKfpq1B_NLsebLLaeUOjLcHaDDPKKmRnpFj7STYafVfmxo_BF6ro_koTrquuI0AzvHyWlu_aw8TRy9TgeCAQ5HcgaXPzPzpdhGWU/s320/foto19.png" width="320" /></a></div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-42662877600253613582010-11-22T04:18:00.000-08:002010-11-22T04:29:55.933-08:00Estructuras RecursivasMateria: Lenguajes de Programacion.<br />
<br />
<br />
<span style="color: red;">Introducción. </span><br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhAzLMSwobUenVHsg0V2LJtYg8jR0ekp2Gb6rxtnsAv8WTBlJwvMQLoylWn039872JZNeG6_WSYa64Nwn85cKvoK-BX75Wicsk734NLTRWfADwbDarkSKhYG900wWIjuZuTplRaU3lbyOM/s1600/recursion.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="160" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhAzLMSwobUenVHsg0V2LJtYg8jR0ekp2Gb6rxtnsAv8WTBlJwvMQLoylWn039872JZNeG6_WSYa64Nwn85cKvoK-BX75Wicsk734NLTRWfADwbDarkSKhYG900wWIjuZuTplRaU3lbyOM/s200/recursion.jpg" width="200" /></a></div>Un procedimiento o función recursiva es aquella que se llama así misma. Esta característica permite a un procedimiento recursivo repetirse valores diferentes de parámetros. La recursion es una alternativa a la iteración muy elegante en la solución de problemas, especialmente si estos tienen naturaleza recursiva. <br />
<br />
Normalmente, una solución recursiva es menos eficiente en términos de tiempo de computadora que una solución iterativa debido al tiempo adicional de llamada a procedimientos. <br />
<br />
En muchos casos, la recursion permite especificar una solución mas simple y natural para resolver un problema que en otro caso seria difícil. Por esta razón la recursion (recursividad) es una herramienta muy potente para la resolución de problemas de programación. <br />
<br />
Un objeto recursivo es aquel que forma parte de si mismo. Esta idea puede servir de ayuda para la definición de conceptos matematicos. Asi, la definición del conjunto de los numeros naturles es aque conjunto en el que se cumplen las siguientes caracteristicas: <br />
<br />
• 0 es un numero natural. <br />
<br />
• El siguiente numero de un numero natural es otro numero natural. <br />
<br />
Mediante una definición finita hemos representado un conjunto infinito. <br />
<br />
El concepto de la recursividad es muy importante en programación. La recursividad es una herramienta muy eficaz para resolver diversos tipos de problemas existen muchos algoritmos que se describiran mejor en terminos recursivos.<br />
<br />
<span style="color: red;">Algoritmos recursivos</span><br />
<br />
Un método común de simplificación consiste en dividir un problema en subproblemas del mismo tipo. Como técnica de programación, esto se denomina división y conquista, y constituye la llave para el desarrollo de muchos algoritmos importantes, así como un elemento fundamental del paradigma de programación dinámica. <br />
<br />
Prácticamente todas las lenguajes de programación usadas hoy día permiten la especificação directa de funciones y procedimientos recursivos. Cuando una función es invocada, el ordenador (en la mayoría de los lenguajes sobre la mayor parte de las arquiteturas basadas en pilas) o la implementación del lenguaje registra las varias instancias de una función (en muchas arquiteturas, se usa una pila de llamada, aunque otros métodos puedan ser usados). Recíprocamente, toda función recursiva puede ser transformada en una función iterativa usando una pila. <br />
<br />
Toda función que pueda ser producida por un ordenador puede ser escrita como función recursiva sin el uso de iteração; recíprocamente, cualquier función recursiva puede ser descrita a través de iterações sucesivas. <br />
<br />
<span style="color: red;">Dentro de la teoría de la recursión, se tiene que existen diferentes tipos de recursión: </span><br />
<br />
Recursión directa. Cuando el código F tiene una sentencia que involucra a F. <br />
<br />
Recursión indirecta o cruzada.- Cuando la función F involucra una función G que invoca a la ves una función H, y así sucesivamente, hasta que se involucra la función F. Por ejemplo el algoritmo de Par o impar. <br />
<br />
int par (int n) <br />
{<br />
if (n==0) return n+1; <br />
return impar(n-1); <br />
int impar(int n) <br />
if (n==0) return 0; <br />
return par(n-1);<br />
}<br />
A continuación se expone otro ejemplo de programa que utiliza recursión indirecta, y nos dice si un número es par o impar. Cabe mencionar que existen otros métodos mucho más sencillos para determinar la solución a este problema, basta con determinar el resto de la división entre dos. Por ejemplo: si hacemos par(2) devuelve 1 (cierto). Si hacemos impar(4) devuelve 0 (falso). <br />
<br />
int par(int n);<br />
int impar(int n); <br />
int par(int n)<br />
{ if (n == 0) return 1; <br />
return impar(n-1);<br />
}<br />
int impar(int n)<br />
{<br />
if (n == 0) return 0; <br />
return par(n-1);<br />
}<br />
<br />
Recursión simple.- Aquella en cuya función solo aparece una llamada recursiva. Se puede transformar con facilidad en algoritmos iteractivos. <br />
<br />
Recursión múltiple.- Se da cuando hay más de una llamada a sí misma dentro del cuerpo de la función, resultando más difícil de transformar a iteractiva. Poe ejemplo el algoritmo de Fibonacci. <br />
<br />
int fibo(int n)<br />
{<br />
if (n<=1) return 1 <br />
return fibo(n-1) + fibo(n-2)<br />
} <br />
<br />
Recursión anidada.- En algunos de los argumentos de la llamada hay una nueva llamada a sí misma. Por<br />
ejemplo la función de Ackerman: <br />
int Ack(int m, int n)<br />
{<br />
if (m==0) return n+1 <br />
if (n=00) return Ack(n-1, 1) <br />
return Ack(m-1, Ack(m, n-1));<br />
} <br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEinZHspwvEVeH_j8yiwJgvk51f-z2kIDgvwJAk42K4SKwwICpHCQTZPyAbARvtk93fFjIYNzmZHsU3DsNJGM_SKVKNjVAk5BlkjghGBErnkIzYYZq9Cg_z34rc8ln0lqFttJyt8GdA-mAw/s1600/Recursividad.gif" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="192" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEinZHspwvEVeH_j8yiwJgvk51f-z2kIDgvwJAk42K4SKwwICpHCQTZPyAbARvtk93fFjIYNzmZHsU3DsNJGM_SKVKNjVAk5BlkjghGBErnkIzYYZq9Cg_z34rc8ln0lqFttJyt8GdA-mAw/s320/Recursividad.gif" width="320" /></a></div>Un requisito para que un algoritmo recursivo sea correcto es que no genere una secuencia infinita de llamadas sobre sí mismo. Cualquier algoritmo que genere una secuencia de este tipo no terminará nunca. En consecuencia, la definición recursiva debe incluir un componente base (condición de salida ) en el que f(n) se define directamente (es decir, no recursivamente) para uno o más valores de n. Debe existir una <> de la secuencia de llamadas recursivas. <br />
<br />
Al estar trabajando con recursividad, la memoria de la computadora hace uso de una pila de recursión, la cual se divide de manera lógica en 4 segmentos: <br />
<br />
Segmento de código.- Parte de la memoria donde se guardan las instrucciones del programa en código máquina. <br />
<br />
Segmento de datos.- Parte de la memoria destinada a almacenar las variables estáticas. <br />
<br />
Montículo.- Parte de la memoria destinada a las variables dinámicas. <br />
<br />
Pila de programa.- parte destinada a las variables locales y parámetros de la función que está siendo ejecutada. <br />
<br />
<span style="color: #cc0000;">Funciones mutuamente recursivas </span><br />
<br />
<span style="color: red;">Cuando se trabaja llamados a la ejecución de las funciones, se provocan las siguientes operaciones: </span><br />
<br />
1.- Reservar espacio en la pila para los parámetros de la función y sus variables locales. <br />
<br />
2.- Guardar en la pila la dirección de la línea de código desde donde se ha llamado a la función. <br />
<br />
3.- Almacenar los parámetros de la función y sus valores de pila. <br />
<br />
4.- Al terminar la función, se libera la memoria asignada en la pila y se vuelve a la instrucción actual. <br />
<br />
Pero cuando se trabaja con funciones recursivas, se provoca además lo siguiente: <br />
<br />
1.- La función se ejecutará normalmente hasta la llamada a sí misma. En ese momento se crean en la pila nuevos parámetros y variables locales. <br />
<br />
2.- El nuevo ejemplar de función comienza a ejecutarse. <br />
<br />
3.- Se crean más copias hasta llegar a la primera llamada (ultima en cerrarse). <br />
<br />
La ciencia de la computación hace tiempo que descubrió que se puede reemplazar a un método que utiliza un bucle para realizar un cálculo con un método que se llame repetidamente a sí mismo para realizar el mismo cálculo. El hecho de que un método se llame repetidamente a sí mismo se conoce como recursion. <br />
<br />
La recursión trabaja dividiendo un problema en subproblemas. Un programa llama a un método con uno o más parámetros que describen un problema. Si el método detecta que los valores no representan la forma más simple del problema, se llama a sí mismo con valores de parámetros modificados que describen un subproblema cercano a esa forma. <br />
<br />
Esta actividad continúa hasta que el método detecta la forma más simple del problema, en cuyo caso el método simplemente retorna, posiblemente con un valor, si el tipo de retorno del método no es void. La pila de llamadas a método empieza a desbobinarse como una llamada a método anidada para ayudar a completar una evaluación de expresión. En algún punto, la llamada el método original se completa, y posiblemente se devuelve un valor. <br />
<br />
<span style="color: red;">Recursión infinita </span><br />
<br />
La iteración y la recursión pueden producirse infinitamente. Un bucle infinito ocurre si la prueba o test de continuación del bucle nunca se vuelve falsa. <br />
<br />
Una recursión infinita ocurre si la etapa de recursión no reduce el problema en cada ocasión de modo que converja sobre el caso base o condición de la salida. <br />
<br />
En realidad, larecursión infinita significa que cada llamada recursiva produce otra llamada recursiva y esta a su vez otra llamada recursiva, y así para siempre. En la práctica, dicha función se ejecutará hasta que la computadora agote la memoria disponible y se produzca una terminación anormal del programa. <br />
<br />
El flujo de control de una función recursiva requiere de tres condiciones para una terminación normal. <br />
<br />
<span style="color: red;">CUANDO NO UTILIZAR RECURSIVIDAD. </span><br />
<br />
La solucion recursiva de ciertos problemas simplifica mucho la estructura de los programas. Como contrapartida, en la mayoria de los lenguajes de programación las llamadas recursivas a procedimientos o funciones tienen un coste de tiempo mucho mayor que sus homologos iterativos. Se puede, por lo tanto, afrimar que la ejecución de un programa recursivo va a ser mas lenta y menos eficiente que el programa iterativo que soluciona el mismo problema, aunque, a veces, la sencilles de la estructura recursiva justifica el mayor tiempo de ejecucion. <br />
<br />
Los procedimientos recursivos se pueden convertir en no recursivos mediante la introducción de una pila y asi emular las llamadas recursivas. De esta manera se puede eliminar la recursion de aquellas partes de los programas que se ejecutan mas frecuentemente. <br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://www.programacionfacil.com/estructura_datos_csharp:mecanica_de_recursion<br />
<br />
http://es.wikilingue.com/pt/Recursividade_(ciencia_de_la_computaci%C3%B3n)Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-29423611932053586672010-11-22T04:13:00.000-08:002010-11-22T04:13:09.686-08:00Estructuras IterativasMateria: Lenguajes de Programacion.<br />
<br />
<span style="color: red;">CONTROL DE FLUJO: ESTRUCTURAS ITERATIVAS</span><br />
<br />
La iteración permite controlar mediante expresiones lógicas la repetición de una o varias instrucciones dentro del programa. Los bloques con las instrucciones que se repiten se conocen como ciclos o loops. La expresión que controla la ejecución del ciclo se conoce como condición de control. <br />
<br />
El lenguaje de programación C cuenta con tres instrucciones para especificar iteraciones. Aunque las tres instrucciones son lógicamente equivalentes, sus diferencias se radican principalmente en la forma en que se controla la continuación o terminación del ciclo (especificación y verificación). Las instrucciones son: <br />
<br />
• while <br />
• do-while <br />
• for <br />
En realidad, casi todos los lenguajes cuentan con instrucciones parecidas (si no iguales) o que funcionan de un modo muy similar a las que vamos a ver aquí. Las estructuras iterativas de control de flujo se ocupan de repetir una serie de líneas de código tantas veces como el programador indique o bien hasta que se de una cierta condición. A estas estructuras también se les llama bucles.<br />
<br />
<span style="color: red;">BUCLES FOR</span><br />
Los bucles for van asignando valores a una variable desde un valor inicial hasta un valor final, y cuando la variable contiene un valor que está fuera del intervalo el bucle termina. Veamos la sintaxis para hacernos mejor a la idea:<br />
<br />
for (var=inicial;condición;siguientevalor)<br />
{<br />
Instrucciones<br />
}<br />
Sé que esto es algo difícil de leer, incluso para aquellos que hayan programado en otros lenguajes, puesto que los bucles for de C no se parecen mucho, en cuanto a su sintaxis, al resto de los bucles for de los otros lenguajes, así que trataré de explicarlo con detenimiento. Como veis, tras la sentencia for se indican las especificaciones del bucle entre paréntesis. Dichas especificaciones están divididas en tres partes separadas por punto y coma: la parte de asignación del valor inicial en primer lugar; la parte que verifica la continuidad del bucle (mediante una condición) en segundo lugar; y la parte en que se calcula el siguiente valor en tercer lugar. Pongamos un ejemplo: vamos a calcular el factorial de un número dado, que se encuentra almacenado en la variable num. Se podría hacer de dos formas:<br />
for (byte i=num; i>1 ; i--)<br />
{<br />
fact*=i;<br />
}<br />
O bien:<br />
for (byte i=1; i<=num ; i++)<br />
{<br />
fact*=i;<br />
}<br />
En primer lugar se asigna a la variable i el valor de num (vamos a suponer que num vale 3), es decir, después del primer paso, el valor de i es 3. Posteriormente se comprueba si dicha variable es mayor que 1, es decir, si 3>1. Como la condición del segundo paso se cumple se ejecuta el código del bucle en el tercer paso, fact*=i, con lo que fact (que valía 1) ahora vale 3 (1*3). En el cuarto paso se asigna el siguiente valor a i (i--), con lo que, ahora, i valdrá 2. En el quinto se vuelve a comprobar si i es mayor que 1, y como esto se cumple, el sexto paso vuelve a ejecutar el código del bucle (de nuevo, fact*=i), con lo que ahora fact vale 6 (3*2). El séptimo paso es idéntico al cuarto, es decir, se asigna el siguiente valor a la variable i (de nuevo, i--), con lo que ahora i valdría 1. El octavo paso es idéntico al quinto, comprobando por lo tanto si i es mayor que 1. Sin embargo esta vez, la condición no se cumple (1 no es mayor que 1, sino igual), por lo que la ejecución saldría del bucle y ejecutaría la siguiente línea del programa que esté fuera de él. Date cuenta de que el bucle se seguirá ejecutando siempre que la condición ( i>1 ) se cumpla, y dejará de ejecutarse cuando la condición no se cumpla. Por lo tanto, no habría sido válido poner i==2 en lugar de i>1, ya que esta condición se cumpliría únicamente cuando num valiera 2, pero no en cualquier otro caso. ¿Serías capaz de ver cómo funcionaría el otro bucle? Venga, inténtalo.<br />
<span style="color: red;">BUCLES FOR ANIDADOS</span><br />
Efectivamente, se pueden colocar bucles for dentro de otros bucles for, con lo que obtendríamos lo que se llaman los bucles for anidados. Son también muy útiles: por ejemplo, piensa que tienes almacenadas unas cuantas facturas en una base de datos, y quieres leerlas todas para presentarlas en pantalla. El problema está en que cada factura tiene una o varias líneas de detalle. ¿Cómo podríamos hacer para cargar cada factura con todas sus líneas de detalle? Pues usando bucles anidados. Colocaríamos un bucle for para cargar las facturas, y otro bucle for dentro de él para que se cargaran las líneas de detalle de cada factura. Así, el segundo bucle se ejecutará completo en cada iteración del primer bucle. Veamos un ejemplo que nos aclare todo esto un poco más:<br />
<br />
using System;<br />
namespace BuclesAnidados<br />
{<br />
class BuclesAnidadosApp<br />
{<br />
static void Main()<br />
{<br />
for (int i=1; i<=3; i++)<br />
{<br />
Console.WriteLine("Factura número {0}", i);<br />
Console.WriteLine("Detalles de la factura");<br />
for (int j=1; j<=3; j++)<br />
{<br />
Console.WriteLine(" Línea de detalle {0}", j);<br />
}<br />
Console.WriteLine();<br />
}<br />
string a=Console.ReadLine();<br />
}<br />
}<br />
}<br />
Como ves, el bucle "j" está dentro del bucle "i", de modo que se ejecutará completo tantas veces como se itere el bucle i. Por este motivo, la salida en consola sería la siguiente:<br />
Factura número 1<br />
<br />
Detalles de la factura<br />
<br />
Línea de detalle 1<br />
<br />
Línea de detalle 2<br />
<br />
Línea de detalle 3<br />
Factura número 2<br />
<br />
Detalles de la factura<br />
<br />
Línea de detalle 1<br />
<br />
Línea de detalle 2<br />
<br />
Línea de detalle 3<br />
Factura número 3<br />
<br />
Detalles de la factura<br />
<br />
Línea de detalle 1<br />
<br />
Línea de detalle 2<br />
<br />
Línea de detalle 3<br />
Otra forma de anidar los bucles es utilizando solamente una única sentencia for, aunque no es un modo muy recomendable de hacerlo puesto que resulta mucho más difícil de leer. El siguiente código:<br />
<br />
for (int i=1, int j=1; i<=3, j<=3; i++, j++)<br />
{<br />
...<br />
}<br />
Sería el equivalente a esto otro:<br />
for (int i=1; i<=3; i++)<br />
{<br />
for (int j=1; j<=3; j++)<br />
{<br />
...<br />
}<br />
}<br />
<span style="color: red;">BUCLES WHILE</span><br />
Bien, para los que no sepan inglés, "while" significa "mientras", de modo que ya os podéis hacer la idea: un bucle while se repetirá mientras una condición determinada se cumpla, o sea, devuelva true. Veamos su sintaxis:<br />
<br />
while (expresión bool)<br />
{<br />
Instrucciones<br />
}<br />
<br />
Efectivamente, las "Instrucciones" que se hallen dentro del bucle while se ejecutarán continuamente mientras la expresión de tipo boolean retorne true. Por ejemplo, podemos escribir un bucle while para pedir una contraseña de usuario. Algo así:<br />
<br />
using System;<br />
namespace BuclesWhile<br />
{<br />
class BuclesWhileApp<br />
{<br />
static void Main()<br />
{<br />
string Clave="Compadre, cómprame un coco";<br />
string Res="";<br />
while (Res!=Clave)<br />
{<br />
Console.Write("Dame la clave: ");<br />
Res=Console.ReadLine();<br />
}<br />
Console.WriteLine("La clave es correcta");<br />
string a=Console.ReadLine();<br />
}<br />
}<br />
}<br />
<br />
En este pequeño ejemplo el programa pedirá una y otra vez la clave al usuario, y cuando este teclee la clave correcta será cuando finalice la ejecución del mismo. Así, la salida en la consola de este programa sería algo como esto (en rojo está lo que se ha tecleado durante su ejecución):<br />
<br />
Dame la clave: No quiero<br />
<br />
Dame la clave: Que no<br />
<br />
Dame la clave: eres contumaz, ¿eh?<br />
<br />
Dame la clave: Vaaaaale<br />
<br />
Dame la clave: Compadre, cómprame un coco<br />
<br />
<span style="color: red;">La clave es correcta</span><br />
<br />
¿Alguna pregunta? ¿Que qué habría pasado si la condición no se hubiera cumplido antes de ejecutar el bucle, es decir, si Res ya contuviera lo mismo que Clave antes de llegar al while? Bien, pues, en ese caso, el bucle no se hubiera ejecutado ninguna vez, es decir, al comprobar que la expresión de tipo boolean retorna false, la ejecución del programa pasa a la primera línea que se encuentra a continuación del bucle. Vamos a verlo para que te quede más claro. Modificaremos ligeramente el ejemplo anterior, así:<br />
<br />
using System;<br />
namespace BuclesWhile<br />
{<br />
class BuclesWhileApp<br />
{<br />
static void Main()<br />
{<br />
string Clave="Compadre, cómprame un coco";<br />
string Res=Clave;<br />
while (Res!=Clave)<br />
{<br />
Console.Write("Dame la clave: ");<br />
Res=Console.ReadLine();<br />
}<br />
Console.WriteLine("La clave es correcta");<br />
string a=Console.ReadLine();<br />
}<br />
}<br />
}<br />
<br />
En efecto, en este caso, la salida en consola sería la siguiente:<br />
<br />
<span style="color: red;">La clave es correcta</span><br />
Ya que la ejecución no pasa por el bucle. Bueno, ya veis que es muy sencillo. Por cierto, luego os propondré algunos ejercicios para que practiquéis un poco todo esto de los bucles (a ver si pensabais que os ibais a escaquear).<br />
<span style="color: red;">BUCLES DO</span><br />
Ciertamente, estos bucles tienen mucho que ver con los bucles while. La diferencia es que estos se ejecutan siempre al menos una vez, mientras que los bucles while, como acabamos de ver antes, pueden no ejecutarse ninguna vez. Veamos la sintaxis de los bucles "do":<br />
<br />
do<br />
{<br />
Instrucciones<br />
} while (expresión bool);<br />
<br />
Como ves, también hay un while y una expresión boolean, pero en este caso se encuentra al final. De este modo, la ejecución pasará siempre por las instrucciones del bucle una vez antes de evaluar dicha expresión. Vamos a rehacer el ejemplo anterior cambiando el bucle while por un bucle do:<br />
<br />
using System;<br />
namespace BuclesDo<br />
{<br />
class BuclesDoApp<br />
{<br />
static void Main()<br />
{<br />
string Clave="Compadre, cómprame un coco";<br />
string Res="";<br />
do<br />
{<br />
Console.Write("Dame la clave: ");<br />
Res=Console.ReadLine();<br />
} while (Res!=Clave);<br />
Console.WriteLine("La clave es correcta");<br />
string a=Console.ReadLine();<br />
}<br />
}<br />
}<br />
El resultado sería el mismo que antes. La diferencia está en que aquí daría exactamente lo mismo lo que valiera la variable Res antes de llegar al bucle, puesto que este se va a ejecutar antes de comprobar dicho valor, y al ejecutarse, el valor de Res se sustituye por lo que se introduzca en la consola. Por lo tanto, repito, los bucles do se ejecutan siempre al menos una vez.<br />
Por otro lado tenemos otro tipo de bucle, los bucles foreach, pero no hablaremos de ellos hasta que hayamos visto arrays e indizadores. Tened un poco de paciencia, que todo se andará.<br />
<span style="color: red;">INSTRUCCIONES DE SALTO</span><br />
Las instrucciones de salto permiten modificar también el flujo del programa, forzando la siguiente iteración de un bucle antes de tiempo, o la salida del mismo o bien mandando la ejecución directamente a un punto determinado del programa (esto último está altamente perseguido y penado por la ley, o sea, los jefes de proyecto). Son pocas y muy sencillas, así que podéis estar tranquilos, que no os voy a soltar otra biblia con esto...<br />
<br />
<br />
<span style="color: red;">LA INSTRUCCIÓN BREAK</span><br />
Algo hemos visto ya sobre la instrucción break. ¿Cómo que no? Anda, repásate la entrega anterior, hombre... Mira que se te ha olvidado pronto... En fin... a lo que vamos. La instrucción break fuerza la salida de un bucle antes de tiempo o bien de una estructura de control de flujo condicional en la que se encuentre (un switch). Ahora nos fijaremos en los bucles, que es donde andamos. Pondremos un ejemplo sencillo: El siguiente programa escribirá múltiplos de 5 hasta llegar a 100:<br />
<br />
using System;<br />
namespace InstruccionBreak<br />
{<br />
class InstruccionBreakApp<br />
{<br />
static void Main()<br />
{<br />
int num=0;<br />
while (true)<br />
{<br />
Console.WriteLine(num);<br />
num+=5;<br />
if (num>100) break;<br />
}<br />
string a=Console.ReadLine();<br />
}<br />
}<br />
}<br />
<br />
¿Qué es eso de while (true)? Pues un bucle infinito. ¿No decíamos que dentro de los paréntesis había que colocar una expresión boolean? Pues entonces... true es una expresión boolean. De este modo, el bucle es infinito (claro, true siempre es true). Sin embargo, cuando la variable num tiene un valor mayor que 100 la ejecución del bucle terminará, pues se ejecuta una instrucción break.<br />
<br />
<br />
<span style="color: red;">LA INSTRUCCIÓN CONTINUE</span><br />
La instrucción continue fuerza la siguiente iteración del bucle donde se encuentre (que puede ser un bucle for, while, do o foreach). Como esto se ve muy bien con un ejemplo, vamos con ello: El siguiente programa mostrará todos los números del uno al veinte a excepción de los múltiplos de tres:<br />
<br />
using System;<br />
namespace InstruccionContinue<br />
{<br />
class InstruccionContinueApp<br />
{<br />
static void Main()<br />
{<br />
for (int i=1; i<=20; i++)<br />
{<br />
if (i % 3 == 0) continue;<br />
Console.WriteLine(i);<br />
}<br />
string a=Console.ReadLine();<br />
}<br />
}<br />
}<br />
<br />
En este ejemplo, el bucle for va asgnando valores a la variable i entre 1 y 20. Sin embargo, cuando el valor de i es tres o múltiplo de tres (es decir, cuando el resto de la división entre i y 3 es cero) se ejecuta una instrucción continue, de modo que se fuerza una nueva iteración del bucle sin que se haya escrito el valor de i en la consola. Por este motivo, aparecerían todos los números del uno al veinte a excepción de los múltiplos de tres.<br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://www2.ing.puc.cl/~iic11021/materia/cap5.htm<br />
<br />
http://www.exes.es/ManNET/index.asp?Pg=Entrega10.htmObed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-37472141297763712102010-11-22T04:02:00.000-08:002010-11-22T04:02:02.949-08:00Lenguajes MultiparadigmasMateria: Lenguajes de Programacion<br />
<br />
<br />
<span style="color: red;">Introduccion:</span><br />
<br />
Un lenguaje de programación puede soportar distintos paradigmas de programación con el objetivo de que un programador utilice el más conveniente a la hora de resolver un problema.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjOkHqnHHo8Cbyr4WyFORKCjA_mBsPbCfYYqq81nANL2KKRI5acWld0MVwk4_bx3bJBHGn31Gwg-L5B8W1edS6POUR2xe7noB0W4HvgCEDn-0X2VugJM_WCKo_boAs7YWO8E5jlvAEUemQ/s1600/Oz.gif" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="164" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjOkHqnHHo8Cbyr4WyFORKCjA_mBsPbCfYYqq81nANL2KKRI5acWld0MVwk4_bx3bJBHGn31Gwg-L5B8W1edS6POUR2xe7noB0W4HvgCEDn-0X2VugJM_WCKo_boAs7YWO8E5jlvAEUemQ/s200/Oz.gif" width="200" /></a></div>Un lenguaje de programación multiparadigma es el cual soporta más de un paradigma de programación. Según lo describe Bjarne Stroustrup, permiten crear “programas usando más de un estilo de programación”.<br />
<br />
Ningún paradigma es capaz de resolver todos los problemas de forma sencilla y eficiente, por lo tanto es útil poder elegir entre distintos “estilos” de programación dependiendo del tipo de problema. También hay lenguajes que permiten mezclar los paradigmas que, en principio, parecerían irreconciliables. Se debe aclarar que hay subparadigmas que se incluyen en paradigmas más generales, pero hay otros que utilizan métodos de programación totalmente distintos entre sí e igualmente hay lenguajes que los combinan. Por ejemplo, el lenguaje Oz emplea programación lógica, funcional, orientada a objeto y otras.<br />
<br />
Lenguajes como Delphi, C++ y Visual Basic combinan el paradigma imperativo, el procedural y el orientado a objetos.<br />
Incluso lenguajes más puros en sus paradigmas como Prolog (paradigma lógico) o Scheme (paradigma funcional) poseen estructuras iterativas típicas de los lenguajes de paradigma imperativos.<br />
<br />
<span style="color: red;">Esto sirve solamente para la referencia rápida para los paradigmas de programación enumerados aquí</span><br />
<br />
• Flujo de datos - recálculo forzado de fórmulas cuando los valores de los datos cambian (e.g. Hojas de balance) <br />
<br />
• Lenguaje de programación visual - elementos de programa de manipulación gráficamente más bien que especificándolos textual (e.g. Simulink) <br />
<br />
• Programación declarativa - describe acciones (e.g. HTML describa una página pero no cómo exhibirla realmente) <br />
<br />
• Programación imprescindible - declaraciones explícitas que cambian un estado del programa <br />
<br />
• Programación funcional - la evaluación de las aplicaciones de funciones matemáticas y evita el estado y datos mutable <br />
<br />
• Programación orientada al objeto - clases y casos, herencia, encapsulación de las aplicaciones y polimorfismo <br />
<br />
• programación Prototipo-basada - programación orientada al objeto que evita clases y pone herencia en ejecución vía la reproducción de casos <br />
<br />
• El computar paralelo - ejecución simultánea con la comunicación necesaria y sincronización entre los procesos/los hilos de rosca <br />
<br />
• Modelo del agente - cómputo concurrente con los “agentes” esos decisiones locales de las marcas en respuesta al ambiente (capaz de comportamiento egoísta o competitivo) <br />
<br />
• programación de la tubería - ningunas llamadas de función jerarquizadas, pero las estructuras simples de un flujo con fácil visualizar/entienden que los datos atraviesan el programa <br />
<br />
• programación de constreñimiento - las relaciones entre las variables se expresan como los apremios (o redes del constreñimiento), dirigiendo soluciones permisibles (satisfacción del constreñimiento de las aplicaciones o algoritmo a una cara) <br />
<br />
• programación basada en las reglas - una red de las reglas del pulgar que abarcan una base de conocimiento y se pueden utilizar para los sistemas expertos y deducción y resolución del problema <br />
<br />
• programación de la lógica - hechos lógicos de las aplicaciones para crear un modelo que puede probar consistencia, deducir otras verdades o contestar a preguntas sobre el modelo (e.g. ¡Los perros son animales! ¡Los perros son rojos! Son algunos animales rojos?) <br />
<br />
• programación reflexiva - caso especial de metaprogramming (la modificación de programas como datos por otro programa o la capacidad de hacer la parte del trabajo adentro compila tiempo en vez de tiempo en marcha) en el cual el programa modifica o se amplía <br />
<br />
<span style="color: red;">Dos paradigmas</span><br />
<br />
• flujo de datos, visual <br />
<br />
o LabVIEW <br />
<br />
• funcional, imprescindible <br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgtHsQJOQ8TvgaIqA4hN8vkKNfXLRVtVTJlz4N4Z7Hy7sGbg_XWP1jCnFAupkqNKlM2pRGBvA_FRag2rDS5lzAQdw8UzYalMzoCTEU14KMjw7XqozkyElUZi10lnAyLF2GK4hi2Ydw1j9c/s1600/100px-C_plus_plus_svg.png" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgtHsQJOQ8TvgaIqA4hN8vkKNfXLRVtVTJlz4N4Z7Hy7sGbg_XWP1jCnFAupkqNKlM2pRGBvA_FRag2rDS5lzAQdw8UzYalMzoCTEU14KMjw7XqozkyElUZi10lnAyLF2GK4hi2Ydw1j9c/s200/100px-C_plus_plus_svg.png" width="200" /></a></div><br />
o APL <br />
<br />
• funcional, lógica <br />
<br />
o ALF <br />
<br />
• funcional, orientado al objeto (clase-basado) <br />
<br />
o Dylan[la citación necesitó] <br />
<br />
o Sather[citación necesitada] <br />
<br />
• funcional, visual <br />
<br />
o Hojas de balance <br />
<br />
• imperativo, orientado al objeto (clase-basado) <br />
<br />
o AmigaE <br />
<br />
o PHP <br />
<br />
o Simula] <br />
<br />
• orientado al objeto (clase-basado), (prototipo-basado) <br />
<br />
o Metaobject protocolos <br />
<br />
• orientado al objeto (clase-basado), visual <br />
<br />
o Lava <br />
<br />
<span style="color: red;">Tres paradigmas</span><br />
<br />
• concurrente, flujo de datos, funcional <br />
<br />
o SISAL <br />
<br />
• concurrente, funcional, distribuido <br />
<br />
o Erlang <br />
<br />
• concurrente, funcional, lógica <br />
<br />
o Curry <br />
<br />
• concurrente, imprescindible, orientado al objeto (clase-basado) <br />
<br />
o Tirada <br />
<br />
o Java <br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhnu6RUIMFCwi10yiKbOFJf9j1CEMzLVwNjeElkFieCva4BSaIzHCsW3XcH4mlNM5dXxVcZuthoTiVhD6PPH0NkFTzmRBIzakh8xmiY9jLfXMkVg3BMLjrWweCWUIrJRbCyFlTRB99TNZ0/s1600/delphi.png" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="132" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhnu6RUIMFCwi10yiKbOFJf9j1CEMzLVwNjeElkFieCva4BSaIzHCsW3XcH4mlNM5dXxVcZuthoTiVhD6PPH0NkFTzmRBIzakh8xmiY9jLfXMkVg3BMLjrWweCWUIrJRbCyFlTRB99TNZ0/s200/delphi.png" width="200" /></a></div>• flujo de datos, orientado al objeto (clase-basado), visual <br />
<br />
o Prograph <br />
<br />
• funcional, imprescindible, lógica <br />
<br />
o Poplog <br />
<br />
• funcional, imprescindible, orientado al objeto (clase-basado) <br />
<br />
o BETA <br />
<br />
o F# <br />
<br />
o J <br />
<br />
o Perl <br />
<br />
o Pliant <br />
<br />
o Python <br />
<br />
o Rubí <br />
<br />
o Tcl con itcl o XOTcl extensiones <br />
<br />
• funcional, imprescindible, orientado al objeto (prototipo-basado) <br />
<br />
o [1] Lenguaje de programación del halcón <br />
<br />
o ECMAScript <br />
<br />
ActionScript <br />
<br />
DMDScript<br />
<br />
E4X <br />
<br />
Javascript<br />
<br />
JScript <br />
<br />
o Lua <br />
<br />
o Tcl con Snit extensión <br />
<br />
• genérico (plantilla metaprogramming), imperativo, orientado al objeto (clase-basado) <br />
<br />
o C++ <br />
<br />
o D <br />
<br />
<span style="color: red;">Cuatro paradigmas</span><br />
<br />
• funcional, imprescindible, genérico (plantilla metaprogramming), orientado al objeto (clase-basado) <br />
<br />
o C# <br />
<br />
• funcional, imprescindible, genérico (plantilla metaprogramming), orientado al objeto (clase-basado) <br />
<br />
o Caml objetivo <br />
<br />
• funcional, imprescindible, concurrente (Modelo del agente), orientado al objeto (clase-basado) <br />
<br />
o Scala<br />
<br />
• funcional, imprescindible, concurrente (Modelo del agente), orientado al objeto (prototipo-basado) <br />
<br />
o Io <br />
<br />
• funcional, imprescindible, lógica, orientada al objeto (clase-basado) <br />
<br />
o Leda <br />
<br />
• funcional, imprescindible, orientado al objeto (prototipo-basado), dialected <br />
<br />
o REBOL <br />
<br />
• imperativo, lógica, orientada al objeto (clase-basado), basado en las reglas <br />
<br />
o ROOP <br />
<br />
• funcional, imprescindible, orientado al objeto (clase-basado), reflexivo <br />
<br />
o Lisp común (aunque hay otros paradigmas puestos en ejecución como bibliotecas) <br />
<br />
<span style="color: red;">Cinco paradigmas</span><br />
<br />
• concurrente (rendezvous y monitor-como basado), distribuido, genérico, imprescindible, orientado al objeto (clase-basado) <br />
<br />
o Ada <br />
<br />
• funcional, imprescindible, tubería, orientado al objeto (clase-basado), reflexivo <br />
<br />
o Windows PowerShell <br />
<br />
• funcional, genérico (plantilla metaprogramming), imperativo, orientado al objeto (clase-basado), reflexivo <br />
<br />
o Enrollamiento <br />
<br />
<span style="color: red;">Ocho paradigmas</span><br />
• concurrente, constreñimiento, flujo de datos, distribuido, funcional (evaluación: impaciente, perezoso), imperativo, lógica, orientada al objeto (clase-basado) <br />
<br />
o Onza<br />
<br />
Sistema de programación de Mozart (a multiplatform Onza) <br />
<br />
Bibliografias:<br />
<br />
http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_multiparadigma<br />
<br />
http://www.alegsaonline.com/art/14.php<br />
<br />
http://www.worldlingo.com/ma/enwiki/es/Multi-paradigm_programming_languageObed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-30480100007458716822010-11-22T03:55:00.000-08:002010-11-22T03:55:04.438-08:00Tipos de DatosMateria: Lenguajes de Programación.<br />
<br />
<br />
<span style="color: #660000;">Introducción a los tipos de datos</span><br />
<br />
<span style="color: red;">Una definición muy simple:</span><br />
<br />
El tipo de un dato es el conjunto de valores que puede tomar durante el programa. Si se le intenta dar un valor fuera del conjunto se producirá un error. <br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj_Phlwx_YKT2A3eeDgEPxtsyOi1w4RbFgDbfcKqTdI4kusvwWz6xQoPAik4JFN3s07sKjXQF66aThljO3ueQYmn2TyAMrqkZVjm8YS80Ck-WN3oTbh6Yte8AGKnmRmeueRd-LuKNAS1Ok/s1600/bits.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj_Phlwx_YKT2A3eeDgEPxtsyOi1w4RbFgDbfcKqTdI4kusvwWz6xQoPAik4JFN3s07sKjXQF66aThljO3ueQYmn2TyAMrqkZVjm8YS80Ck-WN3oTbh6Yte8AGKnmRmeueRd-LuKNAS1Ok/s200/bits.jpg" width="200" /></a></div>La asignación de tipos a los datos tiene dos objetivos principales: <br />
<br />
• Por un lado, detectar errores en las operaciones <br />
<br />
• Por el otro, determinar cómo ejecutar estas operaciones <br />
<br />
De Pascal se dice que es un lenguaje fuertemente tipeado. Esto quiere decir que todos los datos deben de tener un tipo declarado explícitamente, y además que existen ciertas restricciones en las expresiones en cuanto a los tipos de datos que en ellas intervienen. <br />
<br />
Una ventaja de los lenguajes fuertemente tipeados es que se gasta mucho menos esfuerzo en depurar (corregir) los programas gracias a la gran cantidad de errores que detecta el compilador. <br />
<br />
Los tipos de datos, como casi todos los objetos de Pascal, se pueden declarar. La declaración de tipos ya se comentó en el tema correspondiente a la estructura de un programa. <br />
<br />
<span style="color: red;">Clasificaciones en los tipos de datos</span><br />
<br />
En Pascal existen gran variedad y cantidad de tipos de datos. Pero en este tutorial sólo se trataran los básicos para que puedas ir construyendo tus primeros programas. <br />
<br />
Existen muchas clasificaciones para los tipos de datos, y dependiendo de la fuente que mires, te mostrarán una u otra. A continuacón tienes una de las posibles clasificaciones.: <br />
<br />
• Dinámicos <br />
<br />
• Estáticos <br />
<br />
o El tipo cadena <br />
<br />
o Estructurados <br />
<br />
o Simples <br />
<br />
Ordinales <br />
<br />
No-ordinales <br />
<br />
<span style="color: red;">Tipos estáticos</span><br />
<br />
Casi todos los tipos de datos son estáticos, la excepción son los punteros y no se tratarán debido a su complejidad. <br />
<br />
Que un tipo de datos sea estático quiere decir que el tamaño que ocupa en memoria no puede variar durante la ejecución del programa. Es decir, una vez declarada una variable de un tipo determinado, a ésta se le asigna un trozo de memoria fijo, y este trozo no se podrá aumentar ni disminuír. <br />
<span style="color: red;">Tipos dinámicos</span><br />
Dentro de esta categoría entra sólamente el tipo puntero. Este tipo te permite tener un mayor control sobre la gestión de memoria en tus programas. Con ellos puedes manejar el tamaño de tus variables en tiempo de ejecución, o sea, cuando el programa se está ejecutando. <br />
<br />
Los punteros quizás sean el concepto más complejo a la hora de aprender un lenguaje de programación, sobre todo si es el primero que aprendes. Debido a esto, no lo trataremos. Además, lenguajes que están muy de moda (por ejemplo Java) no permiten al programador trabajar con punteros. <br />
<br />
<span style="color: red;">Tipos simples</span><br />
Como su nombre indica son los tipos básicos en Pascal. Son los más sencillos y los más fáciles de aprender. Por todo esto, serán en los que nos centremos. <br />
<br />
Los tipos simples más básicos son: entero, lógico, carácter y real. Y la mayoría de los lenguajes de programación los soportan, no como ocurre con los estructurados que pueden variar de un lenguaje a otro. <br />
<br />
<span style="color: red;">Tipos estructurados</span><br />
Mientras que una variable de un tipo simple sólo referencia a un elemento, los estructurados se refieren a colecciones de elementos. <br />
<br />
Las colecciones de elementos que aparecen al hablar de tipos estructurados son muy variadas: tenemos colecciones ordenadas que se representan mediante el tipo array, colecciones sin orden mediante el tipo conjunto, e incluso colecciones que contienen otros tipos, son los llamados registros. <br />
<br />
<span style="color: red;">Tipos ordinales</span><br />
<br />
Dentro de los tipos simples, los ordinales son los más abundantes. De un tipo se dice que es ordinal porque el conjunto de valores que representa se puede contar, es decir, podemos establecer una relación uno a uno entre sus elementos y el conjunto de los números naturales. <br />
<br />
<span style="color: red;">Dentro de los tipos simples ordinales, los más importantes son: </span><br />
<br />
• El tipo entero (integer) <br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgZtZA2VaYTN-NTi1xsLdnDPnXtID2Jvp4H5PKRIPnWvNDgBRZKZXHZYqCxiJO2DE0865-xkta-OryhmmB_J8ygw9r8_6gerNcbxksa02fzEc9znILnCnI1ERAYVVF0hHW1Jyb4j8QFUyI/s1600/Duke_Int_Float_Char.gif" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="191" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgZtZA2VaYTN-NTi1xsLdnDPnXtID2Jvp4H5PKRIPnWvNDgBRZKZXHZYqCxiJO2DE0865-xkta-OryhmmB_J8ygw9r8_6gerNcbxksa02fzEc9znILnCnI1ERAYVVF0hHW1Jyb4j8QFUyI/s200/Duke_Int_Float_Char.gif" width="200" /></a></div>• El tipo lógico (boolean) <br />
<br />
• El tipo carácter (char) <br />
<br />
<span style="color: red;">Tipos no-ordinales</span><br />
<br />
Simplificando, podríamos reducir los tipos simples no-ordinales al tipo real. Este tipo nos sirve para declarar variables que pueden tomar valores dentro del conjunto de los números reales. <br />
<br />
A diferencia de los tipos ordinales, los no-ordinales no se pueden contar. No se puede establecer una relación uno a uno entre ellos y los número naturales. Dicho de otra forma, para que un conjunto se considere ordinal se tiene que poder calcular la posición, el anterior elemento y el siguiente de un elemento cualquiera del conjunto.¿Cuál es el sucesor de 5.12? Será 5.13, o 5.120, o 5.121, ... <br />
<br />
<span style="color: red;">Los tipos básicos que nos interesan</span><br />
<br />
Después de ver una de las posibles clasificaciones para los tipos de datos, pasemos a ver los que nos interesan: los tipos simples. Realmente de los tipos simples veremos los más básicos, que son: integer, boolean, char y real. Además, también hablaremos un poco de las cadenas de caracteres, los llamados strings. <br />
<br />
nota: a continuación sólo se comentará qué es cada tipo, no se explicará su declaración, esto puedes verlo si vas a la sección correspondiente. <br />
<span style="color: red;">El tipo integer (entero)</span><br />
<br />
Como ya habrás leído el tipo de datos entero es un tipo simple, y dentro de estos, es ordinal. Al declarar una variable de tipo entero, estás creando una variable numérica que puede tomar valores positivos o negativos, y sin parte decimal. <br />
<br />
Este tipo de variables, puedes utilizarlas en asignaciones, comparaciones, expresiones aritméticas, etc. Algunos de los papeles más comunes que desarrollan son: <br />
<br />
• Controlar un bucle <br />
<br />
• Usarlas como contador, incrementando su valor cuando sucede algo <br />
<br />
• Realizar operaciones enteras, es decir, sin parte decimal <br />
<br />
• Y muchas más... <br />
<br />
A continuación tienes un ejemplo en el que aparecen dos variables enteras. Como puedes ver, en el ejemplo se muestran las dos maneras de declarar una variable de tipo entero: <br />
<br />
type<br />
tContador = integer;<br />
var <br />
i : tContador;<br />
n : integer;<br />
begin<br />
n := 10; (* asignamos valor al maximo *)<br />
i := 1; (* asignamos valor al contador *)<br />
while (i <= n) do begin<br />
writeln('El valor de i es ',i);<br />
i := i + 1<br />
end<br />
end. <br />
<br />
<span style="color: red;">El tipo boolean (lógico)</span><br />
<br />
El tipo de datos lógico es el que te permite usar variables que disponen sólo de dos posibles valores: cierto o falso. Debido a esto, su utilidad salta a la vista, y no es otra que variables de chequeo. Nos sirven para mantener el estado de un objeto mediante dos valores: <br />
• si/no <br />
• cierto/falso <br />
• funciona/no funciona <br />
• on/off <br />
• etc. <br />
<br />
<span style="color: red;">Para aclararlo, veamos un ejemplo:</span><br />
type<br />
tLogico = boolean;<br />
var <br />
llueve : tLogico; (* si llueve o no *)<br />
paraguas : boolean; (* si encuentro o no el paraguas *)<br />
begin<br />
(* aqui se determinarian los valores de "llueve" y "paraguas" *) <br />
if llueve and (not paraguas) then <br />
writeln('Me quedo en casita')<br />
else <br />
writeln('Me voy a dar un paseo')<br />
end. <br />
<br />
<span style="color: red;">El tipo real (real)</span><br />
<br />
Como ya has visto, Pascal soporta el conjunto entero de números. Pero no es el único, también te permite trabajar con números pertenecientes al conjunto real. <br />
<br />
El tipo de datos real es el que se corresponde con los números reales. Este es un tipo importante para los cálculos. Por ejemplo en los estadísticos, ya que se caracterizan por tratar fundamentalmente con valores decimales. <br />
<br />
nota: Aunque pueda que estés acostumbrado a escribir con coma los decimales, te advierto que en Pascal y en todos los lenguajes de programación se escribe con un punto. Por ejemplo: 3.1416 <br />
<br />
A continuación tienes un ejemplo en el que se utiliza el tipo real. En el puedes ver las dos formas de declarar una variable real, y tambíen el uso de una constante real. Por si tienes curiosidad, el resultado de ejecutar el programa compilado es:<br />
<br />
El area para un radio de 3.14 es 63.6174 <br />
const<br />
pi = 3.1416; <br />
type<br />
tArea = real;<br />
var <br />
A : tArea; (* area *)<br />
R : real; (* radio *)<br />
begin<br />
R := 4.50;<br />
A := pi * R * R; (* calculamos el area *)<br />
writeln('El area para un radio de ',R:4:2,' es ',A:8:4)<br />
end. <br />
<br />
<span style="color: red;">Los tipos char y string (carácter y cadena)</span><br />
<br />
Con el tipo carácter puedes tener objetos que representen una letra, un número, etc. Es decir, puedes usar variables o constantes que representen un valor alfanumérico. Pero ojo, cada variable sólo podrá almacenar un carácter. <br />
<br />
Sin embargo, con las cadenas de caracteres (strings) puedes contener en una sóla variable más de un carácter. Por ejemplo, puedes tener en una variable tu nombre. <br />
<br />
<span style="color: red;">Veamos cómo se usan ambos tipos en el siguiente ejemplo</span><br />
type<br />
tNombre = string[10]; (* puede almacenar 10 caracteres *)<br />
var <br />
nombre : tNombre; (* variable para almacenar el nombre *)<br />
letra_NIF : char; (* caracter para contener la letra del NIF *)<br />
begin<br />
nombre := 'Beni';<br />
letra_NIF := 'L';<br />
writeln('Mi nombre es ',nombre,' y mi letra es ',letra_NIF) <br />
end. <br />
<br />
Se clasifican en 13 tipos de datos primarios y de varios sinónimos válidos reconocidos por dichos tipos de datos.<br />
<br />
<span style="color: red;">Tipos de datos primarios: </span><br />
<br />
BINARY 1 byte Para consultas sobre tabla adjunta de productos<br />
<br />
de bases de datos que definen un tipo de datos Binario. <br />
<br />
BIT 1 byte Valores Si/No ó True/False <br />
<br />
BYTE 1 byte Un valor entero entre 0 y 255.<br />
<br />
COUNTER 4 bytes Un número incrementado automáticamente<br />
<br />
(de tipo Long)<br />
<br />
CURRENCY 8 bytes Un entero escalable entre 922.337.203.685.477,5808<br />
<br />
y 922.337.203.685.477,5807.<br />
<br />
DATETIME 8 bytes Un valor de fecha u hora entre los años<br />
<br />
100 y 9999.<br />
<br />
SINGLE 4 bytes Un valor en punto flotante de precisión<br />
<br />
simple con un rango de -3.402823*1038 a -1.401298*10-45<br />
<br />
para valores negativos, 1.401298*10-45 a 3.402823*1038<br />
<br />
para valores positivos, y 0.<br />
<br />
DOUBLE 8 bytes Un valor en punto flotante de doble precisión<br />
<br />
con un rango de -1.79769313486232*10308 a -4.94065645841247*10-324<br />
<br />
para valores negativos, 4.94065645841247*10-324 a 1.79769313486232*10308<br />
<br />
para valores positivos, y 0.<br />
<br />
SHORT 2 bytes Un entero corto entre -32,768 y 32,767.<br />
<br />
LONG 4 bytes Un entero largo entre -2,147,483,648 y 2,147,483,647.<br />
<br />
LONGTEXT 1 byte por carácter De cero a un máximo de 1.2 gigabytes.<br />
<br />
LONGBYNARY Según se necesite De cero 1 gigabyte. Utilizado para objetos<br />
<br />
OLE.<br />
<br />
TEXT 1 byte por caracter <br />
<br />
Bibliografias:<br />
<br />
http://teleformacion.edu.aytolacoruna.es/PASCAL/document/tipos.htm<br />
<br />
http://www.maestrosdelweb.com/editorial/tutsql6/Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-24803713146962520872010-11-22T03:45:00.000-08:002010-11-22T03:46:07.907-08:00Lenguajes Orientados a ObjetosMateria: Lenguajes de Programacion<br />
<br />
<br />
<span style="color: red;">Introduccion:</span><br />
<br />
La programación orientada a objetos o POO (OOP según sus siglas en inglés) es un paradigma de programación que usa objetos y sus interacciones, para diseñar aplicaciones y programas informáticos. Está basado en varias técnicas, incluyendo herencia, abstracción, polimorfismo y encapsulamiento. Su uso se popularizó a principios de la década de los años 1990. En la actualidad, existe variedad de lenguajes de programación que soportan la orientación a objetos.<br />
<br />
Se le llama así a cualquier lenguaje de programación que implemente los conceptos definidos por la programación orientada a objetos.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjySq9dz2WxhUUc180mN9w50NzaTUQ4dkKUpg7zA5lq5QZKWifXYs1BdnS-eDAYM_Vbycm-v-MVWoHkWulJQ0968X1AdFmrtnP2N5pwb4gS3N-vPp4UmpMkALkGj9nSIkUnwCA2hAt7vOY/s1600/100px-C_plus_plus_svg.png" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjySq9dz2WxhUUc180mN9w50NzaTUQ4dkKUpg7zA5lq5QZKWifXYs1BdnS-eDAYM_Vbycm-v-MVWoHkWulJQ0968X1AdFmrtnP2N5pwb4gS3N-vPp4UmpMkALkGj9nSIkUnwCA2hAt7vOY/s1600/100px-C_plus_plus_svg.png" /></a></div>Cabe notar que los conceptos definidos en la programación orientada a objetos no son una condición sino que son para definir que un lenguaje es orientado a objetos. Existen conceptos que pueden estar ausentes en un lenguaje dado y sin embargo, no invalidar su definición como lenguaje orientado a objetos.<br />
<br />
Quizás las condiciones mínimas necesarias las provee el formalismo que modeliza mejor las propiedades de un sistema orientado a objetos: los tipos de datos abstractos.<br />
<br />
Siguiendo esa idea, cualquier lenguaje que permita la definición de tipos de datos , de operaciones nuevas sobre esos tipos de datos, y de instanciar el tipo de datos podría ser considerado orientado a objetos.<br />
<br />
Esta definición concuerda incluso con ciertos ejemplos prácticos, que no son considerados dentro de la programación orientada a objetos, pero que podrían serlo. Por ejemplo, la programación de interfaces gráficas de usuario para los sistemas X-Window utilizando infraestructuras de funciones y APIs como Motif, Xview y Xlib, son realizadas usualmente en lenguaje C, pero organizando el código en una manera que "parecen objetos" (los Widgets).<br />
<br />
<span style="color: red;">Orientadoa a Objetos?</span><br />
<br />
Los objetos son entidades que combinan estado (atributo), comportamiento (método) e identidad:<br />
<br />
• El estado está compuesto de datos, será uno o varios atributos a los que se habrán asignado unos valores concretos (datos).<br />
<br />
• El comportamiento está definido por los procedimientos o métodos con que puede operar dicho objeto, es decir, qué operaciones se pueden realizar con él.<br />
<br />
• La identidad es una propiedad de un objeto que lo diferencia del resto, dicho con otras palabras, es su identificador (concepto análogo al de identificador de una variable o una constante).<br />
<br />
Un objeto contiene toda la información que permite definirlo e identificarlo frente a otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma clase, al poder tener valores bien diferenciados en sus atributos. A su vez, los objetos disponen de mecanismos de interacción llamados métodos, que favorecen la comunicación entre ellos. Esta comunicación favorece a su vez el cambio de estado en los propios objetos. Esta característica lleva a tratarlos como unidades indivisibles, en las que no se separa el estado y el comportamiento.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgxDjUWyo8RIwg1G5izD0zkR_XaS_HIFb5LskKYdrRjLwGONbX3Y73Z58GKVA6Kbf8uUZB7V9_7J7k9wb3qb2N-Fi815K0Sj2slY-F1jzXCdkCwoK5DQ9J_40oyOeeIizg1HYUe3QlcRTs/s1600/java_logo.png" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgxDjUWyo8RIwg1G5izD0zkR_XaS_HIFb5LskKYdrRjLwGONbX3Y73Z58GKVA6Kbf8uUZB7V9_7J7k9wb3qb2N-Fi815K0Sj2slY-F1jzXCdkCwoK5DQ9J_40oyOeeIizg1HYUe3QlcRTs/s200/java_logo.png" width="107" /></a></div>Los métodos (comportamiento) y atributos (estado) están estrechamente relacionados por la propiedad de conjunto. Esta propiedad destaca que una clase requiere de métodos para poder tratar los atributos con los que cuenta. El programador debe pensar indistintamente en ambos conceptos, sin separar ni darle mayor importancia a alguno de ellos. Hacerlo podría producir el hábito erróneo de crear clases contenedoras de información por un lado y clases con métodos que manejen a las primeras por el otro. De esta manera se estaría realizando una programación estructurada camuflada en un lenguaje de programación orientado a objetos.<br />
<br />
La POO difiere de la programación estructurada tradicional, en la que los datos y los procedimientos están separados y sin relación, ya que lo único que se busca es el procesamiento de unos datos de entrada para obtener otros de salida. La programación estructurada anima al programador a pensar sobre todo en términos de procedimientos o funciones, y en segundo lugar en las estructuras de datos que esos procedimientos manejan. En la programación estructurada sólo se escriben funciones que procesan datos. Los programadores que emplean POO, en cambio, primero definen objetos para luego enviarles mensajes solicitándoles que realicen sus métodos por sí mismos.<br />
<br />
<span style="color: red;">Conceptos:</span><br />
<br />
La programación orientada a objetos es una forma de programar que trata de encontrar una solución a estos problemas. Introduce nuevos conceptos, que superan y amplían conceptos antiguos ya conocidos. Entre ellos destacan los siguientes:<br />
<br />
• Clase: definiciones de las propiedades y comportamiento de un tipo de objeto concreto. La instanciación es la lectura de estas definiciones y la creación de un objeto a partir de ellas.<br />
<br />
• Herencia: (por ejemplo, herencia de la clase C a la clase D) Es la facilidad mediante la cual la clase D hereda en ella cada uno de los atributos y operaciones de C, como si esos atributos y operaciones hubiesen sido definidos por la misma D. Por lo tanto, puede usar los mismos métodos y variables publicas declaradas en C. Los componentes registrados como "privados" (private) también se heredan, pero como no pertenecen a la clase, se mantienen escondidos al programador y sólo pueden ser accedidos a través de otros métodos públicos. Esto es así para mantener hegemónico el ideal de OOP.<br />
<br />
• Objeto: entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o funcionalidad (métodos) los mismos que consecuentemente reaccionan a eventos. Se corresponde con los objetos reales del mundo que nos rodea, o a objetos internos del sistema (del programa). Es una instancia a una clase.<br />
<br />
• Método: Algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecución se desencadena tras la recepción de un "mensaje". Desde el punto de vista del comportamiento, es lo que el objeto puede hacer. Un método puede producir un cambio en las propiedades del objeto, o la generación de un "evento" con un nuevo mensaje para otro objeto del sistema.<br />
<br />
• Evento: Es un suceso en el sistema (tal como una interacción del usuario con la máquina, o un mensaje enviado por un objeto). El sistema maneja el evento enviando el mensaje adecuado al objeto pertinente. También se puede definir como evento, a la reacción que puede desencadenar un objeto, es decir la acción que genera.<br />
<br />
• Mensaje: una comunicación dirigida a un objeto, que le ordena que ejecute uno de sus métodos con ciertos parámetros asociados al evento que lo generó.<br />
<br />
• Propiedad o atributo: contenedor de un tipo de datos asociados a un objeto (o a una clase de objetos), que hace los datos visibles desde fuera del objeto y esto se define como sus características predeterminadas, y cuyo valor puede ser alterado por la ejecución de algún método.<br />
<br />
• Estado interno: es una variable que se declara privada, que puede ser únicamente accedida y alterada por un método del objeto, y que se utiliza para indicar distintas situaciones posibles para el objeto (o clase de objetos). No es visible al programador que maneja una instancia de la clase.<br />
<br />
• Componentes de un objeto: atributos, identidad, relaciones y métodos.<br />
<br />
• Identificación de un objeto: un objeto se representa por medio de una tabla o entidad que esté compuesta por sus atributos y funciones correspondientes.<br />
<br />
En comparación con un lenguaje imperativo, una "variable", no es más que un contenedor interno del atributo del objeto o de un estado interno, así como la "función" es un procedimiento interno del método del objeto.<br />
<br />
<span style="color: red;">Caracteristicas</span><br />
<br />
Existe un acuerdo acerca de qué características contempla la "orientación a objetos", las características siguientes son las más importantes:<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhUkFk44oYimEQudETXUA-r0Ye0e3UXwvhHY35lrxGUv4S2epcc8erqyj9uHJzh3S4JPe7kYr8Y3IWTQytFVBxGYz7O27D5WjPE91eER39ZUVGpnocYPovk1Po7gw9mqqm8xEuaDcGorWM/s1600/perl_logo.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhUkFk44oYimEQudETXUA-r0Ye0e3UXwvhHY35lrxGUv4S2epcc8erqyj9uHJzh3S4JPe7kYr8Y3IWTQytFVBxGYz7O27D5WjPE91eER39ZUVGpnocYPovk1Po7gw9mqqm8xEuaDcGorWM/s200/perl_logo.jpg" width="151" /></a></div>• Abstracción: denota las características esenciales de un objeto, donde se capturan sus comportamientos.Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características. Los procesos, las funciones o los métodos pueden también ser abstraídos y cuando lo están, una variedad de técnicas son requeridas para ampliar una abstracción.El proceso de abstracción permite seleccionar las características relevantes dentro de un conjunto e identificar comportamientos comunes para definir nuevos tipos de entidades en el mundo real. La abstracción es clave en el proceso de análisis y diseño orientado a objetos, ya que mediante ella podemos llegar a armar un conjunto de clases que permitan modelar la realidad o el problema que se quiere atacar.<br />
<br />
• Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar la cohesión de los componentes del sistema. Algunos autores confunden este concepto con el principio de ocultación, principalmente porque se suelen emplear conjuntamente.<br />
<br />
• Modularidad: Se denomina Modularidad a la propiedad que permite subdividir una aplicación en partes más pequeñas (llamadas módulos), cada una de las cuales debe ser tan independiente como sea posible de la aplicación en sí y de las restantes partes. Estos módulos que se puedan compilar por separado, pero que tienen conexiones con otros módulos. Al igual que la encapsulación, los lenguajes soportan la Modularidad de diversas formas.<br />
<br />
• Principio de ocultación: Cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas, solamente los propios métodos internos del objeto pueden acceder a su estado. Esto asegura que otros objetos no pueden cambiar el estado interno de un objeto de maneras inesperadas, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstracción. La aplicación entera se reduce a un agregado o rompecabezas de objetos.<br />
<br />
• Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado. Cuando esto ocurre en "tiempo de ejecución", esta última característica se llama asignación tardía o asignación dinámica. Algunos lenguajes proporcionan medios más estáticos (en "tiempo de compilación") de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.<br />
<br />
• Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener que volver a implementarlo. Esto suele hacerse habitualmente agrupando los objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común. Cuando un objeto hereda de más de una clase se dice que hay herencia múltiple.<br />
<br />
• Recolección de basura: la recolección de basura o garbage collector es la técnica por la cual el entorno de objetos se encarga de destruir automáticamente, y por tanto desvincular la memoria asociada, los objetos que hayan quedado sin ninguna referencia a ellos. Esto significa que el programador no debe preocuparse por la asignación o liberación de memoria, ya que el entorno la asignará al crear un nuevo objeto y la liberará cuando nadie lo esté usando. En la mayoría de los lenguajes híbridos que se extendieron para soportar el Paradigma de Programación Orientada a Objetos como C++ u Object Pascal, esta característica no existe y la memoria debe desasignarse manualmente.<br />
<span style="color: red;">Los Lenguajes orientados a objetos son:</span><br />
• C++<br />
• Objective C<br />
• Java<br />
• Smalltalk<br />
• Eiffel<br />
• Lexico (en castellano)<br />
• Ruby<br />
• Python<br />
• OCAML<br />
• Object Pascal<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjY6vUVJNQOXv1vacwq_JKKnI8-BIvBKOwLFbUIanYGqVbMJYyHsKHx_f-MLwBunRkltFlpQiKoB9iqfrQySkmRKCmeWqvdxHINMX7aWofMZ_cFWyWoIr6YqPWTq2VTvnoaQnUcegcOFEQ/s1600/images.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="107" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjY6vUVJNQOXv1vacwq_JKKnI8-BIvBKOwLFbUIanYGqVbMJYyHsKHx_f-MLwBunRkltFlpQiKoB9iqfrQySkmRKCmeWqvdxHINMX7aWofMZ_cFWyWoIr6YqPWTq2VTvnoaQnUcegcOFEQ/s320/images.jpg" width="320" /></a></div>• CLIPS<br />
• Visual .net<br />
• Actionscript<br />
• COBOL<br />
• Perl<br />
• C#<br />
• Visual Basic.NET<br />
• PHP<br />
• Simula<br />
• Delphi<br />
• PowerBuilder<br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<a href="http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos">http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos</a><br />
<br />
http://es.wikipedia.org/wiki/Lenguaje_orientado_a_objetos<br />
<br />
<span style="color: red;"></span>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-1676042687328940152010-11-22T03:38:00.000-08:002010-11-22T03:38:44.168-08:00Lenguajes Imperativos<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">Materia: Lenguajes de Programación.</div><br />
<br />
<span style="color: red;">Introduccion.</span><br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">La programación imperativa, en contraposición a la programación declarativa es un paradigma de programación que describe la programación en términos del estado del programa y sentencias que cambian dicho estado. Los programas imperativos son un conjunto de instrucciones que le indican al computador cómo realizar una tarea.</div><br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj5SnxETE7M2urOSNgY6IR31FlcdmFWVIcb78zXPwn51RPrjM89yiH7WtCRzj95LEWtFQCNLMP4tmk5FnSeKqx9QYEcQas9NERTnMbHDOOv7aomTs_q_mdCoF9Jk_AvEDlBpZepOTf7JUc/s1600/c.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="194" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj5SnxETE7M2urOSNgY6IR31FlcdmFWVIcb78zXPwn51RPrjM89yiH7WtCRzj95LEWtFQCNLMP4tmk5FnSeKqx9QYEcQas9NERTnMbHDOOv7aomTs_q_mdCoF9Jk_AvEDlBpZepOTf7JUc/s200/c.jpg" width="200" /></a>La implementación de hardware de la mayoría de computadores es imperativa; prácticamente todo el hardware de los computadores está diseñado para ejecutar código de máquina, que es nativo al computador, escrito en una forma imperativa. Esto se debe a que el hardware de los computadores implementa el paradigma de las Máquinas de Turing. Desde esta perspectiva de bajo nivel, el estilo del programa está definido por los contenidos de la memoria, y las sentencias son instrucciones en el lenguaje de máquina nativo del computador (por ejemplo el lenguaje ensamblador).</div><br />
Los lenguajes imperativos de alto nivel usan variables y sentencias más complejas, pero aún siguen el mismo paradigma. Las recetas y las listas de revisión de procesos, a pesar de no ser programas de computadora, son también conceptos familiares similares en estilo a la programación imperativa; cada paso es una instrucción, y el mundo físico guarda el estado (Zoom).<br />
<br />
Los primeros lenguajes imperativos fueron los lenguajes de máquina de los computadores originales. En estos lenguajes, las instrucciones fueron muy simples, lo cual hizo la implementación de hardware fácil, pero obstruyendo la creación de programas complejos. Fortran, cuyo desarrollo fue iniciado en 1954 por John Backus en IBM, fue el primer gran lenguaje de programación en superar los obstáculos presentados por el código de máquina en la creación de programas complejos.<br />
<br />
<span style="color: red;">Algunos lenguajes imperativos</span><br />
• ASP<br />
• BASIC<br />
• Lenguaje de programación C<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhR3YVQV73-o5nyojaOrobRk40He5NAf4F65SL-hx-tJoOIi3JReNqlfeQaG1a-cXVmcBHyX-R7XizAr74hoxHvrTZ0p3MkYvOZsg5cryeCbXhvSKlyyKCXPUYAFviq_42F06qEVojbjkE/s1600/pascal.png" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="66" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhR3YVQV73-o5nyojaOrobRk40He5NAf4F65SL-hx-tJoOIi3JReNqlfeQaG1a-cXVmcBHyX-R7XizAr74hoxHvrTZ0p3MkYvOZsg5cryeCbXhvSKlyyKCXPUYAFviq_42F06qEVojbjkE/s200/pascal.png" width="200" /></a>• Fortran</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">• Pascal</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">• Perl</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">• PHP</div>• Lua<br />
• Java<br />
<br />
<span style="color: red;">Ejemplo:</span><br />
<br />
Este es un ejemplo sencillo de perl donde ordena de manera diferente la secuencia de numeros.<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi8cpVlpnSNE3lFj8-y6tkA0xdj8MKEXwspmgwgenwXiytWpc-3PQiJGOZA6PxTn0A4BeM4CeA9DICARZjDUl_ddTPGCuYriEYdFLbgtgzz5nnA4zNs2BiQDhHeUpaEnXxWyalXRuIszh4/s1600/foto21.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi8cpVlpnSNE3lFj8-y6tkA0xdj8MKEXwspmgwgenwXiytWpc-3PQiJGOZA6PxTn0A4BeM4CeA9DICARZjDUl_ddTPGCuYriEYdFLbgtgzz5nnA4zNs2BiQDhHeUpaEnXxWyalXRuIszh4/s320/foto21.png" width="320" /></a></div><br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgcR_UG52Bdm5RXnsHO1VTom4YmiGksfzdN-bD-von2AGLmC17CiZbeTK4I9rp4OBrYtr7QDBdN_C7-qA5ChB9arUzmg4f_WWxSU4rINKLzLdfHWwpuvp9dkQb-JhOuhqB737P7_ujkHgk/s1600/foto22.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="187" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgcR_UG52Bdm5RXnsHO1VTom4YmiGksfzdN-bD-von2AGLmC17CiZbeTK4I9rp4OBrYtr7QDBdN_C7-qA5ChB9arUzmg4f_WWxSU4rINKLzLdfHWwpuvp9dkQb-JhOuhqB737P7_ujkHgk/s320/foto22.png" width="320" /></a></div><br />
<br />
<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><span style="color: red;">Bibliografias.</span></div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">http://es.wikipedia.org/wiki/Programaci%C3%B3n_imperativa</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-62995580186891312602010-11-22T03:31:00.000-08:002010-11-22T03:32:43.075-08:00Lenguajes LogicosMateria: Lenguajes de Programación.<br />
<br />
<br />
<span style="color: red;">Introduccion:</span><br />
<br />
La programación lógica consiste en la aplicación del corpus de conocimiento sobre lógica para el diseño de lenguajes de programación; no debe confundirse con la disciplina de la lógica computacional.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhrPEHTrBjTsTBMS4YVHnMPasm-1HqQKLtps0RyJ0dEHeKaHXTX7pwvR-4oz4iSbtoJd0JJzPkELM8C8TDIO7oKU5UwBe0Fuc4YWzcCJ0-RcLyi6azEuJ4nIEeLUFH7Z3r018o_2yGUle0/s1600/prolog.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="153" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhrPEHTrBjTsTBMS4YVHnMPasm-1HqQKLtps0RyJ0dEHeKaHXTX7pwvR-4oz4iSbtoJd0JJzPkELM8C8TDIO7oKU5UwBe0Fuc4YWzcCJ0-RcLyi6azEuJ4nIEeLUFH7Z3r018o_2yGUle0/s200/prolog.jpg" width="200" /></a></div>La programación lógica es un tipo de paradigmas de programación dentro del paradigma de programación declarativa. El resto de los subparadigmas de programación dentro de la programación declarativa son: programación funcional, programación basada en restricciones, programas DSL (de dominio específico) e híbridos. La programación lógica gira en torno al concepto de predicado, o relación entre elementos. La programación funcional se basa en el concepto de función (que no es más que una evolución de los predicados), de corte más matemático<br />
<br />
<span style="color: red;">Campos de Aplicacion</span><br />
<br />
La programación lógica encuentra su hábitat natural en aplicaciones de inteligencia artificial o relacionadas:<br />
<br />
• Sistemas expertos, donde un sistema de información imita las recomendaciones de un experto sobre algún dominio de conocimiento.<br />
<br />
• Demostración automática de teoremas, donde un programa genera nuevos teoremas sobre una teoría existente.<br />
<br />
• Reconocimiento de lenguaje natural, donde un programa es capaz de comprender (con limitaciones) la información contenida en una expresión lingüística humana.<br />
<br />
• Etc.<br />
<br />
La programación lógica también se utiliza en aplicaciones más "mundanas" pero de manera muy limitada, ya que la programación tradicional es más adecuada a tareas de propósito general.<br />
<br />
<span style="color: red;">Fundamentos</span><br />
<br />
La mayoría de los lenguajes de programación lógica se basan en la teoría lógica de primer orden, aunque también incorporan algunos comportamientos de orden superior. En este sentido, destacan los lenguajes funcionales, ya que se basan en el cálculo lambda, que es la única teoría lógica de orden superior que es demostradamente computable (hasta el momento).<br />
<br />
<span style="color: red;">Uso:</span><br />
<br />
Históricamente, los ordenadores se han programado utilizando lenguajes muy cercanos a las peculiaridades de la propia máquina: operaciones aritméticas simples, instrucciones de acceso a memoria, etc. Un programa escrito de esta manera puede ocultar totalmente su propósito a la comprensión de un ser humano, incluso uno entrenado. Hoy día, estos lenguajes pertenecientes al paradigma de la Programación imperativa han evolucionado de manera que ya no son tan crípticos.<br />
<br />
En cambio, la lógica matemática es la manera más sencilla, para el intelecto humano, de expresar formalmente problemas complejos y de resolverlos mediante la aplicación de reglas, hipótesis y teoremas. De ahí que el concepto de "programación lógica" resulte atractivo en diversos campos donde la programación tradicional es un fracaso.<br />
<br />
<span style="color: red;">Lenguajes:</span><br />
<br />
El lenguaje de programación lógica por excelencia es Prolog, que cuenta con diversas variantes. La más importante es la programación lógica con restricciones (véase artículo sobre programación con restricciones), que posibilita la resolución de ecuaciones lineales además de la demostración de hipótesis.<br />
<br />
<strong>Notas: *</strong><br />
La teoría del orden es una rama de la matemática que estudia varias clases de relaciones binarias que capturan la noción intuitiva del orden matemático.<br />
<br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://es.wikipedia.org/wiki/Programaci%C3%B3n_l%C3%B3gicaObed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com0tag:blogger.com,1999:blog-6147241035718533881.post-17668315240232165252010-11-21T12:08:00.000-08:002010-11-21T12:08:28.352-08:00Lenguajes Funcionales.<strong>Materia: Lenguajes de programación web.</strong><br />
<br />
<span style="color: red;">Introduccion:</span><br />
<br />
En ciencias de la computación, la programación funcional es un paradigma de programación declarativa basado en la utilización de funciones aritméticas que no maneja datos mutables o de estado. Enfatiza la aplicación de funciones, en contraste con el estilo de programación imperativa, que enfatiza los cambios de estado. La programación funcional tiene sus raices en el *cálculo lambda, un sistema formal desarrollado en los 1930s para investigar la definición de función, la aplicación de las funciones y la recursión. Muchos lenguajes de programación funcionales pueden ser vistos como elaboraciones del cálculo lambda.<br />
<br />
En la práctica, la diferencia entre una función matemática y la noción de una "función" utilizada en la programación imperativa es que las funciones imperativas pueden tener efectos secundarios, al cambiar el valor de calculos realizados previamente. Por esta razón carecen de transparencia referencial, es decir, la misma expresión lingüística puede resultar en valores diferentes en diferentes momentos dependiendo del estado del programa siendo ejecutado. Con código funcional, en contraste, el valor generado por una función depende exclusivamente de los argumentos alimentados a la función. Al eliminar los efectos secundarios se puede entender y predecir el comportamiento de un programa mucho más fácilmente, y esta es una de las principales motivaciones para utilizar la programación funcional.<br />
<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjRnH_euv8kM_JJedjybtjIKm6NJUDRiEB37ouDS0EO7nZoNvr3QV6nGH7k1gFu-dyhVK9Zo9kLgeImR7Jkgi51XCXyoBsLYBX0aqnC-lXIfaI3_ONuDcgrVjjmzUczyL3GTnveJSA0-Ug/s1600/BlueHaskellLogo.png" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="77" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjRnH_euv8kM_JJedjybtjIKm6NJUDRiEB37ouDS0EO7nZoNvr3QV6nGH7k1gFu-dyhVK9Zo9kLgeImR7Jkgi51XCXyoBsLYBX0aqnC-lXIfaI3_ONuDcgrVjjmzUczyL3GTnveJSA0-Ug/s200/BlueHaskellLogo.png" width="200" /></a>Los lenguajes de programación funcional, especialmente los que son puramente funcionales, han sido enfatizados en el ambiente académico principalmente y no tanto en el desarrollo de software comercial. Sin embargo, lenguajes de programación importantes tales como Scheme, Erlang, Objective Caml y Haskel, han sido utilizados en aplicaciones comerciales e industriales por muchas organizaciones. La programación funcional también es utilizada en la industria a través de lenguajes de dominio específico como R (estadística), Mathematica (matemáticas simbólicas), J y K (análisis financiero), F# en Microsoft.NET y XSLT (XML). Lenguajes de uso específico usados comúnmente como SQL y Lex/Yacc, utilizan algunos elementos de programación funcional, especialmente al procesar valores mutables. Las hojas de cálculo también pueden ser consideradas lenguajes de programación funcional.</div><br />
La programación funcional también puede ser desarrollada en lenguajes que no están diseñados específicamente para la programación funcional. En el caso de Perl, por ejemplo, que es un lenguaje de programación imperativo, existe un libro que describe como aplicar conceptos de programación funcional. JavaScript, uno de los lenguajes más ampliamente utilizados en la actualidad, también incorpora capacidades de programación funcional.<br />
<br />
<span style="color: red;">Para que nos sirve?</span><br />
<br />
El objetivo es conseguir lenguajes expresivos y matemáticamente elegantes, en los que no sea necesario bajar al nivel de la máquina para describir el proceso llevado a cabo por el programa, y evitar el concepto de estado del cómputo. La secuencia de computaciones llevadas a cabo por el programa se rige única y exclusivamente por la reescritura de definiciones más amplias a otras cada vez más concretas y definidas, usando lo que se denominan "definiciones dirigidas".<br />
<br />
<span style="color: red;">Ventajas de uso.</span><br />
<br />
Entre las ventajas que suelen citarse de usar un paradigma funcional en la programación de computadoras, están las siguientes:<br />
<div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhb-LYYtU77_uGWhyphenhyphen-kNR3W7tJw3iiF2VuKUy7QM8PhFoG3qsp-WnX-5iYeoFjgoaQah2rmtZ1Pvb4gFF8BorrekAXNt4YpIKpyFvwnthXtZOl74zMmj9jPD25EYmN_XkywoyrCjTZ5Mx0/s1600/erlang110.gif" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="174" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhb-LYYtU77_uGWhyphenhyphen-kNR3W7tJw3iiF2VuKUy7QM8PhFoG3qsp-WnX-5iYeoFjgoaQah2rmtZ1Pvb4gFF8BorrekAXNt4YpIKpyFvwnthXtZOl74zMmj9jPD25EYmN_XkywoyrCjTZ5Mx0/s200/erlang110.gif" width="200" /></a></div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;">• Ausencia de efectos colaterales</div><div style="border-bottom: medium none; border-left: medium none; border-right: medium none; border-top: medium none;"><br />
</div>• Proceso de depuración menos problemático<br />
<br />
• Pruebas de unidades más confiables<br />
<br />
• Mayor facilidad para la ejecución concurrente<br />
<br />
Los programas escritos en un lenguaje funcional están constituidos únicamente por definiciones de funciones, entendiendo éstas no como subprogramas clásicos de un lenguaje imperativo, sino como funciones puramente matemáticas, en las que se verifican ciertas propiedades como la transparencia referencial (el significado de una expresión depende únicamente del significado de sus subexpresiones), y por tanto, la carencia total de efectos laterales.<br />
<br />
Otras características propias de estos lenguajes son la no existencia de asignaciones de variables y la falta de construcciones estructuradas como la secuencia o la iteración (lo que obliga en la práctica a que todas las repeticiones de instrucciones se lleven a cabo por medio de funciones recursivas).<br />
<br />
Existen dos grandes categorías de lenguajes funcionales: los funcionales puros y los híbridos. La diferencia entre ambos estriba en que los lenguajes funcionales híbridos son menos dogmáticos que los puros, al admitir conceptos tomados de los lenguajes imperativos, como las secuencias de instrucciones o la asignación de variables. En contraste, los lenguajes funcionales puros tienen una mayor potencia expresiva, conservando a la vez su transparencia referencial, algo que no se cumple siempre con un lenguaje funcional híbrido.<br />
<span style="color: red;">Paradigma:</span><br />
<br />
El paradigma de programación funcional comparte, junto con el de programación lógica, características de programación declarativa. <br />
<br />
La característica fundamental del paradigma declarativo es que no existe la asignación ni el cambio de estado en un programa. Las variables son identificadores de valores que no cambian en toda la evaluación (como constantes definidas con un DEFINE de C). Sólo existen valores y expresiones matemáticas que devuelven nuevos valores a partir de los declarados.<br />
<br />
En los lenguajes imperativos, sin embargo, se realizan asignaciones que cambian el valor de una variable ya existente.<br />
<br />
<span style="color: red;">Consideremos el siguiente ejemplo:</span><br />
• 1. { int x = 1;<br />
• 2. x = x+1;<br />
• 3. int y = x+1;<br />
• 4. { int x = y;<br />
• 5. y = x+2; }<br />
• 6. y = x;}<br />
<br />
En este fragmento de programa se mezclan instrucciones imperativas con instrucciones declarativas. Por ejemplo, las instrucciones 1, 3 y 4 son declarativas, ya que están definiendo una variable con un valor asociado (están dando un nombre a un valor). Sin embargo, las sentencias 2, 5 y 6 son imperativas, ya que están modificando el valor de una variable mediante asignaciones de nuevos valores.<br />
<br />
<span style="color: red;">Los Lenguajes Funcionales son:</span><br />
<br />
<span style="color: #cc0000;">Lenguajes Puros:</span><br />
• Haskell<br />
• Miranda<br />
<br />
<span style="color: #cc0000;">Lenguajes híbridos:</span><br />
• Scala<br />
• Lisp<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEioSoSqRNrWGnqdzSX37gIIV2KDVfyFe7t6xbRinQ0xSK33F92-sq0tLwk92wvg2q5p-ITTGt92lhWmdwLh08a2BxXvHWgsfi3_tC9mbBQj1xQa2YepTj2cEqK3zrfWClC4DARcYtLgaw4/s1600/lisp-glossy.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="138" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEioSoSqRNrWGnqdzSX37gIIV2KDVfyFe7t6xbRinQ0xSK33F92-sq0tLwk92wvg2q5p-ITTGt92lhWmdwLh08a2BxXvHWgsfi3_tC9mbBQj1xQa2YepTj2cEqK3zrfWClC4DARcYtLgaw4/s200/lisp-glossy.jpg" width="200" /></a></div>• Scheme<br />
• Ocmal<br />
• SAP<br />
• Standard ML<br />
<span style="color: #cc0000;">Otros:</span><br />
• Erlang<br />
• R<br />
• Python<br />
• Perl<br />
• Ruby<br />
<br />
<strong>Notas: *</strong><br />
<br />
El cálculo lambda es un sistema formal diseñado para investigar la definición de función, la noción de aplicación de funciones y la recursión. Fue introducido por Alonzo Church y Stephen Kleene en la década de 1930<br />
<span style="color: red;">Ejemplo de un programa funcional:</span><br />
<br />
Es un programa sencillo hecho en el lenguaje Lisp donde realiza el factorial de un número.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEikYzY_AkLOuPCde6xqEnR716Cs8ykMpvAqDsfQZONFLw6Ff47717VVSBbOW6KRw2gVLxFj2e-epExtnLEEMmgSxInvb8hwqrY6PuCgPNpXG08lcweYFHWhLW8ica7SCpWmHHZcy7yqA-s/s1600/foto9.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="233" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEikYzY_AkLOuPCde6xqEnR716Cs8ykMpvAqDsfQZONFLw6Ff47717VVSBbOW6KRw2gVLxFj2e-epExtnLEEMmgSxInvb8hwqrY6PuCgPNpXG08lcweYFHWhLW8ica7SCpWmHHZcy7yqA-s/s400/foto9.png" width="400" /></a></div><br />
<br />
<br />
<span style="color: red;">Bibliografias:</span><br />
<br />
http://es.wikipedia.org/wiki/Programaci%C3%B3n_funcional<br />
<br />
http://www.dccia.ua.es/dccia/inf/asignaturas/LPP/2007-2008/tema-02.htmlObed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-2602721492347333542010-11-20T12:38:00.000-08:002010-11-20T12:38:23.041-08:00Heuristica de una Pagina webMateria: Programacion web<br />
<br />
<strong><span style="color: blue;">Diez Heurística de Usabilidad </span></strong><br />
<br />
<br />
por Jakob Nielsen<br />
<br />
Primero que nada que significa heuristica:<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh9VNoXd1BZlHBvfn5qY6WNfO8jdUmPml34N-v3whIzNXZJ4n74HB5Ntd_hosMUA0A7rM3Y8K51yIA53RYHAsn5JRbYcAsAVYTK3CnRLc6dOgUcj2KcTZrEQ2mlcJhfEt-fno5oxY-FKDc/s1600/fundteor-mapa-heuristica.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="150" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh9VNoXd1BZlHBvfn5qY6WNfO8jdUmPml34N-v3whIzNXZJ4n74HB5Ntd_hosMUA0A7rM3Y8K51yIA53RYHAsn5JRbYcAsAVYTK3CnRLc6dOgUcj2KcTZrEQ2mlcJhfEt-fno5oxY-FKDc/s200/fundteor-mapa-heuristica.jpg" width="200" /></a></div>Se denomina heurística a la capacidad de un sistema para realizar de forma inmediata innovaciones positivas para sus fines. La capacidad heurística es un rasgo característico de los humanos, desde cuyo punto de vista puede describirse como el arte y la ciencia del descubrimiento y de la invención o de resolver problemas mediante la creatividad y el pensamiento lateral o pensamiento divergente.<br />
Estos son los diez principios generales para el diseño de interfaz de usuario. Se les llama "heurística", ya que están más en la naturaleza de las reglas de oro de las directrices específicas de usabilidad. <br />
<br />
<span style="color: blue;">Visibilidad del estado del sistema </span><br />
<br />
El sistema siempre debe mantener informado al usuario acerca de lo que está pasando, a través de información adecuada en un plazo razonable. <br />
<br />
<span style="color: blue;">Coincidencia entre el sistema y el mundo real </span><br />
<br />
El sistema debe hablar el lenguaje de los usuarios, con palabras, frases y conceptos familiares al usuario, en lugar de términos orientados al sistema. Seguir las convenciones del mundo real, por lo que la información aparezca en un orden natural y lógico. <br />
<br />
<span style="color: blue;">De control de usuarios y la libertad </span><br />
<br />
Los usuarios a menudo eligen funciones del sistema por error y será necesario un marcado claramente como "salida de emergencia" para salir del estado no deseado sin tener que pasar a través de un amplio diálogo. Apoyo de deshacer y rehacer. <br />
<br />
<span style="color: blue;">Consistencia y estándares </span><br />
<br />
Los usuarios no deberían tener que preguntarse si diferentes palabras, situaciones o acciones significan lo mismo. Siga las convenciones de la plataforma. <br />
<br />
<span style="color: blue;">Prevención de errores </span><br />
<br />
Incluso mejor que buenos mensajes de error es un diseño cuidado que impide que un problema se produzca en el primer lugar. Cualquiera de eliminar las condiciones propensas a errores o detectar los usuarios actuales y con una opción de confirmación antes de comprometerse a la acción. <br />
<br />
<span style="color: blue;">Reconocimiento más que recordar </span><br />
<br />
Minimizar la carga del usuario, haciendo memoria de los objetos, acciones y opciones visibles. El usuario no debería tener que recordar la información de una parte del diálogo a otra. Instrucciones de uso del sistema deben ser visibles o fácilmente recuperables cuando sea apropiado. <br />
<br />
<span style="color: blue;">La flexibilidad y la eficiencia en el uso </span><br />
<br />
Aceleradores - no visto por el usuario novato - a menudo se puede acelerar la interacción para el usuario experto de tal manera que el sistema puede servir tanto a usuarios inexpertos y experimentados. Permitir a los usuarios sus acciones frecuentes. <br />
<br />
<span style="color: blue;">Estética y diseño minimalista </span><br />
<br />
Los diálogos no deben contener información que es irrelevante o raramente necesaria. Cada unidad adicional de información en un diálogo compite con las dependencias pertinentes de la información y disminuye su visibilidad relativa. <br />
<br />
<span style="color: blue;">Ayude a los usuarios reconocer, diagnosticar, y recuperarse de errores </span><br />
<br />
Los mensajes de error deben ser expresados en un lenguaje sencillo (sin códigos), indicar con precisión el problema y sugerir una solución constructiva. <br />
<br />
<span style="color: blue;">Ayuda y documentación </span><br />
<br />
A pesar de que es mejor si el sistema puede ser usado sin documentación, puede ser necesario para proporcionar ayuda y documentación. Toda esa información debe ser fácil de la búsqueda, centrado en la tarea del usuario, lista de medidas concretas que se llevarán a cabo, y no ser demasiado grande.<br />
<br />
<span style="color: blue;">25 señales indicativas de las páginas web de mala calidad:</span><br />
<span style="color: blue;"> </span>1.Contienen páginas pidiendo intercambio de enlaces.<br />
2.No tienen ningún texto de advertencia legal o sobre privacidad.<br />
3.La fecha del copyright está caducada a pesar de ser visible.<br />
4.Las páginas de error no dan un 404, sea cual sea la página que pidas.<br />
5.Les llegan enlaces masivos desde granjas de enlaces.<br />
6.Tienen enlaces muertos o que dan erorres 404 («la página no existe»).<br />
7.Alta proporción de enlaces respecto al texto.<br />
8.No hay información sobre cómo contactar, formulario, correos ni teléfonos.<br />
9.Alto grado de insatisfacción para el lector: los usuarios hacen clic en «volver» en su navegador para buscar la siguiente página en los resultados de búsqueda.<br />
10.Demasiado contenido duplicado.<br />
11.La información del WHOIS [propietario] del dominio es de alguien que en el pasado fue penalizado o baneado de los buscadores (y lo mismo puede decirse de su identificador de AdSense, de afiliado a algún tipo de red o de identificadores similares).<br />
12.Contiene enlaces a sitios de programas de afiliados que son timos bien conocidos [ej. cómo ganar en los casinos o ventas piramidales].<br />
13.El dominio fue penalizado por spam (envío de correo basura) en algún tipo de lista negra. [A veces también por venta de enlaces].<br />
14.Está muerto: el contenido del sitio no cambia nunca. [Esto me recordó las bitácoras legalmente muertas].<br />
15.URLs exageradamente largas, incluyendo cadenas de búsqueda, nombres de directorios o de archivos.<br />
16.Según los buscadores, no tiene enlaces entrantes o son muy escasos.<br />
17.Alto porcentaje de enlaces de «afiliados» frente a enlaces normales. <br />
18.No tiene enlaces hacia fuera o son muy escasos.<br />
19.Todos los enlaces entrantes son a la portada.<br />
20.Todos los enlaces de salida son a sitios cuestionables, de spam o de baja calidad.<br />
21.Incluye palabrotas o lenguaje «adulto», en un sitio que no es específicamente para adultos.<br />
22.Los textos tienen demasiadas faltas de ortografía.<br />
23.Contiene temáticas no relacionadas, por ejemplo: un sitio de reseñas de juguetes de repente intenta vender un seguro de vida o Viagra.<br />
24.Carente de interés en los servicios de marcadores sociales [del tipo del.icio.us, donde la gente guarda sus favoritos].<br />
25.Aparecen errores de MySQL o PHP en las páginas.<br />
<br />
Algunos de los detalles, como los relativos a las proporciones y tipos de enlaces sólo los detectarían los expertos en SEO, pero el resto son fáciles de entender.<span style="color: black;"><strong></strong></span><br />
<br />
<span style="color: black;"><strong>Notas: *</strong></span><br />
<br />
Jakob Nielsen ha sido llamado: -------------------><br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgT3vw76_KgMHfPqc9PmKw3V1ynyagkhMiGMM5s1ourCv_yJ2KYnZtwEuOT9m46LpPRJLxgyQegNqDetWhR66rawxhuqB2BWhYjJsBAY2ignoBpAAyIYG3YId96QgP3k2Ju8Lsp8RWVX_g/s1600/jakob_nielsen.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgT3vw76_KgMHfPqc9PmKw3V1ynyagkhMiGMM5s1ourCv_yJ2KYnZtwEuOT9m46LpPRJLxgyQegNqDetWhR66rawxhuqB2BWhYjJsBAY2ignoBpAAyIYG3YId96QgP3k2Ju8Lsp8RWVX_g/s200/jakob_nielsen.jpg" width="160" /></a></div>• "El rey de la usabilidad" (Revista de Internet) <br />
<br />
• " el gurú de la usabilidad página Web "(The New York Times) <br />
<br />
Jakob Nielsen, Ph.D., es un defensor del usuario y el director de la Nielsen Norman Group , que él co-fundó con el Dr. Donald A. Norman (ex vicepresidente de investigación de Apple Computer). Antes de comenzar NGN en 1998 fue un distinguido ingeniero de Sun Microsystems. <br />
<br />
El Dr. Nielsen fundó la "posibilidad de utilizar los descuentos de ingeniería" circulación de las mejoras rápidas y baratas de interfaces de usuario y la usabilidad ha inventado varios métodos, incluyendo la evaluación heurística . Tiene 79 patentes en Estados Unidos, principalmente en la manera de hacer que Internet sea más fácil de usar. <br />
<br />
Bibliografias:<br />
<a href="http://www.useit.com/papers/heuristic/heuristic_list.html">http://www.useit.com/papers/heuristic/heuristic_list.html</a><br />
<a href="http://www.microsiervos.com/archivo/internet/25-senales-malas-web.html">http://www.microsiervos.com/archivo/internet/25-senales-malas-web.html</a>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-23916929330144726742010-11-20T11:59:00.000-08:002010-11-21T11:11:15.357-08:00PageRankMateria: Programacion web<br />
<br />
<br />
<span style="color: blue;">¿Qué es el PageRank?</span><br />
<br />
<br />
PageRank (PR) es un valor numérico que representa la importancia que una página web tiene en Internet. Google se hace la idea de que cuando una página coloca un enlace (link) a otra, es de hecho un voto para esta última.<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiv9gq-R08RMhIIkvX2ijt-DssZEaVKub7x1IXnK7_txcsx53grwdpKrbzWOpV4TMJgsVCt74wEPPTjvn7K2vEyGcuyxJFoUNpym31Yon2UrL1yL8zWh50Q6W8E0aImWQ-AUDFIIQBFwAg/s1600/pagerank2.png" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="88" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiv9gq-R08RMhIIkvX2ijt-DssZEaVKub7x1IXnK7_txcsx53grwdpKrbzWOpV4TMJgsVCt74wEPPTjvn7K2vEyGcuyxJFoUNpym31Yon2UrL1yL8zWh50Q6W8E0aImWQ-AUDFIIQBFwAg/s200/pagerank2.png" width="200" /></a></div>Cuantos más votos tenga una página, será considerada más importante por Google. Además, la importancia de la página que emite su voto también determina el peso de este voto. De esta manera, Google calcula la importancia de una página gracias a todos los votos que reciba, teniendo en cuenta también la importancia de cada página que emite el voto.<br />
<br />
PageRank (desarrollado por los fundadores Larry Page y Sergey Brin) es la manera que tiene Google de decidir la importancia de una página. Es un dato valioso, porque es uno de los factores que determinan la posición que va a tener una página dentro de los resultados de la búsqueda. No es el único factor que Google utiliza para clasificar las páginas, pero sí es uno de los más importantes.<br />
<br />
Hay que tener en cuenta que no todos los links son tenidos en cuenta por Google. Por ejemplo, Google filtra y descarta los enlaces de páginas dedicadas exclusivamente a colocar links (llamadas 'link farms').<br />
Además, Google admite que una página no puede controlar los links que apuntan hacia ella, pero sí que puede controlar los enlaces que esta página coloca hacia otras páginas. Por ello, links hacia una página no pueden perjudicarla, pero sí que enlaces que una página coloque hacia sitios penalizados, pueden ser perjudiciales para su PageRank .Si un sitio web tiene PR0, generalmente es una web penalizada, y podría ser poco inteligente colocar un link hacia ella.<br />
<br />
<span style="color: blue;">Algoritmo PageRank</span><br />
<br />
El algoritmo inicial del PageRank lo podemos encontrar en el documento original donde sus creadores presentaron el prototipo de Google: “The Anatomy of a Large-Scale Hypertextual Web Search Engine":2<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhUWjgG9UVndjDzCSEs_9OuMbO72fSQSkD_IR01sGdvVsik3H2joSk4x30ysEFbcmkZRf_dlM28UI2-JVjXoASM7xNR3n_zun9-VU9-gPkLik3ciHy3vWszXdUloqZtBqVTqZopYkNi12k/s1600/nose28.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="65" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhUWjgG9UVndjDzCSEs_9OuMbO72fSQSkD_IR01sGdvVsik3H2joSk4x30ysEFbcmkZRf_dlM28UI2-JVjXoASM7xNR3n_zun9-VU9-gPkLik3ciHy3vWszXdUloqZtBqVTqZopYkNi12k/s320/nose28.png" width="320" /></a></div>Donde:<br />
<br />
• PR(A) es el PageRank de la página A.<br />
<br />
• d es un factor de amortiguación que tiene un valor entre 0 y 1.<br />
<br />
• PR(i) son los valores de PageRank que tienen cada una de las páginas i que enlazan a A.<br />
<br />
• C(i) es el número total de enlaces salientes de la página i (sean o no hacia A).<br />
<br />
Algunos expertos aseguran que el valor de la variable d suele ser 0,85.3 Representa la probabilidad de que un navegante continúe pulsando links al navegar por Internet en vez de escribir una url directamente en la barra de direcciones o pulsar uno de sus marcadores y es un valor establecido por Google. Por lo tanto, la probabilidad de que el usuario deje de pulsar links y navegue directamente a otra web aleatoria es 1-d.4 La introducción del factor de amortiguación en la fórmula resta algo de peso a todas las páginas de Internet y consigue que las páginas que no tienen enlaces a ninguna otra página no salgan especialmente beneficiadas. Si un usuario aterriza en una página sin enlaces, lo que hará será navegar a cualquier otra página aleatoriamente, lo que equivale a suponer que una página sin enlaces salientes tiene enlaces a todas las páginas de Internet.<br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhVkzr6bipK_Xd8ibJm3hNJurnxbPdFWOgNqYLuR5WXTZwLt1dpxwhNjeGliEL2RDfwmo8QpVDVZ3n9XaQ3RZPdPFcwP60xonWsHvVNq3u4FVrcNwEZMzh0OdiP2ogW-fVn7NRS0nFmt4A/s1600/nose27.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="193" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhVkzr6bipK_Xd8ibJm3hNJurnxbPdFWOgNqYLuR5WXTZwLt1dpxwhNjeGliEL2RDfwmo8QpVDVZ3n9XaQ3RZPdPFcwP60xonWsHvVNq3u4FVrcNwEZMzh0OdiP2ogW-fVn7NRS0nFmt4A/s320/nose27.png" width="320" /></a></div><br />
<span style="color: blue;">Antecedentes</span><br />
<br />
PageRank ha tomado su modelo del *Science Citation Index (SCI) elaborado por Eugene Garfield para el Instituto para la Información Científica (ISI) en los Estados Unidos durante la década del 50. El SCI pretende resolver la asignación objetiva de méritos científicos suponiendo que los investigadores cuyo factor de impacto (número de publicaciones y/o referencias bibliográficas en otros trabajos científicos) es más alto, colaboran en mayor medida con el desarrollo de su área de investigación. El índice de citación es un elemento determinante para seleccionar qué investigadores reciben becas y recursos de investigación.<br />
<br />
<span style="color: blue;">Como Conseguir un buen PageRank:</span><br />
<br />
<span style="color: red;">1. Optimización Web Interna:</span> lo primero de todo es tener un sitio web optimizado para facilitar la indexación y lectura a los buscadores, clave para que Google pueda medir la cantidad de votos que tu sitio recibe. Se debe tener una buena estructura interna de enlaces asegurándose de que todas las páginas son accesibles.<br />
<br />
<span style="color: red;">2. Sitio con contenido de calidad:</span> cuanto mayor contenido de calidad haya en tu sitio web, mejor valoración obtendrás. Google valora de forma positiva que ese contenido de calidad vaya aumentando y esté actualizado. Además se valora la densidad de las palabras clave en el contenido de tu sitio.<br />
<br />
<span style="color: red;">3. Número de enlaces externos:</span> en general podemos afirmar que cuantos más enlaces externos tengamos hacia nuestro sitio, mayor probabilidad de aumentar nuestro PageRank tendremos, siempre teniendo en cuenta la calidad de los enlaces.<br />
<br />
<span style="color: red;">4. Enlaces con alto PR:</span> si los sitios que nos enlazan tienen un PR alto, mejoraremos nuestro PR. Además cuanto menos enlaces salientes tenga este sitio, mayor importancia tendrá su voto.<br />
<br />
<span style="color: red;">5. Enlaces Naturales:</span> Google valora de forma muy positiva que los enlaces sean naturales, es decir, que por ejemplo hablen bien de nuestro sitio en otras páginas web, ya que la forma que tenemos de hablar bien en la red es enlazando o refiriendo un determinado sitio.<br />
<br />
<span style="color: red;">6. Enlaces solicitados de forma manual:</span> cuando se ejecutan campañas de Linkbuilding siempre se debe hacer de forma manual y eligiendo los mejores directorios, blogs o sitios para solicitar el enlace, ya que Google detecta y penaliza los enlaces obtenidos de forma automatizada, además que estos enlaces tienen mucho menos valor, ya que es más fácil su inclusión y generalmente suelen ser sitios denominados Granjas de Enlaces.<br />
<br />
<span style="color: red;">7. Conseguir enlaces de forma progresiva:</span> Google desconfía de los sitios web que obtienen un gran número de enlaces en poco tiempo, por ello la obtención de enlaces se debe hacer de forma progresiva, debe ser un trabajo diario y constante en el tiempo.<br />
<br />
Aunque el PageRank es un indicador de Google, también afecta de forma positiva en los resultados en el resto de buscadores como Bing o Yahoo, ya que muchos de los factores que tiene en cuenta en su cálculo, también son relevantes en los algoritmos del resto de buscadores.<br />
<br />
<strong>NOTAS: *</strong><br />
Un índice de citación, índice de citas o análisis de citas de una revista científica es aquel que mantiene un seguimiento sobre qué artículos son citados en otros artículos. El más usado y mejor conocido es el Web of Science publicado por el Instituto para la Información Científica Institute for Scientific Information (ISI).<br />
<span style="color: blue;">Bibliografias:</span><br />
<a href="http://es.wikipedia.org/wiki/PageRank">http://es.wikipedia.org/wiki/PageRank</a><br />
<a href="http://www.mipagerank.com/">http://www.mipagerank.com/</a><br />
<a href="http://www.go2jump.com/blog/como-aumentar-el-pagerank-de-tu-sitio/">http://www.go2jump.com/blog/como-aumentar-el-pagerank-de-tu-sitio/</a>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-62578919510703418102010-11-19T16:38:00.000-08:002010-11-19T16:38:19.358-08:00MySQLMateria: Programacion web.<br />
<br />
<br />
<strong><span style="color: blue;">¿Qué es MySQL?</span></strong><br />
<br />
MySQL es un sistema de gestión de bases de datos relacional, licenciado bajo la GPL de la GNU. Su diseño multihilo le permite soportar una gran carga de forma muy eficiente. MySQL fue creada por la empresa sueca MySQL AB, que mantiene el copyright del código fuente del servidor SQL, así como también de la marca.<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiBzI68ZRv8QEHp3HfX22TEukAitxV-BXQhZ-f8_MuFFhgop8nPRS0N5RfSiMgyptqCn6JvIOKCntSmWyFb4BjHI8DIC1PH7jhb8nSLVv7_ofDE3Hdj1DXfNmlzQCZ_OUmFIufSbLqELQY/s1600/20100615-mysql2.jpg" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="131" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiBzI68ZRv8QEHp3HfX22TEukAitxV-BXQhZ-f8_MuFFhgop8nPRS0N5RfSiMgyptqCn6JvIOKCntSmWyFb4BjHI8DIC1PH7jhb8nSLVv7_ofDE3Hdj1DXfNmlzQCZ_OUmFIufSbLqELQY/s200/20100615-mysql2.jpg" width="200" /></a></div>Aunque MySQL es software libre, MySQL AB distribuye una versión comercial de MySQL, que no se diferencia de la versión libre más que en el soporte técnico que se ofrece, y la posibilidad de integrar este gestor en un software propietario, ya que de no ser así, se vulneraría la licencia GPL.<br />
<br />
Este gestor de bases de datos es, probablemente, el gestor más usado en el mundo del software libre, debido a su gran rapidez y facilidad de uso. Esta gran aceptación es debida, en parte, a que existen infinidad de librerías y otras herramientas que permiten su uso a través de gran cantidad de lenguajes de programación, además de su fácil instalación y configuración.<br />
<br />
<span style="color: blue;"><strong>Historia de MySQL</strong></span><br />
<br />
MySQL surgió como un intento de conectar el gestor mSQL a las tablas propias de MySQL AB, usando sus propias rutinas a bajo nivel. Tras unas primeras pruebas, vieron que mSQL no era lo bastante flexible para lo que necesitaban, por lo que tuvieron que desarrollar nuevas funciones. Esto resultó en una interfaz SQL a su base de datos, con una interfaz totalmente compatible a mSQL.<br />
<br />
Se comenta en el manual [MySQL_Manual] que no se sabe con certeza de donde proviene su nombre. Por un lado dicen que sus librerías han llevado el prefijo 'my' durante los diez últimos años. Por otro lado, la hija de uno de los desarrolladores se llama My. No saben cuál de estas dos causas (aunque bien podrían tratarse de la misma), han dado lugar al nombre de este conocido gestor de bases de datos.<br />
<br />
La versión estable de este gestor a días de hoy es la 3.23.49. Se puede encontrar más información sobre este gestor en el manual [MySQL_Manual].<br />
<br />
<span style="color: blue;"><strong>Características de MySQL</strong></span><br />
<br />
Las principales características de este gestor de bases de datos son las siguientes:<br />
<br />
1. Aprovecha la potencia de sistemas multiprocesador, gracias a su implementación multihilo.<br />
<br />
2. Soporta gran cantidad de tipos de datos para las columnas.<br />
<br />
3. Dispone de *API's en gran cantidad de lenguajes (C, C++, Java, PHP, etc).<br />
<br />
4. Gran portabilidad entre sistemas.<br />
<br />
5. Soporta hasta 32 índices por tabla.<br />
<br />
6. Gestión de usuarios y passwords, manteniendo un muy buen nivel de seguridad en los datos.<br />
<br />
<strong><span style="color: blue;">¿Qué es lo que le falta?</span></strong><br />
<br />
MySQL surgió cómo una necesidad de un grupo de personas sobre un gestor de bases de datos rápido, por lo que sus desarrolladores fueron implementando únicamente lo que precisaban, intentando hacerlo funcionar de forma óptima. Es por ello que, aunque MySQL se incluye en el grupo de sistemas de bases de datos relacionales, carece de algunas de sus principales características:<br />
<br />
<span style="color: red;">1. Subconsultas:</span> tal vez ésta sea una de las características que más se echan en falta, aunque gran parte de las veces que se necesitan, es posible reescribirlas de manera que no sean necesarias.<br />
<br />
<span style="color: red;">2. SELECT INTO TABLE</span>: Esta característica propia de Oracle, todavía no está implementada.<br />
<br />
<span style="color: red;">3. *Triggers y Procedures:</span> Se tiene pensado incluir el uso de procedures almacenados en la base de datos, pero no el de triggers, ya que los triggers reducen de forma significativa el rendimiento de la base de datos, incluso en aquellas consultas que no los activan.<br />
<br />
<span style="color: red;">4. Transacciones</span><span style="color: red;">:</span> a partir de las últimas versiones ya hay soporte para transacciones, aunque no por defecto (se ha de activar un modo especial).<br />
<br />
<span style="color: red;">5. Integridad referencial:</span> aunque sí que admite la declaración de claves ajenas en la creación tablas, internamente no las trata de forma diferente al resto de campos.<br />
<br />
Los desarrolladores comentan en la documentación que todas estas carencias no les resultaban un problema, ya que era lo que ellos necesitaban. De hecho, MySQL fue diseñada con estas características, debido a que lo que buscaban era un gestor de bases de datos con una gran rapidez de respuesta. Pero ha sido con la distribución de MySQL por Internet, cuando más y más gente les están pidiendo estas funcionalidades, por lo que serán incluidas en futuras versiones del gestor.<br />
<br />
<strong>Notas: *</strong><br />
<br />
API es la abreviatura de Aplication Programming Interface. Un API no es más que una serie de servicios o funciones que el Sistema Operativo ofrece al programador, como por ejemplo, imprimir un caracter en pantalla, leer el teclado, escribir en un fichero de disco, etc.<br />
<br />
Un trigger (o disparador) en una Base de datos , es un procedimiento que se ejecuta cuando se cumple una condición establecida al realizar una operación de inserción (INSERT), actualización (UPDATE) o borrado (DELETE).<br />
<br />
<span style="color: blue;">Bibliografias:</span><br />
<br />
<a href="http://danielpecos.com/docs/mysql_postgres/x57.html">http://danielpecos.com/docs/mysql_postgres/x57.html</a><br />
<br />
<a href="http://www.uaem.mx/posgrado/mcruz/cursos/miic/MySQL.pdf">http://www.uaem.mx/posgrado/mcruz/cursos/miic/MySQL.pdf</a><br />
<br />
<a href="http://www.alegsa.com.ar/Dic/mysql.php">http://www.alegsa.com.ar/Dic/mysql.php</a><br />
<br />
<a href="http://es.wikipedia.org/wiki/MySQL">http://es.wikipedia.org/wiki/MySQL</a>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-32841903078960481922010-11-19T16:12:00.000-08:002010-11-19T16:12:48.904-08:00Google apps y Facebook appsMateria: Progrmacion web<br />
<div style="text-align: center;"><span style="color: blue;"><strong>Google apps</strong></span></div><strong><span style="color: blue;"></span></strong><span style="color: blue;"><strong> </strong></span><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjWcUI1pUj-TxcEjp65KPegYKArTWi0770sa7feDAo5l_Nq_T6LFlO9hQ6sEB7uC3qCEzniBtCd14J44MUOAY2lABZKBpAd6SUS5tHWkIlN2aUJJ_9XZjhIcwVIfYeot7fbTfjq9AMW6xg/s1600/google+apps.png" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="188" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjWcUI1pUj-TxcEjp65KPegYKArTWi0770sa7feDAo5l_Nq_T6LFlO9hQ6sEB7uC3qCEzniBtCd14J44MUOAY2lABZKBpAd6SUS5tHWkIlN2aUJJ_9XZjhIcwVIfYeot7fbTfjq9AMW6xg/s200/google+apps.png" width="200" /></a>Google Apps es un servicio de Google para uso de dominios de diversos productos ofrecidos por la red Google. Este servicio representa muchas aplicaciones para Internet con funcionamiento similar a los tradicionales programas para escritorio, incluido Gmail, Google Agenda, Talk, Docs y Sites. Esto permite también elegir una garantía de seguridad y de conformidad (proporcionada por Postini) para la mensajería electrónica existente. Para Educación, el programa es gratuito.<br />
<br />
Google Apps ofrece herramientas eficaces para la manipulación, gestión y personalización de utilidades para dominios o nombres de Internet. Es decir, Google Apps te permite gestionar el correo electrónico de tu dominio (a través de Gmail), mensajería instantánea entre miembros de tu organización o red (Google Talk), calendario en línea (Google Calendar), edición de Documentos también en línea (Google Docs) y creación de sitios web profesionales (Google Sites).<br />
<br />
<br />
<span style="color: blue;">Algunas ventajas de Google Apps:</span><br />
<br />
* Capacidad de hasta 7 GB para correo electrónico, y sigue creciendo (similar a Gmail).<br />
<br />
* Interfaz web personalizable.<br />
<br />
* POP3 para descargar e-mail hacia Microsoft Outlook, Apple Mail, Thunderbirdo cualquier gestor de correo electrónico.<br />
<br />
* A partirde este año, totalmente en español.<br />
<br />
* Cuenta catch all, o cuenta que recibe todo el correo perdido enviado a su dominio<br />
<br />
* Acceso IMAP para sincronización del correo desde diferentes dispositivos móviles.<br />
<br />
* Que es una herramienta gratuita (pero no es libre) y se puede acceder a varios servicios bajo una misma cuenta.<br />
<br />
*Además puede resultar muy beneficioso para equipos de trabajo que se encuentran en locaciones diferentes y distantes; ya que permite compartir archivos y la colaboración en tiempo real.<br />
<br />
*Y la ventaja que supone trabajar sin tener que trasladar nuestros archivos y datos, ya que están en línea (siempre y cuando haya conectividad).<br />
<br />
<span style="color: blue;">Como desventajas se puede señalar:</span><br />
<br />
* Que aún las funcionalidades no son tan equiparables como las de las suites de escritorio (Ejemplo: Aun no hay editor de dispositivas).<br />
<br />
*Que nuestros datos están siempre a disposición de terceras personas, y esto (aunque no lo admitan) es un peligro para la privacidad.<br />
<br />
*La dependencia constante que las aplicaciones web generan respecto del proveedor del servicio.<br />
<br />
La seguridad de los servicios está respaldada por Postini, que segun lo que investigue se refiere a una compañía que adquirió Google la cual ofrece seguridad en las comunicaciones de las empresas, desde el correo hasta la mensajería instantánea.<br />
<br />
Postini ofrece una solución que no necesita de hardware, sino que todo funciona a través de sus servidores, de forma parecida a como funciona Google Apps. Permite controlar correo electrónico, mensajería instantánea y otros servicios basados en web, protegiendo contra spam y virus y ofreciendo cifrado y protección de los datos.<br />
<br />
<div style="text-align: center;"><span style="color: blue;"><strong>Facebook</strong></span></div><br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh0MuJi4QsCTOtg6KzWECaKboiDuRyBEAtnDlOQ2pRr60e89AUQH0lbrDQgQ9wtZAewrg2SHEUCqQ_ivg_xDvs2E7GddJjuAd-Kdq8CsEqp6WJbaneSvh2fS1rfGWsFl44HM2PvmEp8Qkk/s1600/facebook-apps.jpg" imageanchor="1" style="clear: right; cssfloat: right; float: right; margin-bottom: 1em; margin-left: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh0MuJi4QsCTOtg6KzWECaKboiDuRyBEAtnDlOQ2pRr60e89AUQH0lbrDQgQ9wtZAewrg2SHEUCqQ_ivg_xDvs2E7GddJjuAd-Kdq8CsEqp6WJbaneSvh2fS1rfGWsFl44HM2PvmEp8Qkk/s200/facebook-apps.jpg" width="165" /></a></div>Facebook es un sitio web gratuito de redes sociales creado por Mark Zuckerberg y fundado por Eduardo Saverin, Chris Hughes, Dustin Moskovitz y Mark Zuckerberg. Originalmente era un sitio para estudiantes de la Universidad Harvard, pero actualmente está abierto a cualquier persona que tenga una cuenta de correo electrónico. Los usuarios pueden participar en una o más redes sociales, en relación con su situación académica, su lugar de trabajo o región geográfica.<br />
<br />
<span style="color: blue;"><strong>Historia de la empresa</strong></span><br />
<br />
El creador de Facebook es Mark Zuckerberg, estudiante de la Universidad Harvard. La compañía tiene sus oficinas centrales en Palo Alto, California.<br />
<br />
La idea de crear una comunidad basada en la Web en que la gente compartiera sus gustos y sentimientos no es nueva. Ya David Bohnett, creador de Geocities, la había incubado a fines de los años 1980. Geocities tuvo éxito en los 1990, en 1998 fue el tercer sitio más visto en la Web, pero no logró consolidarse después de que fuera adquirido por Yahoo!.<br />
<br />
Facebook compite por abrirse espacio entre empresas de éxito como Google y MySpace, por lo que se enfrenta a grandes desafíos para lograr crecer y desarrollarse. Una de las estrategias de Zuckerberg ha sido abrir la plataforma Facebook a otros desarrolladores.<br />
<br />
La fortaleza de la red social Facebook radica en los 500 millones de usuarios que ha creado, basada en conexiones de gente real. Entre los años 2007 y 2008 se puso en marcha Facebook en español, extendiéndose a los países de Latinoamérica. Casi cualquier persona con conocimientos informáticos básicos puede tener acceso a todo este mundo de comunidades virtuales.<br />
<br />
<span style="color: blue;">Caracteristicas importantes para realizar un facebook app:</span><br />
*Nesesitas un servidor fijo, esto implica tener una IP fija.<br />
<br />
*En caso de que manejes base de datos, tambien tendra que ser por tu cuenta.<br />
<br />
*Tienes que registrarte en Facebook, solo para obtener la ID de la aplicacion<br />
<br />
*Existe seguridad, pero no es tanta comparada con las aplicaciones de google.<br />
<br />
*Se manejan lenguajes comop pyhton, javascript, y php<br />
<br />
<span style="color: blue;">Bibliografias:</span><br />
<br />
<a href="http://www.trucosfacebook.com/">http://www.trucosfacebook.com/</a><br />
<br />
<a href="http://www.paraisogeek.com/que-es-google-apps/">http://www.paraisogeek.com/que-es-google-apps/</a><br />
<br />
<a href="http://es.wikipedia.org/wiki/Facebook">http://es.wikipedia.org/wiki/Facebook</a><br />
<br />
<div style="text-align: left;"></div>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1tag:blogger.com,1999:blog-6147241035718533881.post-75852250435349891322010-11-19T16:02:00.000-08:002010-11-19T16:02:24.730-08:00Servlets y JSP´s<span style="color: #073763;">Materia: Programacion web</span><br />
<br />
<span style="color: blue;"><strong>¿Qué son los Servlets Java?</strong></span><br />
<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjJ0vYIQAFu-kdwV30xZjELbGbBMlGxKU94-vaAaZBuJ94agPutlkii1jgBHAiPbRdQAKEddvlUGoSRKakTsnr8xUSiyd75H0Nj_wK7P8TWlQt3DHd4pSulyzgxiUwRo1ZAApnYn8C8CKU/s1600/java_logo.png" imageanchor="1" style="clear: left; cssfloat: left; float: left; margin-bottom: 1em; margin-right: 1em;"><img border="0" height="200" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjJ0vYIQAFu-kdwV30xZjELbGbBMlGxKU94-vaAaZBuJ94agPutlkii1jgBHAiPbRdQAKEddvlUGoSRKakTsnr8xUSiyd75H0Nj_wK7P8TWlQt3DHd4pSulyzgxiUwRo1ZAApnYn8C8CKU/s200/java_logo.png" width="107" /></a></div>Los Servlets son las respuesta de la tecnología Java a la programación CGI. Son programas que se ejecutan en un servidor Web y construyen páginas Web. Construir páginas Web al vuelo es útil (y comunmente usado) por un número de razones:<br />
<br />
La página Web está basada en datos envíados por el usuario. Por ejemplo, las páginas de resultados de los motores de búsqueda se generan de esta forma, y los programas que procesan pedidos desde sites de comercio electrónico también.<br />
<br />
Los datos cambian frecuentemente. Por ejemplo, un informe sobre el tiempo o páginas de cabeceras de noticias podrían construir la página dinámicamente, quizás devolviendo una página previamente construida y luego actualizandola.<br />
<br />
Las páginas Web que usan información desde bases de datos corporativas u otras fuentes. Por ejemplo, usaríamos esto para hacer una página Web en una tienda on-line que liste los precios actuales y el número de artículos en stock. <br />
<br />
<span style="color: blue;"><strong>¿Cuáles son las Ventajas de los Servlets sobre el CGI "Tradicional"?</strong></span><br />
<br />
Los Servlets Java son más eficientes, fáciles de usar, más poderosos, más portables, y más baratos que el CGI tradicional y otras muchas tecnologías del tipo CGI. (y lo que es más importante, los desarrolladores de servlets cobran más que los programadores de Perl :-).<br />
<br />
Eficiencia. Con CGI tradicional, se arranca un nuevo proceso para cada solicitud HTTP. Si el programa CGI hace una operación relativamente rápida, la sobrecarga del proceso de arrancada puede dominar el tiempo de ejecución. Con los Servlets, la máquina Virtual Java permanece arrancada, y cada petición es manejada por un thread Java de peso ligero, no un pesado proceso del sistema operativo. De forma similar, en CGI tradicional, si hay N peticiones simultáneas para el mismo programa CGI, el código de este problema se cargará N veces en memoria. Sin embargo, con los Servlets, hay N threads pero sólo una copia de la clase Servlet. Los Servelt también tienen más alternativas que los programas normales CGI para optimizaciones como los cachés de cálculos prévios, mantener abiertas las conexiones de bases de datos, etc.<br />
<br />
Conveniencia. Hey, tu ya sabes Java. ¿Por qué aprender Perl? Junto con la conveniencia de poder utilizar un lenguaje familiar, los Servlets tienen una gran infraestructura para análisis automático y decodificación de datos de formularios HTML, leer y seleccionar cabeceras HTTP, manejar cookies, seguimiento de sesiones, y muchas otras utilidades. <br />
<br />
Potencia. Los Servlets Java nos permiten fácilmente hacer muchas cosas que son difíciles o imposibles con CGI normal. Por algo, los servlets pueden hablar directamente con el servidor Web. Esto simplifica las operaciones que se necesitan para buscar imágenes y otros datos almacenados en situaciones estándards. Los Servlets también pueden compartir los datos entre ellos, haciendo las cosas útiles como almacenes de conexiones a bases de datos fáciles de implementar. También pueden mantener información de solicitud en solicitud, simplicando cosas como seguimiento de sesión y el caché de cálculos anteriores. <br />
<br />
Portable. Los Servlets están escritos en Java y siguen un API bien estándarizado. Consecuentemente, los servlets escritos, digamos en el servidor I-Planet Enterprise, se pueden ejecutar sin modificarse en Apache, Microsoft IIS, o WebStar. Los Servlets están soportados directamente o mediante plug-in en la mayoría de los servidores Web.<br />
<br />
Barato. Hay un número de servidores Web gratuitos o muy baratos que son buenos para el uso "personal" o el uso en sites Web de bajo nivel. Sin embargo, con la excepción de Apache, que es gratuito, la mayoría de los servidores Web comerciales son relativamente caros. Una vez que tengamos un servidor Web, no importa el coste del servidor, añadirle soporte para Servlets (si no viene preconfigurado para soportarlos) es gratuito o muy barato.<br />
<br />
<span style="color: blue;"><strong>¿Qué es JSP?</strong></span><br />
<br />
Java Server Pages (JSP) es una tecnología que nos permite mezclar HTML estático con HTML generado dinámicamente. Muchas páginas Web que están construidas con programas CGI son casi estáticas, con la parte dinámica limitada a muy pocas localizaciones. Pero muchas variaciones CGI, incluyendo los servlets, hacen que generemos la página completa mediante nuestro programa, incluso aunque la mayoría de ella sea siempre lo mismo. JSP nos permite crear dos partes de forma separada. Aquí tenemos un ejemplo:<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhPPbhX6MLEsHd1e-WeA0cCrE_aEg3z27_F-gzOwxdPuKK96eos7_f2Fvtx9Wir3weIbQgnnLc7HFBKy-le9PeaHZyb4kYpIoxD6WGTU70O6Xy6k0tL1mKPw_fmXSbL_SLkmKLMfHqt82M/s1600/nose17.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="197" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhPPbhX6MLEsHd1e-WeA0cCrE_aEg3z27_F-gzOwxdPuKK96eos7_f2Fvtx9Wir3weIbQgnnLc7HFBKy-le9PeaHZyb4kYpIoxD6WGTU70O6Xy6k0tL1mKPw_fmXSbL_SLkmKLMfHqt82M/s400/nose17.png" width="400" /></a></div><br />
<span style="color: blue;"><strong>¿Cuáles son las Ventajas de JSP?</strong></span><br />
<br />
Contra Active Server Pages (ASP). ASP es una tecnología similar de Microsoft. Las ventajas de JSP estan duplicadas. Primero, la parte dinámica está escrita en Java, no en Visual Basic, otro lenguaje específico de MS, por eso es mucho más poderosa y fácil de usar. Segundo, es portable a otros sistemas operativos y servidores Web.<br />
<br />
Contra los Servlets. JSP no nos da nada que no pudierámos en principio hacer con un servlet. Pero es mucho más conveniente escribir (y modificar!) HTML normal que tener que hacer un billón de sentencias println que generen HTML. Además, separando el formato del contenido podemos poner diferentes personas en diferentes tareas: nuestros expertos en diseño de páginas Web pueden construir el HTML, dejando espacio para que nuestros programadores de servlets inserten el contenido dinámico.<br />
<br />
Contra Server-Side Includes (SSI). SSI es una tecnología ámpliamente soportada que incluye piezas definidas externamente dentro de una página Web estática. JSP es mejor porque nos permite usar servlets en vez de un programa separado para generar las partes dinámicas. Además, SSI, realmente está diseñado para inclusiones sencillas, no para programas "reales" que usen formularios de datos, hagan conexiones a bases de datos, etc.<br />
<br />
Contra JavaScript. JavaScript puede generar HTML dinámicamente en el cliente. Este una capacidad útil, pero sólo maneja situaciones donde la información dinámica está basada en el entorno del cliente. Con la excepción de las cookies, el HTTP y el envió de formularios no están disponibles con JavaScript. Y, como se ejecuta en el cliente, JavaScript no puede acceder a los recursos en el lado del servidor, como bases de datos, catálogos, información de precios, etc.<br />
<span style="color: blue;">Bibliografias:</span><br />
<br />
http://www.programacion.com/articulos/servlets_y_jsp_82Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com2tag:blogger.com,1999:blog-6147241035718533881.post-78395469000587248662010-11-19T03:25:00.000-08:002010-11-19T03:26:14.424-08:00Python<span style="color: blue;">Materia: Programacion web.</span><br />
Python es un lenguaje de programación de alto nivel cuya filosofía hace hincapié en una sintaxis muy limpia y que favorezca un código legible.<br />
<br />
Se trata de un lenguaje de programación *multiparadigma ya que soporta orientación a objetos, programación imperativa y, en menor medida, programación funcional. Es un lenguaje interpretado, usa tipado dinámico, es fuertemente tipado y es multiplataforma.<br />
<br />
Python fue creado a finales de los ochenta por Guido van Rossum en el National Research Institute for Mathematics and Computer Science (CWI), en los Países Bajos, como un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e interactuar con el sistema operativo Amoeba.<br />
<br />
El nombre del lenguaje proviene de la afición de su creador original, Guido van Rossum, por los humoristas británicos Monty Python.<br />
<br />
Van Rossum es el principal autor de Python, y su continuo rol central en decidir la dirección de Python es reconocido, refiriéndose a él como Benevolente Dictador Vitalicio (en inglés: Benevolent Dictator for Life, BDFL).<br />
<br />
Los usuarios de Python se refieren a menudo a la Filosofía Python que es bastante análoga a la filosofía de Unix. El código que sigue los principios de Python de legibilidad y transparencia se dice que es "pythonico". Contrariamente, el código opaco u ofuscado es bautizado como "no pythonico" ("unpythonic" en inglés). Estos principios fueron famosamente descritos por el desarrollador de Python Tim Peters en El Zen de Python<br />
<br />
<br />
<span style="color: red;">El Zen de Python:</span><br />
<span style="color: red;">• Bello es mejor que feo.</span><br />
<span style="color: red;">• Explícito es mejor que implícito.</span><br />
<span style="color: red;">• Simple es mejor que complejo.</span><br />
<span style="color: red;">• Complejo es mejor que complicado.</span><br />
<span style="color: red;">• Plano es mejor que anidado.</span><br />
<span style="color: red;">• Ralo es mejor que denso.</span><br />
<span style="color: red;">• La legibilidad cuenta.</span><br />
<span style="color: red;">• Los casos especiales no son tan especiales como para quebrantar las reglas.</span><br />
<span style="color: red;">• Aunque lo práctico gana a la pureza.</span><br />
<span style="color: red;">• Los errores nunca deberían dejarse pasar silenciosamente.</span><br />
<span style="color: red;">• A menos que hayan sido silenciados explícitamente.</span><br />
<span style="color: red;">• Frente a la ambigüedad, rechaza la tentación de adivinar.</span><br />
<span style="color: red;">• Debería haber una -y preferiblemente sólo una- manera obvia de hacerlo.</span><br />
<span style="color: red;">• Aunque esa manera puede no ser obvia al principio a menos que usted sea holandés.16</span><br />
<span style="color: red;">• Ahora es mejor que nunca.</span><br />
<span style="color: red;">• Aunque nunca es a menudo mejor que ya mismo.</span><br />
<span style="color: red;">• Si la implementación es difícil de explicar, es una mala idea.</span><br />
<span style="color: red;">• Si la implementación es fácil de explicar, puede que sea una buena idea.</span><br />
<span style="color: red;">• Los espacios de nombres (namespaces) son una gran idea ¡Hagamos más de esas cosas!</span><br />
<br />
<strong><span style="color: blue;">Tipos de datos</span></strong><br />
<br />
<span style="color: blue;">Los tipos de datos se pueden resumir en esta tabla:</span><br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh4eKQT0h3zhqj_-Jf36GSSXgKez2tGcKj90F-TVQQd_mXzKjR9dq0zCmjxn73szhqnCqikIzM_7DhlzUxSt0Qn23qSXmP3tJ5stuqviXi4wEVcaOoQlttZ2tPSuVG0fAhXOtoqYjZ7Flk/s1600/nose16.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="400" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh4eKQT0h3zhqj_-Jf36GSSXgKez2tGcKj90F-TVQQd_mXzKjR9dq0zCmjxn73szhqnCqikIzM_7DhlzUxSt0Qn23qSXmP3tJ5stuqviXi4wEVcaOoQlttZ2tPSuVG0fAhXOtoqYjZ7Flk/s400/nose16.png" width="375" /></a></div><span style="color: blue;">Listas y Tuplas.</span><br />
<br />
• Para declarar una lista se usan los corchetes [], en cambio, para declarar una tupla se usan los paréntesis (). En ambas los elementos se separan por comas, y en el caso de las tuplas es necesario que tengan como mínimo una coma.<br />
<br />
• Tanto las listas como las tuplas pueden contener elementos de diferentes tipos. No obstante las listas suelen usarse para elementos del mismo tipo en cantidad variable mientras que las tuplas se reservan para elementos distintos en cantidad fija.<br />
<br />
• Para acceder a los elementos de una lista o tupla se utiliza un índice entero (empezando por "0", no por "1"). Se pueden utilizar índices negativos para acceder elementos a partir del final.<br />
<br />
• Las listas se caracterizan por ser mutables, es decir, se puede cambiar su contenido en tiempo de ejecución, mientras que las tuplas son inmutables ya que no es posible modificar el contenido una vez creada.<br />
<br />
<span style="color: blue;">Conjuntos</span><br />
<br />
• Los conjuntos se construyen mediante set(items) donde items es cualquier objeto iterable, como listas o tuplas. Los conjuntos no mantienen el orden ni contienen elementos duplicados.<br />
<br />
• Se suelen utilizar para eliminar duplicados de una secuencia, o para operaciones matemáticas como intersección, unión, diferencia y diferencia simétrica.<br />
<br />
<span style="color: blue;">Listas por comprensión.</span><br />
<span style="color: blue;"><br />
</span><br />
Una lista por comprensión (en inglés: list comprehension) es una expresión compacta para definir listas. Al igual que lambda, aparece en lenguajes funcionales. <br />
<br />
<span style="color: blue;">Funciones.</span><br />
<br />
• Las funciones se definen con la palabra clave def, seguida del nombre de la función y sus parámetros. Otra forma de escribir funciones, aunque menos utilizada, es con la palabra clave lambda (que aparece en lenguajes funcionales como Lisp).<br />
<br />
• El valor devuelto en las funciones con def será el dado con la instrucción return.<br />
<br />
<span style="color: blue;">Clases</span><br />
<br />
• Las clases se definen con la palabra clave class, seguida del nombre de la clase y, si hereda de otra clase, el nombre de esta.<br />
<br />
• En Python 2.x es recomendable que una clase herede de "object", en Python 3.x esto ya no hará falta.<br />
<br />
• En una clase un "método" equivale a una "función", y una "propiedad" equivale a una "variable".25<br />
<br />
• "__init__" es un método especial que se ejecuta al instanciar la clase, se usa generalmente para inicializar propiedades y ejecutar métodos necesarios. Al igual que todos los métodos en Python, debe tener al menos un parámetro, generalmente se utiliza self. El resto de parámetros serán los que se indiquen al instanciar la clase.<br />
<br />
• Las propiedades que se desee que sean accesibles desde fuera de la clase se deben declarar usando self. delante del nombre.<br />
<br />
• De forma parecida a otros lenguajes donde existen restricciones de acceso a una propiedad o método, public y private, en Python, para que una propiedad o método sea privado se utilizan dos barras bajas __ antes del nombre de la variable, y después de self.<br />
<strong>Notas: *</strong><br />
Un lenguaje de programación multiparadigma es el cual soporta más de un paradigma de programación. Según lo describe Bjarne Stroustrup, permiten crear “programas usando más de un estilo de programación”.<br />
<br />
<span style="color: blue;">Ejemplo:</span><br />
<span style="color: black;">Programa que te encuentra los numeros primos segun el limite le des:</span><br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjSJCwJlqD2XLsAz8uiENgwMe4XgjWXk-MQnjGEPXsdKM49897RnHdY1sEEsHLpHCkVdn-43XAOAdwpcurD4cbGux24ExBUccjVdoZXWkPKoA9ZXBFGGPuLPTdajnjWz0PTaMJrZLOXrzQ/s1600/nose17.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="183" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjSJCwJlqD2XLsAz8uiENgwMe4XgjWXk-MQnjGEPXsdKM49897RnHdY1sEEsHLpHCkVdn-43XAOAdwpcurD4cbGux24ExBUccjVdoZXWkPKoA9ZXBFGGPuLPTdajnjWz0PTaMJrZLOXrzQ/s320/nose17.png" width="320" /></a></div><br />
<br />
Terminal.- primero entramos en documentos, despues revisamos si el documento o programa se encuentra ahi y al final lo compilamos, entonces te pide un numero se lo das y esto aparece tal como se muestra en la imagen:<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg9FpPk3FPNo0MuT5Pxp4kqgnyEcbLF7jwux5lTJ46jie5eEVxmouZ0EmNyPZE8qEdRzUEySdIh2t6R3xjgu19rGhDqIEmGhR_JO6QDV7dnMn36fVpHEepYwnbBRrFiSPAKm4sIezkDVxM/s1600/nose18.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" ox="true" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg9FpPk3FPNo0MuT5Pxp4kqgnyEcbLF7jwux5lTJ46jie5eEVxmouZ0EmNyPZE8qEdRzUEySdIh2t6R3xjgu19rGhDqIEmGhR_JO6QDV7dnMn36fVpHEepYwnbBRrFiSPAKm4sIezkDVxM/s1600/nose18.png" /></a></div><div class="separator" style="clear: both; text-align: center;"><br />
</div><br />
<br />
<br />
<br />
<br />
<br />
<span style="color: blue;">Bibliografias:</span> <br />
<a href="http://es.wikipedia.org/wiki/Python">http://es.wikipedia.org/wiki/Python</a>Obed Guevarahttp://www.blogger.com/profile/04970162450835967179noreply@blogger.com1