Programación

Amanda Laza & Karol García

2 Bachillerato de ciencias

1
Índice
Índice ........................................................................................................................................2
Programación de aplicaciones sencillas. ........................................................................3
Conceptos de clases y objetos...........................................................................................7
Diagrama de flujo:................................................................................................... 10
Lectura y escritura de datos. ........................................................................................... 12
Tipos de operadores: ................................................................................................. 13
Estructuras de almacenamiento..................................................................................... 16
Entornos de programación. ............................................................................................. 17
Tipos de entornos de programación y ejemplos ................................................ 18
Por la plataforma en la que se ejecutan:............................................................... 18
Entornos para la creación de aplicaciones para móviles ......................................... 19
¿Qué son los entornos de desarrollo de apps? ...................................................... 20
Características esenciales de un entorno de desarrollo ....................................... 22
Elaboración de programas ............................................................................................... 22
1. Análisis.......................................................................................................................... 23
2. Diseño............................................................................................................................ 23
3. Codificación o construcción..................................................................................... 23
4. Explotación o implantación ..................................................................................... 24
5. Mantenimiento............................................................................................................ 24
Depuración de programas. .............................................................................................. 25
¿Por Qué Es Importante la Depuración? ................................................................... 25
Etapas Críticas en la Depuración ................................................................................ 25
Elementos del Depurador: Breakpoints y Ejecución Paso a Paso...................... 26
Fundamentos del software adaptativo. ........................................................................ 27
Características del Software Adaptativo................................................................... 28
Bibliografía ........................................................................................................................... 30

2
Programación de aplicaciones sencillas.
La programación de aplicaciones es el proceso de escribir este código para que
la computadora haga lo que tú quieres. En el caso de un juego, esto podría
incluir:

• Crear los personajes: Decidir cómo se verán y cómo se moverán.

• Diseñar los niveles: Crear los escenarios donde se desarrollará el juego.
• Programar las reglas: Establecer cómo se ganan o se pierden los puntos,
qué pasa cuando se presiona un botón, etc.

¿Qué aplicaciones sencillas puedo crear?

• Juegos simples: Desde adivinar números hasta laberintos.

• Calculadoras: Para hacer operaciones matemáticas.
• Dibujos animados: Con personajes que se mueven y hablan.
• Historias interactivas: Donde el lector puede elegir cómo continúa la
historia.

Existen muchos lenguajes de programación y herramientas diseñadas

específicamente para que niños y jóvenes aprendan a programar de forma
divertida. Algunos ejemplos son:

• Scratch: Una plataforma visual donde puedes crear juegos y

animaciones arrastrando y soltando bloques.
• Blockly: Similar a Scratch, pero con un enfoque más en la lógica de
programación.
• Python: Un lenguaje de programación muy popular y versátil.

Las principales funciones de un programador son:

Crear nuevas aplicaciones.

Modificar apps existentes.

Publicar las aplicaciones en los markets.

Actualizar apps para adaptarlas a las nuevas versiones de los sistemas

operativos.

Desarrollar nuevas ideas para impulsar los negocios para los que trabaje.

3
Para poder hacer esto es necesario conocer una serie de lenguajes de
programación o códigos, con los que poder crear desde cero las aplicaciones
móviles o bien modificarlas partiendo de una tecnología pre desarrollada.

Cómo se programa una aplicación paso a paso:

Crear una aplicación móvil es cualquier cosa menos fácil, sobre todo si lo haces
a lo loco y no tienes en cuenta una serie de aspectos. Vas a necesitar tiempo,
conocimientos específicos y, generalmente, hacer una inversión económica.

Sin embargo, si te planteas la creación de una app de manera profesional y

sigues un proceso en su desarrollo puedes conseguir una aplicación de éxito
en menos de lo que esperabas. Te contamos cómo hacerlo.

1. Fija unos objetivos.

Tanto si quieres crear una aplicación desde cero, como para complementar la
web de un negocio existente o como parte de una estrategia de marketing, es
fundamental que estudies tu idea pormenorizadamente.

Analiza en primer lugar qué quieres hacer, después piensa cómo vas a
desarrollarlo y por último los medios con los que cuentas. Una buena idea es
investigar el mercado existente y ver si hay algún hueco en el que puedas
innovar. Si no sabes cómo hacerlo te contamos cómo detectar nichos de
mercado en el siguiente artículo.

2. Dirígete a tu público.

Cuando ya tengas clara la idea que vas a usar para crear tu app es importante
que analices el mercado y veas si hay sitio para ella. Además, este es el
momento de hacer los cambios necesarios para adaptar tus objetivos. Céntrate
en conocer mejor el perfil al que te diriges, estudia su comportamiento, los
hábitos que tiene, sus gustos, etc.

3. Define tu modelo de negocio.

Ya conoces el sector en el que vas a moverte y las necesidades de tu público,

pues bien, ahora tienes que redefinir tu idea para adaptarla al máximo a toda la
información obtenida anteriormente. De este modo podrás garantizar que vas a
lanzar una app que realmente va a conseguir cubrir tus objetivos.

4. Decide el tipo de app que encaja mejor con tu negocio.

4
Hay aplicaciones móviles que se basan en distintas tecnologías para su
funcionamiento, además de diferentes opciones a la hora de programarlas.
Estudia cada variable para tener claro cuál se adapta mejor a lo que necesita el
negocio y a los recursos con los que cuentas.

Puedes elegir entre:

• Apps nativas
• Aplicaciones web progresivas
• Apps híbridas

5. Diseña cómo será tu app.

Para poder definir las partes de las que estará formada la aplicación móvil de tu
negocio, cómo disponer los distintos elementos, elegir una paleta de color o
dónde colocar las distintas llamadas a la acción es recomendable contar con un
diseñador web que pueda crear un “boceto” de la app.

Aunque es cierto que si tienes experiencia en el sector, esto es algo que

puedes hacer tu mismo. Eso sí, recuerda que esta parte es imprescindible ya
que será sobre lo que se hará la programación de la app.

6. Crea tu aplicación móvil.

