Semana 3

Escritura de código

Luego de un análisis correcto de requerimientos, y de una diagramación esquemática de los

algoritmos que necesitaremos implementar para obtener los resultados deseados,
tendremos una idea clara de cómo deberemos organizar nuestro trabajo, y llegará el
momento de transcribir esos algoritmos para generar nuestro “código fuente”.

Este “código fuente” será sobre el que siempre trabajaremos en cada cambio o actualización
que realicemos, y sobre el que podremos aplicar diversas técnicas para su control,
depuración y organización. Será la expresión de los algoritmos previamente definidos, en un
lenguaje de codificación específico, elegido de acuerdo a preferencias y necesidades.

Pruebas de escritorio

Se trata de una técnica simple para probar el funcionamiento de nuestros algoritmos,

tomando valores de entrada y pasando estos valores por las diferentes etapas, para verificar
que los resultados (salidas) son correctos.

Existen diferentes tipos de pruebas, desde las muy simples de escritorio a depuraciones
complejas que se realizan directamente desde un entorno de programación y bajo un
determinado lenguaje, pero el concepto de escritorio es verificar de manera más ágil y
sencilla algoritmos puntuales, simplemente ejecutando de forma manual las etapas con
diferentes datos de entrada elegidos, para testear los cálculos bajo distintas condiciones.

Programación base texto

Históricamente, los distintos lenguajes de programación mantuvieron siempre una base de

texto, después de todo las diversas instrucciones no son más que nombres de texto para
identificar y configurar la ejecución de distintos comandos, con lo cual podremos inicialmente
escribir un “código fuente” casi con cualquier herramienta que tengamos a mano en nuestra
computadora. Nada nos impide, por ejemplo, utilizar Notepad en Windows para escribir
código.

Si bien esto es perfectamente posible, desde ya, es muy poco práctico. Los lenguajes de
programación poseen en general una gran cantidad de comandos, funciones y librerías.
Resulta imposible recordar de memoria la sintaxis y la forma de utilización de cada uno de
ellos, por lo cual es muy útil contar con un programa de edición (un editor) que nos brinde un
paquete de herramientas para colaborarnos en este tipo de situaciones, permitiéndonos
escribir de forma más rápida y reduciendo notablemente la posibilidad de cometer errores.

Es así que nacieron con los años muchos editores basados en texto, para programar de
manera más cómoda en distintos tipos de lenguajes, algunos pueden utilizarse en distintos
Sistemas Operativos, otros son específicos. En Linux por ejemplo, son muy populares
editores como Vim, Nano o Emacs, en Windows o iOS existen otros, pero en años recientes
ha aumentado considerablemente el uso de editores gratuitos multipropósito, ampliables a
través de plugins. Hay varios casos característicos que actualmente se utilizan mucho en
proyectos de programación, ya sea bajo Windows, Linux o iOS, como ser:
- Visual Studio Code
- Sublime Text
- Atom
- Eclipse
- NetBeans
- Vim
En nuestro caso trabajaremos con Visual Studio Code, ya que puede descargarse de
manera gratuita, presenta una interfaz muy cómoda, y es adaptable y completo para ser
utilizado con diferentes lenguajes.

Con los años, muchos editores fueron sumando funcionalidades, volviéndose cada vez más
y más completos, y dando lugar a la aparición de un término: IDE. IDE significa Integrated
Development Environment (Entorno Integrado de Desarrollo), y es sencillamente una forma
más elegante de identificar a un editor, en general uno diseñado específicamente para
trabajar de forma completa e integrada con determinados lenguajes y plataformas. Como su
nombre lo indica, la idea esencial de un IDE es integrar en un solo lugar el acceso a la
mayor parte de las herramientas de programación, permitiendo un desarrollo más eficiente y
cómodo.

Veremos algunos ejemplos de IDEs y su comodidad en la programación de texto.

Programación base gráfica (bloques)

Con los años y el desarrollo de distintos lenguajes, surgieron también alternativas visuales
de programación. Por ejemplo, un caso muy conocido es el de Ladder, un lenguaje gráfico
muy popular en la programación de PLCs (Controladores Lógicos Programables).

En la última década, se ha generado un enorme crecimiento de distintas herramientas de