Debes saber que en este punto es donde realmente cobra importancia el papel
de un experto en programación de apps, ya que aquí es donde sucede la
magia. Tienes varias opciones:

1. Desarrolla la app tú mismo

Si ya tienes conocimientos en programación y Objetive-C, Swift, Java y Kotlin

no te suenan a chino puedes ponerte manos a la obra y crear tu mismo la app
que quieras sin ningún límite.

2. Contrata un programador

Es posible que no tengas la formación necesaria para hacer una app aún,
aunque ojo, que si estás leyendo esto es probable que la tengas pronto. En
este caso debes saber que los programadores de apps están muy demandados
y que si te especializas en esto no te faltará el trabajo.

Para un negocio esta es la opción más costosa, pero también con la que
conseguir un nivel de personalización mayor. Ya que un programador de apps

5
puede crear una de la nada ajustándose a todos los requisitos particulares del
proyecto.

3. Usa un creador de apps

Aunque esta opción no siempre implica no tener programación, lo cierto es que

hoy en día hay soluciones muy completas con las que puedes crear una app
sin tener ni idea de código. Este es el caso de Scoreapps, donde ofrecemos un
App Builder con el que es posible hacer una aplicación totalmente
personalizada gracias a más de 100 funciones diferentes de manera muy
sencilla.

7. Comprueba que todo funciona a la perfección.

Mucha gente se salta este paso cuando hacen la programación de una app y la
verdad es que es imprescindible. Antes de publicar nada es fundamental
revisar todas y cada una de las funciones, así como llevar a cabo una serie de
pruebas. Para ello puedes usar beta testers que te indiquen los fallos existentes
para poder hacer los cambios necesarios en la programación de la app.

8. Lanza tu app al mundo.

Los programadores habitualmente tienen cuentas de desarrollador en los

mercados de la App Store y Google Play para poder publicar las aplicaciones
una vez estén listas. Este proceso puede ser complicado, por lo que te
recomendamos dejarlo en manos de expertos.

Fases de creación de un programa

1. Análisis

Fase de especificación de cuáles son las necesidades que debe satisfacer

nuestra aplicación y el planteamiento para cubrirlas.

2. Diseño

Una vez identificadas las necesidades, en la fase de diseño se deben detallar

todos y cada uno de los elementos que usaremos: recursos físicos
(característica del ordenador, periféricos, etc) y lógicos (sistema operativo,
compilador, herramientas de utilidad, etc).

3. Codificación

6
Como se ha visto en una sección anterior, la tarea aquí es la de traducir a un
lenguaje de programación la solución obtenida en la fase de diseño.

4. Explotación

Para explotar nuestra aplicación o programa se deberá implantar en el sistema

informático que estemos usando, esto es, instalándola para posteriormente
ejecutarla y comprobar los resultados que nos ofrece.

5. Mantenimiento

Esta última etapa está fundamentalmente relacionada con la idea de mejorar el

programa desarrollado, corrigiendo errores y proporcionando ideas que lo
hagan más eficiente. Así, en ocasiones puede dar lugar al reinicio del ciclo de
vida.

Conceptos de clases y objetos.

Tipos de programación:

Programación imperativa

Describe cómo se deben ejecutar una serie de instrucciones en un orden

secuencial para lograr un objetivo específico. En este enfoque, el programa se
estructura como una serie de comandos o instrucciones que modifican el
estado del programa a medida que se ejecutan. Las instrucciones imperativas
indican a la computadora qué pasos debe seguir para lograr un resultado
deseado.

Programación orientada a objetos (POO)

Es un paradigma de programación, que se basa en la idea de organizar y

estructurar el código, de manera que los conceptos del mundo real se reflejen
de manera natural en él. En la POO, los programas se diseñan alrededor de
"objetos", que son unidades independientes que encapsulan datos y funciones
relacionadas.

Programación funcional

Se fundamenta en el concepto de tratar la computación como la evaluación de

funciones matemáticas, evitando el cambio de estado y la mutabilidad de los
7
datos. Por ello, en la programación funcional, los programas se construyen
mediante la composición de funciones, lo que permite un enfoque más
declarativo y menos centrado en la manipulación directa de datos.

Programación lógica

Se sustenta en el uso de la lógica formal y la inferencia para resolver

problemas. En este enfoque, los programas se construyen mediante la
especificación de hechos y reglas, y luego se utiliza un motor de inferencia
para deducir conclusiones a partir de estas reglas y hechos. La programación
lógica es especialmente adecuada para resolver problemas que implican
razonamiento y manipulación simbólica.

Programación declarativa

Este enfoque de programación se centra en describir qué se debe lograr en un

programa, en lugar de cómo lograrlo. Esto significa que, en vez de dar una
serie de instrucciones detalladas paso a paso, en la programación declarativa
se proporciona una especificación de lo que se desea obtener, permitiendo que
el sistema o el lenguaje de programación se encargue de determinar cómo se
llevará a cabo la ejecución.

Programación orientada a eventos

Se ocupa del manejo de eventos en un programa. En este modelo, un evento

es cualquier acción o suceso que ocurre en el sistema, como una acción del
usuario, un cambio de estado o una interacción con el entorno. Es utilizado
usualmente en aplicaciones que necesitan responder a interacciones del
usuario en tiempo real, como interfaces gráficas de usuario, videojuegos y
sistemas interactivos.

Algoritmos diagramas de flujo:

-Diseño del algoritmo

Es la etapa más creativa, en la que diseñas el algoritmo . Se puede hacer mediante

un diagrama de flujo (gráfico) o mediante pseudocódigo (o ambos).

Los pasos que debes seguir para conseguir el resultado buscado son:

1. Inicio.

8
 2. Coge una sartén.
3. Pon la sartén sobre la placa.
4. Añade aceite a la sartén.
5. Enciende el fuego.
6. Espera a que se caliente el aceite.
7. Parte un huevo.
8. Agrega el contenido al aceite.
9. Espera a que esté frito.
10. Retira la sartén del fuego.
11. Apaga el fuego.
12. Retira el huevo del aceite.
13. Ponlo en un plato.
14. Fin.

Esa es la receta, los pasos. Pero, esto es un ejemplo muy simple, no hay
complicaciones. Para casos más complejos, un diagrama de flujo y el
pseudocódigo aclararía mucho. Este paso es vital, de ello dependerá si vas a poder
implementar el programa escribiendo código fuente o no. Aquí es donde
flaquean los que simplemente aprenden leyendo libros de programación o
modificando códigos.

9
Diagrama de flujo:

Fig 1. Partes del diagrama de flujo.

Es la forma gráfica de representar un algoritmo. Se usan varios símbolos que definen

los procesos en la computación. Los símbolos se relacionan con los otros
siguiendo un orden mediante unas líneas de flujo. El primer bloque será siempre
el inicio y lo último será el final u objetivo. Aunque puedes usar los símbolos
que quieras, lo mejor es respetar los reglamentados por la ANSI.

• Inicio y final: se representan con una elipse.

• Entrada y salida de datos: se representa por un romboide. La entrada es
la lectura de datos y la salida la impresión. En cambio, las fuentes de los
datos o los destinos pueden ser diversos. Algunos autores suelen usar un
símbolo de impresión…
• Decisión: es un rombo que indica comparación de valores.
• Proceso: es un recuadro, indicará asignación de un valor en la memoria
y/o la ejecución de una operación aritmética/lógica.
• Conector: es un círculo con algún símbolo en su interior que indica la
forma de conexión que se usa.

10
 • Líneas de flujo: son flechas que indican la dirección del flujo que sigue la
ejecución del programa. Entrelazan la secuencia de pasos u operaciones
que se deben hacer desde el inicio hasta el final.
Eso en cuanto a los símbolos más básicos. Pero también debes respetar unas
reglas:

• Todo diagrama debe tener inicio y fin.

• Los símbolos de decisión deben tener más de una línea de salida.
• El dibujo o diagrama se lee de arriba a abajo y de izquierda a derecha,
por tanto, debes posicionar los bloques en consecuencia.
• No se especifican la declaración de variables.
• No se suelen usar líneas de flujo que no sean horizontales o verticales, y
se debe evitar el cruce de líneas usando conectores. Esto es algo más
estético y para evitar confusiones. A veces, cuando diseñas el diagrama
lo tienes todo claro, pero cuando vuelves a él pasado un tiempo, puede
que el cruce de líneas pueda llevar a errores o confusiones…
• No debería haber líneas de flujo sin conectar. No es lógico.
• Puedes usar un símbolo específico para comentarios o anotarlos al
margen.
• Si el diagrama es muy grande y ocupa varias páginas, debes numerarlas
para saber el orden. Lo contrario sería un completo desastre.

Estas son algunas de las reglas, pero ahora vamos a ver un ejemplo del diagrama
para nuestra receta (aunque no sea del todo adaptable al diagrama de flujo, pero
para que te hagas una idea):

11
 Fig 2. diagrama de flujo para hacer huevo frito. Ejemplo.

Lectura y escritura de datos.

Tipos de datos:

Existen dos clases de tipos de datos: simples (sin estructura) y compuestos

(estructurados). Los tipos de datos simples solamente almacenan un valor a la
vez, mientras que los tipos de datos compuestos o estructurados pueden
contener muchos valores al mismo tiempo.

Los tipos de datos simples son los siguientes:

- Numéricos (ENTERO, REAL)

- Lógicos (BOOLEANO)
- Alfanuméricos (CHAR, CADENA o STRING)

Los tipos de datos compuestos que son aquellos cuyos valores pueden
englobar a varios datos simultáneamente. Los tipos de datos compuestos son:
el tipo conjunto (que permite expresar el caso del conjunto de letras de una
palabra), el tipo array1 (que recoge los ejemplos de vectores, crucigramas o
una baraja), el tipo registro (con cuyos valores se pueden representar fichas de

12
alumnos), y el tipo archivo (en uno de cuyos valores se puede almacenar una
carta).

Tipos de operadores:
Los tipos de operadores más comunes en programación se dividen en varias
categorías según su función. Aquí tienes algunos de los tipos de operadores
más comunes:

Operadores aritméticos:

Se utilizan para realizar operaciones matemáticas en programación.

+ (suma): Se utiliza para sumar dos valores.

- (resta): Se utiliza para restar el valor de la derecha del valor de la izquierda.

* (multiplicación): Se utiliza para multiplicar dos valores.

/ (división): Se utiliza para dividir el valor de la izquierda por el valor de la

derecha.

% (módulo): Devuelve el resto de la división del valor de la izquierda por el

valor de la derecha.

// (división entera): Devuelve el cociente entero de la división del valor de la

izquierda por el valor de la derecha.

** (exponenciación): Se utiliza para elevar el valor de la izquierda a la potencia

del valor de la derecha.

fig 3. Ejemplo operador aritmético «suma +»

Operadores de comparación o relacionales:

Se utilizan para comparar dos valores y devolver un resultado booleano que

indica la relación entre esos valores.

== (igual a): Devuelve True si los dos valores son iguales; de lo contrario,
devuelve False.

13
!= (diferente de): Devuelve True si los dos valores no son iguales; de lo
contrario, devuelve False.

< (menor que): Devuelve True si el valor de la izquierda es menor que el valor
de la derecha; de lo contrario, devuelve False.

> (mayor que): Devuelve True si el valor de la izquierda es mayor que el valor
de la derecha; de lo contrario, devuelve False.

<= (menor o igual que): Devuelve True si el valor de la izquierda es menor o

igual al valor de la derecha; de lo contrario, devuelve False.

>= (mayor o igual que): Devuelve True si el valor de la izquierda es mayor o

igual al valor de la derecha; de lo contrario, devuelve False.

fig 4. Operador de comparación «mayor que», devolviendo como resultado

«True»

Operadores lógicos:

Se utilizan para combinar expresiones booleanas y realizar operaciones lógicas

en programación.

and (y lógico): Devuelve True si ambas expresiones son verdaderas; de lo

contrario, devuelve False.

or (o lógico): Devuelve True si al menos una de las expresiones es verdadera;

devuelve False si ambas son falsas.

not (negación lógica): Devuelve True si la expresión es falsa y False si la