programación visual por bloques, la gran mayoría basadas en proyectos muy conocidos
devenidos de un proyecto general (Scratch) iniciado originalmente en el MIT. El concepto de
Scratch es utilizar bloques visuales conectables (como si se tratase de un puzzle). Cada
bloque representa un comando determinado, los bloques pueden arrastrarse y engancharse
para ir formando la secuencia del algoritmo que deseamos representar, e internamente el
sistema se ocupará de “traducir” esa lista de bloques visuales a código de texto en un
determinado lenguaje (por ejemplo C/C++, Python o Javascript).

Este tipo de programación es muy cómoda para ser utilizada en ambientes educativos, la
ventaja de emplear bloques visuales es que el usuario puede abstraerse de los detalles de
sintaxis y restricciones del lenguaje, y concentrarse específicamente en la lógica de los
algoritmos que desea utilizar. De esta forma se agiliza enormemente el aprendizaje. Muchos
dispositivos existentes hoy en el mercado, brindan la posibilidad de utilizar algún sistema por
bloques para su programación, permitiendo que todo el mundo tenga la posibilidad de
probar, más allá de no tener o tener muy poca experiencia en Programación.
Por supuesto, como todo, no es perfecto, siempre existirá espacio y aplicación para la
programación tradicional de texto, ya que en proyectos complejos que incluyen gran
cantidad de componentes, la comodidad de los bloques visuales se pierde, resultando
mucho más eficiente la programación habitual, sobre todo para usuarios de más
experiencia.

Comenzando a programar. Análisis del problema

Como ya mencionamos, mucho antes de sentarnos frente a una computadora a escribir

código, debemos realizar un análisis del problema que se nos plantea y las alternativas de
solución, plasmando los pasos básicos en papel, en una pizarra o un archivo de texto
sencillo, para ir generando los primeros diagramas y fijar las ideas.

Por lo general no habrá una única solución para un problema dado, existirán diferentes
alternativas con diferentes exigencias de componentes y código, siendo necesario evaluar
los puntos positivos y negativos de cada caso para definir cuál conviene implementar.

Para un proyecto simple, esta etapa puede tomar apenas algunos minutos, pero en
proyectos de mayor complejidad es muy importante tomarse el tiempo de análisis necesario
-así sean días o semanas- porque todo análisis y evaluación temprana en esta etapa,
reducirá errores y ahorrará tiempo al momento de codificar, es decir, en la etapa de
programación propiamente dicha.

Datos de Entrada y Salida. Relación

Todo sistema automatizado, se puede dividir en 3 etapas básicas: Entradas, Procesamiento

y Salidas. Sintéticamente las Entradas aportarán los datos, que ingresarán a la etapa de
Procesamiento para ser manipulados (evaluados, comparados, clasificados, cuantificados,
filtrados, etc), accionando finalmente las Salidas que corresponda.

Existirá siempre una relación directa entre Entradas y Salidas, ya que los resultados
obtenidos en las Salidas dependerán de los datos alimentados a través de las Entradas,
salvo excepciones puntuales en las que una salida opere de manera independiente.

Las Entradas podrán ser leídas de forma continua, aguardando la introducción de un dato
por ejemplo, o a intervalos regulares para obtener su valor en ese momento. Actualmente
existen enorme cantidad de elementos de entrada conectables a una computadora o
dispositivo programable, desde los más comunes observados en cualquier PC, como un
pulsador, teclado, mouse o tableta digitalizadora; a otros, como sensores para diferentes
magnitudes o generadores de señal. Sea cual fuere el caso, sintéticamente estas entradas
caerán en 2 grandes categorías: analógicas y digitales, y terminarán brindando datos
digitales al sistema para su procesamiento.

Las Salidas por su parte también podrán ser tanto de tipo analógico como digital, a veces
100% electrónicas como en el caso de un monitor, en otras completamente
electromecánicas como lo es el accionamiento de un relay magnético, o bien con mayor
cantidad de componentes mecánicos como sucede con una impresora; pero en todos los
casos el objetivo de fondo será siempre el mismo: presentar los datos de manera amigable
para ser utilizados por el operador, o efectuar un accionamiento que notifique sobre la
situación actual de esa salida (como por ejemplo un led que enciende cuando la salida
correspondiente se activa).

Dentro de la etapa de análisis, luego de identificar claramente los objetivos fundamentales