expresión es verdadera.

fig 5. Ejemplo de operador lógico «and».

Operadores de asignación:

Se utilizan para asignar valores a variables en programación.

14
= (asignación): Asigna el valor de la derecha a la variable de la izquierda.

+= (suma y asigna): Suma el valor de la derecha al valor actual de la variable

de la izquierda y luego asigna el resultado a la variable de la izquierda.

-= (resta y asigna): Resta el valor de la derecha al valor actual de la variable de

la izquierda y luego asigna el resultado a la variable de la izquierda.

*= (multiplica y asigna): Multiplica el valor de la derecha por el valor actual de

la variable de la izquierda y luego asigna el resultado a la variable de la
izquierda.

/= (divide y asigna): Divide el valor actual de la variable de la izquierda por el

valor de la derecha y luego asigna el resultado a la variable de la izquierda.

%= (módulo y asigna): Calcula el módulo del valor actual de la variable de la

izquierda por el valor de la derecha y luego asigna el resultado a la variable de
la izquierda.

//= (división entera y asigna): Realiza una división entera del valor actual de la
variable de la izquierda por el valor de la derecha y luego asigna el resultado a
la variable de la izquierda.

fig 6. Ejemplo de operador de asignación «+= (suma y asigna)»

Operadores de pertenencia e identidad:

Son utilizados en Python para verificar la relación entre variables y objetos.

in (pertenencia): Devuelve True si un valor está presente en una secuencia

(como una lista, tupla o cadena); de lo contrario, devuelve False.

not in (no pertenencia): Devuelve True si un valor no está presente en una

secuencia; de lo contrario, devuelve False.

is (identidad): Devuelve True si dos variables se refieren al mismo objeto en la

memoria; de lo contrario, devuelve False.

is not (no identidad): Devuelve True si dos variables no se refieren al mismo

objeto en la memoria; de lo contrario, devuelve False.

15
fig 7. Ejemplo operador de pertenencia «in»

Estructuras de almacenamiento.

Fig 8. Diagrama de almacenamiento.

Secuencia: Son series de acciones desarrolladas en un orden específico, ya que

se realiza una acción tras otra hasta que todas se hayan llevado a cabo.

Repetición o ciclo: Así como los condicionales, los ciclos también realizan
preguntas. La diferencia es que hacen la misma pregunta una y otra vez hasta
que cierta tarea haya sido elaborada.

Condicional: Este tipo de estructura, en lugar de seguir un orden específico de

eventos, realiza una preguntar para determinar el camino a seguir.

16
Entornos de programación.
Un entorno de programación es un programa o conjunto de programas que engloban
todas las tareas necesarias para el desarrollo de un programa o aplicación. Estas
tareas son básicamente las siguientes:

• Edición del programa.

• Compilación y enlazado.
• Ejecución.
• Depuración.

Algunos entornos de programación incluyen la creación de documentación para

facilitar el mantenimiento del software. Además, integran herramientas, utilidades,
aplicaciones, ejemplos y tutoriales orientados a simplificar y optimizar el desarrollo.

Editores:

El desarrollo de un programa comienza con un editor de texto, que permite escribir y

guardar instrucciones en archivos sin formato. Aunque cualquier editor sirve, es
común usar uno especializado en programación, que ofrece herramientas para la
corrección de errores, resalta palabras clave con colores y facilita el trabajo del
programador.

Procesadores del lenguaje: traductores, compiladores e intérpretes

Una vez editado nuestro programa, es necesario que este sea procesado y
transformado en órdenes que puedan ser ejecutadas por el ordenador. Estas órdenes
deben estar en código máquina, el único lenguaje que la máquina entiende. Los
procesadores de lenguaje cumplen esta función, y dentro de ellos destacan los
traductores, compiladores e intérpretes.

Compilador: convierte un programa escrito en un lenguaje de programación en su

equivalente en lenguaje máquina, produciendo un programa ejecutable sin requerir el
compilador durante la ejecución. Ejemplos de lenguajes que requieren compilación
son Pascal y C. Cuando el proceso es entre lenguaje ensamblador y código máquina,
el compilador se llama ensamblador.

Intérprete: convierte y ejecuta el programa línea por línea simultáneamente, sin

generar un archivo ejecutable, por lo que debe estar presente durante la ejecución.
Ejemplos de lenguajes interpretados son LISP y BASIC.

Traductores: son procesadores de lenguaje que convierten programas de un lenguaje

a otro sin generar código máquina. Por ejemplo, existen traductores de Pascal a C.

17
Algunos lenguajes combinan ambas estrategias. Java, por ejemplo, usa traductores
para generar un código intermedio que luego es ejecutado mediante un intérprete
llamado máquina virtual Java.

Enlazadores

Por simplificación, se suele decir que los compiladores y ensambladores generan

código máquina ejecutable por el ordenador. Sin embargo, esto no es completamente
cierto, ya que tras la compilación, se necesita un enlazador (linker) para realizar el
proceso de enlazado. Durante la escritura de un programa, se utilizan subprogramas o
bibliotecas de funciones, y el programa puede estar dividido en varios archivos. El
enlazador se encarga de unir todos los módulos y bibliotecas estáticas en un único
archivo ejecutable.

El enlazado suele ser una fase posterior a la compilación, realizada de forma

automática. Los archivos involucrados en el proceso tienen nombres genéricos según
su fase: los archivos con las instrucciones del programador se llaman ficheros fuente
(source files), el resultado de la compilación son los ficheros objeto (object files) y,
finalmente, el archivo ejecutable (executable file) es el que puede ser entendido y
ejecutado por el ordenador. En lenguajes interpretados, el fichero fuente se ejecuta
directamente mediante el intérprete, sin necesidad de compilación y enlazado.

Depuradores

Una vez que hemos editado y compilado un programa, lo siguiente es ejecutarlo. Sin
embargo, es común que, aunque el programa no tenga errores de sintaxis, no haga lo
que esperamos. Ahí es donde entran los depuradores. Estos programas nos permiten
ejecutar el código paso a paso, y además nos dan la posibilidad de ver el valor de las
variables y los datos, lo que hace mucho más fácil encontrar errores que de otro modo
serían difíciles de detectar.

Los entornos de programación son herramientas esenciales para los programadores,

pero no todos funcionan igual ni están pensados para lo mismo. Dependiendo de sus
características, pueden clasificarse de varias maneras.

Tipos de entornos de programación y ejemplos

Por la plataforma en la que se ejecutan:

Primero, tenemos los entornos de programación que se instalan en tu
ordenador, lo que significa que todo funciona de forma local. Algunos
ejemplos populares de estos son NetBeans, Eclipse, Visual Studio o IntelliJ
IDEA. Son ideales si trabajas de forma habitual en tu equipo y necesitas
muchas funcionalidades.

18
Por otro lado, están los entornos de programación en la nube, que te permiten
trabajar directamente desde tu navegador, sin importar en qué dispositivo
estés. Esto es perfecto si te gusta la flexibilidad de trabajar desde cualquier
lugar. AWS Cloud9, Codeanywhere y CodePen son algunos ejemplos de este
tipo, y tienen la ventaja de ser accesibles en cualquier momento y desde
cualquier lugar con conexión a Internet.

Por el propósito que tienen:

Los entornos de desarrollo también se pueden clasificar según el tipo de proyecto en
el que los vayamos a usar. Algunos ejemplos son:

1. Desarrollo móvil:
• Android Studio: Es el entorno de desarrollo más común para crear
aplicaciones para Android.
• Xcode: Este se utiliza para desarrollar aplicaciones para dispositivos
Apple, como el iPhone o el iPad.
2. Desarrollo de videojuegos:
• Unreal Engine y Unity: Son dos de los entornos más utilizados para
hacer videojuegos. Ofrecen herramientas muy potentes para crear
mundos virtuales, gráficos y todo lo que necesita un juego.
3. Desarrollo para IoT (Internet de las Cosas):
Aunque no hay un único entorno para esto, hay varias herramientas que
ayudan a crear aplicaciones para dispositivos que forman parte del Internet de
las Cosas, como sensores, cámaras inteligentes, entre otros.
4. Gestión de bases de datos:
Algunos entornos están especializados en gestionar bases de datos, facilitando
tanto el diseño como la manipulación de los datos. Estos entornos permiten
configurar y gestionar de forma eficiente la información.
Cada uno de estos entornos está pensado para facilitar el trabajo en diferentes
tipos de proyectos, por lo que elegir el adecuado depende del tipo de
aplicación que quieras desarrollar.

Entornos para la creación de aplicaciones

para móviles
La creación de aplicaciones móviles es un proceso que requiere herramientas
específicas y una buena planificación. Las apps móviles son fundamentales para
ofrecer servicios, mejorar la comunicación entre empresas y clientes, y aumentar la
eficiencia de procesos en distintos ámbitos. Para desarrollar una aplicación, es
esencial utilizar los entornos de desarrollo adecuados, también conocidos como IDEs

19
(Integrated Development Environments ), que facilitan la programación al integrar
herramientas y recursos en una sola plataforma.

Tipos de aplicaciones móviles

Existen tres tipos principales de aplicaciones móviles, cada una con características
específicas:

1. Aplicaciones nativas:
a. Se desarrollan exclusivamente para un sistema operativo, como Android
o iOS.
b. Están escritas en lenguajes como Java o Kotlin para Android, y Swift u
Objective-C para iOS.
c. Su principal ventaja es el alto rendimiento, ya que están diseñadas
específicamente para aprovechar al máximo las características del
dispositivo, como la cámara, los sensores o el almacenamiento.
d. Sin embargo, requieren mayor inversión de tiempo y recursos, ya que el
desarrollo para cada plataforma es independiente.
2. Aplicaciones híbridas:
a. Mezclan características de las apps nativas y web.
b. Utilizan tecnologías web como HTML, CSS y JavaScript, que se
envuelven en una capa nativa para poder distribuirse a través de tiendas
de aplicaciones.
c. Son más económicas y rápidas de desarrollar porque el mismo código
puede utilizarse en múltiples plataformas. Sin embargo, pueden tener
un rendimiento inferior al de las apps nativas.
3. Aplicaciones web:
a. Son sitios web optimizados para dispositivos móviles y no requieren
instalación.
b. Pueden ejecutarse en cualquier dispositivo con un navegador web, lo
que las hace muy accesibles.
c. Aunque son económicas de crear, no tienen acceso completo a las
funciones del dispositivo y suelen ofrecer un rendimiento inferior.

Elegir el tipo de aplicación depende de factores como el presupuesto, el público

objetivo y las características requeridas.

¿Qué son los entornos de desarrollo de apps?

Los entornos de desarrollo de aplicaciones móviles son herramientas que integran
todo lo necesario para diseñar, programar, probar y depurar software. Estos entornos
incluyen:

20
 • Editores de código: Permiten escribir el código fuente del programa.
• Compiladores o intérpretes: Transforman el código en un formato que el
dispositivo pueda entender.
• Depuradores: Ayudan a identificar y corregir errores en el código.
• Simuladores o emuladores: Permiten probar la aplicación en un entorno virtual
antes de ejecutarla en un dispositivo real.

Además, muchos IDEs ofrecen funciones avanzadas como autocompletado de código,

resaltado de sintaxis y análisis en tiempo real, que facilitan la escritura de código
limpio y eficiente.

Entornos destacados para el desarrollo de aplicaciones

móviles
Existen diversos entornos de desarrollo especializados, cada uno con características
particulares que se adaptan a diferentes tipos de proyectos.