de nuestro sistema, debemos también listar las Entradas y Salidas involucradas, es decir,
qué datos recibirá nuestro código para evaluar y procesar, y qué resultados deberá generar
a través de sus Salidas. Recién en este momento podremos completar de mejor manera
nuestros diagramas de flujo y comenzar a evaluar el funcionamiento de los algoritmos.

Seleccionando el lenguaje adecuado

Con una visión clara del proyecto y una diagramación general ya armada, es tiempo de
definir el lenguaje de programación a utilizar para su codificación. Existirán casos en los que
estaremos ligados a un lenguaje específico (porque el dispositivo por ejemplo exige utilizar
tal o cual opción), y otros en los que podremos optar, a veces según preferencia y
comodidad.
Como ya indicamos, lenguajes de alto nivel como Python o Javascript por ejemplo, serán
muy cómodos de utilizar, pero el código generado tendrá menor performance, y esto puede
ser crucial si estamos desarrollando un programa que requiere gran cantidad de recursos de
equipo; por otro lado, lenguajes como C/C++, serán más “duros” de utilizar si no se cuenta
con mucha experiencia, pero permitirán mayor control y rendimiento al momento de manejar
los recursos.

Para comenzar en Programación, Python es actualmente una muy buena alternativa, ya que
resulta muy intuitivo y cómodo de utilizar, permitiendo realizar una enorme variedad de
operaciones. El tiempo de desarrollo es algo que debemos tener en cuenta, ya que muchos
proyectos deben concretarse en plazos cortos, y allí los los lenguajes de alto nivel permitirán
lograr resultados rápidos y poder mostrar un sistema en funcionamiento sin grandes
demoras. Luego se podrá definir si el sistema quedará operando en esos lenguajes, o se
trabajará en una nueva versión evolucionada en lenguajes de menor nivel, ya con el tiempo
suficiente y con el antecedente de buen funcionamiento de la primer versión.

Elementos de lenguaje

Algunos componentes son específicos de tal o cual lenguaje, otros son mucho más
genéricos y aparecen en todos, más allá de diferencias de sintaxis y demás detalles que
puedan darse.

Comenzaremos ahora a repasar los elementos básicos de cualquier lenguaje, los pilares
sobre los cuales manejaremos la codificación de nuestros algoritmos, más allá del lenguaje
que seleccionemos para determinado proyecto:

Variables y Constantes

Como sabemos, a través de un lenguaje de programación, efectuamos una “traducción” de

algoritmos, para generar una secuencia de instrucciones que pueda ser “entendida” y
ejecutada por el dispositivo en cuestión.

En los algoritmos, dispondremos siempre de datos de entrada, ya sea de configuración o

periódicos. Los datos de configuración serán “leídos” sólo al comienzo de la ejecución del
código, para ajustar parámetros iniciales que permitan comenzar de forma correcta con el
procesamiento; los datos periódicos en cambio, se “releerán” cada determinado tiempo.

Para poder operar con estos datos, un dispositivo programable necesita disponer de un
espacio de memoria temporal, en el cual almacenarlos. De esta forma podrá realizar
comparaciones y demás operaciones utilizando estos datos.
Una Variable, no es más que un nombre amigable con el cual hacemos referencia a un dato
específico dentro de nuestro “código fuente”, de esa forma podemos citar y operar con este
dato todas las veces necesarias. Como resultado de estas operaciones, el valor de este dato
puede cambiar, de allí el nombre: Variable. La forma en la cual declaramos una variable,
depende por supuesto de cada lenguaje, pudiendo ser más o menos estricto o explícito,
pero como ejemplo simple, podemos tener:

n1 = 16

n1 es el nombre de la variable, podremos elegir cualquier cadena válida (no espacios ni

caracteres especiales como % por ejemplo).
16 es el valor que le asignamos a esta variable (= 16).

Con esta simple declaración, le estaremos indicando al sistema que deseamos utilizar una
variable llamada n1, con un valor inicial de 16.
Al ser una variable, si aplicamos luego cualquier operación sobre ella, por ejemplo:

n1 = n1 * 2

podremos alterar su valor, en este caso el nuevo valor será 32.

Una Constante es similar conceptualmente: un nombre amigable para hacer referencia a un