1. Android Studio:
a. Es el entorno oficial para el desarrollo de aplicaciones Android.
b. Incluye herramientas de diseño visual, un emulador avanzado, soporte
para lenguajes como Java y Kotlin, y una integración directa con
servicios de Google.
c. Facilita la creación de aplicaciones optimizadas para dispositivos
Android de diferentes tamaños y versiones.
2. Xcode:
a. Es el entorno de desarrollo para aplicaciones iOS, utilizado para
dispositivos como iPhones y iPads.
b. Ofrece un editor de código intuitivo, herramientas de diseño visual y un
simulador de iOS para pruebas.
c. Es compatible con el lenguaje Swift, conocido por su simplicidad y
eficiencia.
3. Flutter:
a. Este framework, desarrollado por Google, permite crear aplicaciones
multiplataforma con un solo código base.
b. Usa el lenguaje Dart y proporciona widgets personalizables para diseñar
interfaces atractivas y funcionales.
c. Es ideal para proyectos que necesitan ser lanzados en Android e iOS
simultáneamente.
4. React Native:
a. Desarrollado por Facebook, es otra opción para crear aplicaciones
híbridas.
b. Utiliza JavaScript y ofrece un rendimiento cercano al de las aplicaciones
nativas.

21
 c. Su comunidad activa proporciona múltiples recursos y bibliotecas que
facilitan el desarrollo.

Características esenciales de un entorno de desarrollo

Un buen entorno de desarrollo debe incluir:

• Interfaz de usuario amigable: Para que los desarrolladores puedan trabajar

cómodamente.
• Compatibilidad con múltiples plataformas: Especialmente útil para proyectos
que necesitan llegar a un público amplio.
• Soporte para depuración avanzada: Como la ejecución paso a paso y los
puntos de ruptura (breakpoints).
• Integración de herramientas externas: Por ejemplo, servicios de
almacenamiento en la nube o análisis de datos.
• Documentación y comunidad activa: Facilitan la resolución de problemas y el
aprendizaje continuo.

Importancia de los entornos de desarrollo en el proceso de

creación
El éxito de una aplicación no solo depende de su diseño o funcionalidad, sino también
de la eficiencia con la que se desarrolla. Los IDEs ayudan a los programadores a
trabajar de manera organizada y reducir errores, lo que a su vez ahorra tiempo y
recursos. Además, contar con herramientas de prueba y depuración en tiempo real
permite identificar y resolver problemas antes de que la aplicación llegue a los
usuarios finales.

Elaboración de programas
El proceso de creación de un programa es mucho más que sentarse a escribir líneas
de código. Es un trabajo organizado que pasa por varias etapas, y cada una tiene su
propia importancia para que el resultado final sea un software funcional, estable y útil.
A continuación, te explico las fases principales de este proceso, intentando que sea
claro y con ejemplos que lo hagan más cercano.

22
1. Análisis
El análisis es como la base de todo el proyecto. En esta etapa, lo primero que se hace
es definir exactamente qué se necesita. Es un momento clave porque, si no queda
claro qué se espera del programa, todo lo que viene después puede fallar. Aquí es
cuando el analista (el que estudia el problema y propone soluciones) habla con el
cliente o usuario para entender cuáles son sus necesidades.

Por ejemplo, imagina que te piden desarrollar una app para organizar eventos. En esta
fase, habría que averiguar qué funciones necesita: ¿Debe enviar notificaciones?
¿Permitir registro de asistentes? ¿Incluir un calendario interactivo? Todo esto se
recoge en lo que llamamos especificaciones funcionales, que sirven como guía para
las siguientes fases.

2. Diseño
El diseño es el paso en el que las ideas del análisis se convierten en algo más técnico.
Aquí se planifica cómo se hará el programa, teniendo en cuenta los recursos
disponibles.

Por ejemplo:

• Recursos físicos: ¿Qué tipo de ordenadores se usarán? ¿Necesitamos

periféricos como impresoras o cámaras?
• Recursos lógicos: ¿Qué sistema operativo soportará la aplicación? ¿Usaremos
bases de datos para almacenar información?

Además, en esta etapa se define cómo será la interfaz del programa (lo que el usuario
ve y usa) y cómo se organizarán las partes internas del software para que todo
funcione correctamente. Es como cuando haces un boceto detallado antes de
construir algo: te aseguras de que todo encaje y tenga sentido

3. Codificación o construcción
Aquí es donde empieza el trabajo práctico: se escribe el código del programa. Lo que
antes eran ideas y planos ahora se convierte en realidad. Se elige un lenguaje de
programación (como Python, Java o C++) y se empieza a construir cada parte del
programa.

Pero no se trata solo de escribir código. También hay que probarlo continuamente
para asegurarse de que no hay errores. Por ejemplo, si en la app de eventos añades
una función para enviar notificaciones, debes probar que estas llegan a tiempo, al
destinatario correcto y con el mensaje adecuado.

23
La codificación requiere paciencia y atención al detalle. Incluso un pequeño error
(como olvidar un punto y coma) puede hacer que el programa no funcione.

4. Explotación o implantación
Esta etapa es como la gran inauguración: el programa se pone en marcha en el
entorno real donde va a ser usado. Aquí se hacen las últimas comprobaciones para
asegurarse de que todo funciona como se espera.

Algunas tareas clave en esta fase son:

• Instalar el programa en los dispositivos donde se usará.

• Realizar pruebas de aceptación, que básicamente son pruebas finales para
comprobar que el cliente está contento con el resultado.
• Si había un programa anterior, se realiza la conversión de datos para que toda
la información pase al nuevo sistema.

Por ejemplo, en nuestra app de eventos, esta sería la etapa en la que la gente empieza
a usarla, y tú te aseguras de que las notificaciones llegan, el calendario funciona y
todo está en orden.

5. Mantenimiento
Aunque parezca que el trabajo termina cuando el programa se lanza, no es así. El
mantenimiento es una fase constante y crucial, ya que asegura que el programa siga
funcionando bien a medida que pasa el tiempo.

Hay dos tipos principales de mantenimiento:

1. Mantenimiento correctivo: Es cuando arreglamos errores que no se detectaron

durante las pruebas iniciales. Por ejemplo, si los usuarios reportan que no
pueden registrarse en la app, hay que solucionarlo rápidamente.
2. Mantenimiento preventivo: Este tipo de mantenimiento es más proactivo. Se
realizan revisiones periódicas para evitar problemas antes de que ocurran.

En algunos casos, si la app necesita cambios importantes, podría ser necesario volver
a empezar todo el ciclo de desarrollo.

En resumen, el desarrollo de un programa pasa por estas cinco etapas:

1. Análisis: Se identifican las necesidades del cliente y los requisitos del sistema.
2. Diseño: Se planifica cómo se construirá el programa.
3. Codificación: Se escribe y prueba el código.
4. Explotación: Se instala y se pone en marcha el programa.
5. Mantenimiento: Se corrigen errores y se hacen mejoras continuas.

24
Depuración de programas.
La depuración es una de las partes más importantes cuando estamos desarrollando
un programa. En programación, se llama debugging al proceso de encontrar y
corregir errores (o "bugs") en el código.

¿Por Qué Es Importante la Depuración?

La depuración no es solo una parte técnica, sino también una de las más esenciales
del proceso de desarrollo de software. La fase de pruebas es clave, y suele ocupar
gran parte del tiempo de desarrollo. No es algo improvisado, sino que se planifica
desde el principio del proyecto, con los analistas y desarrolladores trabajando en
conjunto para asegurarse de que el programa cumpla con los requisitos esperados.

Durante la implementación del código, los programadores también deben hacer

pruebas para asegurarse de que lo que escriben funcione correctamente. Dentro de
estas pruebas existen dos tipos principales: las pruebas de caja negra y las pruebas de
caja blanca, que se enfocan en diferentes aspectos del programa.

La depuración es el proceso que seguimos para identificar y corregir los errores en

nuestro código. Estos errores pueden aparecer en varias fases del desarrollo del
programa: la compilación, el enlazado y la ejecución.

Etapas Críticas en la Depuración

1. Compilación: En esta fase, el código que hemos escrito se convierte en un

formato que la máquina puede entender. Si el código tiene errores de sintaxis o
de declaración de variables, el compilador nos avisará de estos problemas.
Estos errores deben ser corregidos antes de que el programa pase a la
siguiente fase.
2. Enlazado: Muchos programas utilizan librerías de funciones predefinidas y
métodos creados por otros programadores. El enlazado se encarga de unir
estos métodos con el código cuando el programa se ejecuta. Durante la
compilación, se revisa que los métodos llamados existan y tengan los
parámetros correctos. Los errores de enlazado se detectan en esta etapa.
3. Ejecución: Una vez que el programa ha sido compilado y enlazado
correctamente, llega el momento de la ejecución. Sin embargo, es en esta fase
donde suelen aparecer los errores más difíciles de detectar. Algunos fallos son
evidentes, como cuando intentamos acceder a una parte de un array que no
existe, pero otros son más sutiles y provocan que el programa no haga lo que
25
 esperábamos. Estos fallos, conocidos como bugs , son los que más cuesta
localizar. El programador debe investigar para encontrar la causa de los
errores.

Fig 9. Diagrama de depuración.

Herramientas de Depuración: Usando el Depurador

La depuración se realiza mediante herramientas llamadas depuradores. Un depurador

es un programa que nos ayuda a ejecutar el código paso a paso, observando en cada
momento el comportamiento del programa y el valor de las variables. En Java, uno de
los depuradores más simples es el jdb (Java Debugger), que se usa desde la línea de
comandos. Sin embargo, muchos programadores prefieren usar los depuradores que
vienen integrados en sus entornos de desarrollo, como el que tiene NetBeans.

En NetBeans, el depurador nos muestra varios elementos en pantalla mientras el

programa se ejecuta, tales como:

• El código fuente del programa.

• Los valores de las variables seleccionadas.
• El estado de la ejecución, lo que permite ver paso a paso lo que está haciendo
el programa.

Además, se pueden usar breakpoints para detener el programa en puntos específicos,

lo que permite examinar el estado del programa en momentos clave de su ejecución.

Elementos del Depurador: Breakpoints y Ejecución Paso a

Paso
Cuando usamos un depurador para encontrar errores en nuestros programas,
existen dos herramientas fundamentales que nos ayudan mucho durante el

26
proceso: los breakpoints (puntos de ruptura) y la ejecución paso a paso.
Vamos a ver cómo funciona cada una de ellas.

1. Breakpoints (Puntos de Ruptura)

Los breakpoints son lugares en el código donde podemos hacer que el

programa se detenga de forma temporal. Como programadores, podemos
insertar estos puntos en cualquier línea del código. Cuando ejecutamos el
programa y el flujo de ejecución llega al breakpoint, la ejecución se detiene
automáticamente. Esto nos permite examinar el estado del programa en ese
momento específico.

Cuando la ejecución se detiene, el depurador muestra los valores actuales de

las variables. Si el valor de alguna variable es diferente al que esperábamos,
esto puede ser una pista clave para localizar el error o "bug" en el programa.
Los breakpoints nos ayudan a enfocar nuestra atención en partes concretas del
código donde creemos que puede estar ocurriendo el problema.

2. Ejecución Paso a Paso

Otra herramienta muy útil es la ejecución paso a paso. Esto significa que
podemos hacer que el programa se ejecute línea por línea, lo que nos permite
ver con detalle cómo avanza el flujo del programa. Si notamos que el
comportamiento no es el esperado en alguna parte, podríamos estar cerca de
descubrir un error.

Una ventaja de la ejecución paso a paso es que, si el programa está utilizando

funciones de bibliotecas estándar que sabemos que no contienen errores,
podemos optar por no entrar en esos métodos y ahorrar tiempo. El depurador
nos da la opción de saltar esos métodos, permitiéndonos centrarnos solo en el
código que hemos escrito y que podría estar causando el problema.

Fundamentos del software adaptativo.

El software adaptativo es un tipo de
software que puede ajustarse
automáticamente a cambios en su
entorno, sin necesidad de intervención
manual. Esto le permite responder a las
variaciones en los requisitos,
condiciones de uso, o incluso en el
hardware, lo que lo hace más flexible y
27
eficiente en diversas situaciones. A continuación, te explico los aspectos clave de este
tipo de software.

fig 10. Software.

El software adaptativo está diseñado para adaptarse a diferentes condiciones o

configuraciones, cambiando su comportamiento o rendimiento según sea necesario.
A diferencia del software tradicional, que tiene un comportamiento fijo y predecible, el
software adaptativo es capaz de modificar su funcionamiento en tiempo real para
ajustarse a las necesidades y el entorno del usuario.