dato, solo que ese dato no será modificable a lo largo de la ejecución del código. La forma
en la cual se declaran las constantes, varía un tanto de un lenguaje a otro, por lo que
veremos otros detalles sobre ellas más adelante.

Convenciones y estilos de nomenclatura

Internacionalmente, todos los lenguajes de programación utilizan idioma inglés para nombrar
instrucciones y demás componentes. Al momento de escribir nuestro código, podremos
optar básicamente por seguir utilizando solo inglés -a efectos de mantener unificada la
nomenclatura del lenguaje y de los elementos personalizados que vayamos generando- o
bien utilizar en nuestro caso nomenclatura en castellano.

Obviamente el hecho de elegir una u otra opción, no afectará el desempeño a nivel lógico
del código, pero sí podrá incidir en su lectura. Si trabajamos de manera unipersonal o en
equipos locales, podremos utilizar nomenclatura en español sin demasiado problema; si por
el contrario operamos en proyectos más amplios y/o con grupos más heterogéneos respecto
a nacionalidad, será ideal uniformizar la nomenclatura en inglés.
Por otro lado, lo que siempre intentaremos hacer, es utilizar nombres relativamente cortos y
descriptivos, simplemente mantener coherencia en este aspecto, con eso será suficiente. No
aplicaremos caracteres especiales, tan solo letras sin acentuar, números y guiones.

Recuerden que los nombres son solo identificaciones a nivel de código fuente, no incidirán
en la lógica del código. Si recibo un número y debo multiplicarlo por una constante para
obtener un resultado, puedo escribirlo como:

n = 340
c = 3.14
r=n*c

n identifica al número recibido, c a la constante y r al resultado. No existe nada de malo en

utilizar letras aisladas como en este ejemplo, de hecho algunos lenguajes sugieren tratar de
aplicar nombres lo más cortos posible para variables. Sin embargo, a medida que el
volumen de código crece y diferentes responsables deben trabajar sobre él, o bien
transcurre determinado tiempo y debemos retomar nosotros mismos un código para su
actualización, el hecho de emplear nombres descriptivos facilita siempre su lectura y
análisis. El mismo ejemplo podría escribirse así:

numeroIngresado = 340
coeficiente = 3.14
numeroAjustado = numeroIngresado * coeficiente

Nuevamente, debemos mantener coherencia en esta nomenclatura, una variable que utiliza
50 letras en su nombre, tampoco resulta práctica.

Entre las distintas convenciones al momento de nombrar una variable por ejemplo, las más
populares son:
● Camel case.
● Pascal case.
● Snake case.
● Kebab case.

Camelcase:
Si quiero nombrar una variable que contiene un identificador de cliente, lo hago como:

idCliente (clientId)
podría también hacerlo como idDeCliente, pero en general evitaremos utilizar pronombres y
otros detalles, para mantener el nombre descriptivo pero tan corto como sea posible. En
definitiva, en Camelcase el nombre completo se escribe en minúsculas, y solo se cambia a
mayúscula la primer letra de cada palabra, excepto la inicial.

Pascalcase:
Es idéntico a Camelcase, pero la primer letra del nombre va también en mayúscula, es decir:

IdCliente (ClientId)

Esta práctica habitual en la escritura de variables, también se puede utilizar para constantes,
aunque en algunos lenguajes, se aplica la convención de escribir los nombres de constantes
completamente en mayúsculas, para que resulte más fácil diferenciar visualmente
constantes de variables. Ejemplo, si definimos la constante Pi, podríamos hacerlo como:

K_PI = 3.14
En este caso el guión bajo permite observar mejor la separación de palabras al encontrarse
todas las letras en mayúscula. Una vez más, esto no altera la lógica, utilizar los nombres
K_PI, KPI, KPI o kpi, funcionalmente será lo mismo, el punto es favorecer el análisis visual
del código.

Snake case:
Emplea nombres totalmente en minúsculas, y utiliza guiones bajos para separar palabras, tal
cual aplicamos en el ejemplo de K_PI. El identificador de cliente sería entonces:

id_cliente (client_id)

Kebab case:
No es tan popular como los anteriores, pero también se emplea, sobre todo a más bajo
nivel. Simplemente utiliza guión medio en lugar de bajo, es decir:

id-cliente (client-id)