Características del Software Adaptativo

• Autoajuste: El software puede hacer ajustes automáticamente según las
condiciones que cambian, como variaciones en el sistema operativo, hardware
o datos de entrada.
• Aprendizaje automático: En algunos casos, el software adaptativo incorpora
algoritmos de aprendizaje automático, lo que le permite aprender de la
experiencia y mejorar su rendimiento o funcionalidad.
• Personalización: Permite adaptar la interfaz o la funcionalidad a las preferencias
del usuario, mejorando la experiencia de uso.
• Escalabilidad: Puede ajustarse a diferentes tamaños de recursos, desde
dispositivos móviles hasta sistemas con grandes capacidades de
procesamiento.

3 tipos de Adaptación:

1) Adaptación en tiempo de ejecución: Esta es la adaptación que ocurre mientras

el software está en funcionamiento, sin interrumpir el servicio. Se utiliza
comúnmente en sistemas donde las condiciones cambian constantemente, como
aplicaciones móviles o servidores web.

2) Adaptación basada en el entorno: El software ajusta su comportamiento según

los recursos disponibles, como memoria, CPU o ancho de banda de red. Esto es
útil en dispositivos con recursos limitados.

3) Adaptación en función del usuario: El software personaliza la experiencia según

las preferencias o el comportamiento del usuario. Esto puede incluir ajustes en la
interfaz o la funcionalidad del programa.

Ventajas del Software Adaptativo

• Mayor flexibilidad: Se ajusta a las necesidades cambiantes del entorno sin

requerir actualizaciones manuales.

28
 • Mejora de la experiencia del usuario: La capacidad de personalización permite
que el software se adapte mejor a las preferencias individuales de los usuarios.
• Optimización de recursos: Al adaptarse a las condiciones del sistema o el
entorno, el software puede operar de manera más eficiente, utilizando los
recursos de manera óptima.
• Resiliencia: El software adaptativo puede seguir funcionando correctamente a
pesar de cambios inesperados en el entorno.

Desafíos del Software Adaptativo

Aunque el software adaptativo ofrece muchas ventajas, también presenta algunos

desafíos:

Complejidad en el diseño: Desarrollar un software que pueda adaptarse de manera

efectiva y sin errores puede ser complicado, ya que requiere una arquitectura flexible
y robusta.

Rendimiento variable: Dependiendo de las adaptaciones, el rendimiento del software

puede variar, lo que requiere pruebas exhaustivas en diferentes escenarios.

Seguridad: El hecho de que el software realice cambios en tiempo real también

plantea preocupaciones sobre la seguridad, ya que estas modificaciones pueden
introducir vulnerabilidades si no se gestionan adecuadamente.

Ejemplos de Software Adaptativo

• Sistemas operativos: Los sistemas operativos modernos, como Windows o

Linux, adaptan su uso de recursos según el hardware disponible y las
aplicaciones que se están ejecutando.
• Aplicaciones móviles: Las aplicaciones móviles a menudo se adaptan a las
características del dispositivo, como la resolución de pantalla, la capacidad de
la batería o la conectividad.
• Plataformas web: Sitios web como redes sociales o aplicaciones de comercio
electrónico personalizan el contenido y las recomendaciones en función del
comportamiento del usuario, lo que mejora la interacción y satisfacción.

Tendencias Futuras

A medida que la inteligencia artificial y el aprendizaje automático siguen avanzando,

se espera que el software adaptativo juegue un papel cada vez más importante. El uso
de algoritmos predictivos y análisis de grandes volúmenes de datos permitirá que los
sistemas se adapten de manera más precisa y efectiva a las necesidades del usuario y
a las condiciones cambiantes.

Conclusión

29
El software adaptativo representa un paso importante hacia un futuro donde los
sistemas informáticos son más flexibles, inteligentes y capaces de ajustarse a su
entorno. Si bien tiene sus desafíos, las ventajas que ofrece, como la mejora de la
experiencia del usuario y la optimización de recursos, lo convierten en una tendencia
clave en el desarrollo de software para el futuro.

Bibliografía
➢ Architecnología. Programación por etapas. Recuperado de
https://architecnologia.es/programacion-etapas-programacion
➢ Depuración de programas. Recuperado de
https://sarreplec.caib.es/pluginfile.php/10237/mod_resource/content/3/7_
depuracin_de_programas.html
➢ Elaboración de programas. Recuperado de
https://sites.google.com/view/gerardo-isaias-espinoza-leal/unidad-3/3-9-
elaboración-de-programas
➢ Entornos de programación. Recuperado de
http://descargas.pntic.mec.es/mentor/visitas/nav_Inici_Progr/lenguajes/le
n20.html
➢ Entornos para la creación de aplicaciones para móviles. Recuperado de
https://www.liderlogo.es/diseno-web/entornos-de-desarrollo-de-apps/
➢ El desarrollo adaptivo de software. Recuperado de
https://es.slideshare.net/slideshow/eldesarrolloadaptativodesoftwarepptx
/265264701
➢ Funciones de un programador. Recuperado de
https://gemini.google.com/app/d13bfec3c46e59da
➢ Fundamentos del software adaptivo. Recupeerado de

https://es.slideshare.net/slideshow/eldesarrolloadaptativodesoftwarepptx
/265264701

➢ Programación Apps. Para aprender hacer apps sencillas. Recuperado de

https://scoreapps.com/blog/programacion-apps/
➢ ¿Qué es la programación? Recuperado de
https://global.tiffin.edu/blog/que-es-programacion
➢ Que son los operadores en programación y para qué sirven. Recuperado
de https://www.apinem.com/operadores-en-programacion/#3-tipos-de-
operadores
➢ Representación de algoritmos. Recuperado de
https://edu.gcfglobal.org/es/conceptos-basicos-de-
programacion/representacion-de-algoritmos/1/#
30
➢ Tipos de datos simples y compuestos. Recuperado de
https://antares.sip.ucm.es/cpareja/libroAlgoritmos/docs/Cap11-15.pdf

31