Técnicas básicas de programación

<<- Anterior (Algoritmos) | (Introducción a la programación estructurada) Siguiente->>

Versión para imprimir esta pagina
La programación estructurada sigue tres reglas: la secuencia, la iteración y la decisión. La
primera de ellas indica que las instrucciones del código se leerán de principio a fin; la segunda
indica que, según cierta condición, un número de instrucciones podrían repetirse un numero
determinado de veces, y la tercera indica que según unas ciertas condiciones se ejecutarán o
no un conjunto de instrucciones. En el siguiente algoritmo para limpiar platos se aprecian
estas tres características. La indentación de las instrucciones indican cuáles son englobadas y
cuáles no por sus predecesoras.

mientras haya platos

coger plato
mientras haya suciedad
echar jabon
pasar el estropajo por el plato
si plato es azulado
ponerlo con los azules

En código no estructurado, quedaría algo más complejo.

1 coger plato
2 echar jabon
3 pasar el estropajo por el plato
4 si hay suciedad ir a la instrucción 2
5 si el plato no es azul ir a la instrucción 7
6 ponerlo con los azules
7 si hay más platos ir a la instrucción 1

En programas más grandes, esto es muchísimo más complicado.

Ahora conocemos la ejecución de los algoritmos. Sin embargo, un programa se compone
tanto de algoritmos como de una estructura de datos sobre los que operar.

Antes de empezar un programa

Estructura de un programa
En la programación estructurada hay un inicio y un fin perfectamente bien definido de acuerdo
al diagrama de flujo que se planteó al concebir la idea del programa.
Un programa bien estructurado debería tener algún subprograma que capture cualquier error
dentro del programa principal o de cualquier subprograma dentro de la aplicación de tal modo
que el subprograma que captura los errores genere un registro de datos que describa el error
generado y/o en qué subprograma se generó el error para posteriormente corregirlo. Para
facilitar la corrección de estos errores se hace uso de los comentarios agregados en el código
fuente.

Variables y constantes
Como hemos visto, el ordenador sigue una serie de instrucciones. Pero esas instrucciones
tienen que operar sobre una serie de datos. El ordenador típico sólo procesa una instrucción a
la vez, por lo que necesita 'espacios de memoria' donde guardar o depositar, a modo de
cajones, por usar un símil conocido, los diversos datos con los que trabaja. Aquí es donde
entran en juego las variables y constantes.
En los inicios, con el ensamblador, se podía decir al ordenador, por ejemplo: 'Ejecuta la
instrucción de esa posición de memoria' o también 'En esa posición de memoria está
guardada mi edad, imprímela por pantalla'. Todo esto se deriva del hecho de que los
programas también son datos. Esta ambigüedad presenta numerosos inconvenientes cuando
se producen errores, como el lector se imaginará fácilmente: de ahí que, a medida que los
lenguajes evolucionan hacia niveles superiores, se impida el tratamiento indistinto de los
datos. A partir de entonces, un programa tiene que decirle al sistema operativo los cajones
que necesita y éste se los proporciona independientemente de cuáles sean.
Quizás suene más complicado de lo que es. Un ejemplo: Queremos sumar dos números.
Nuestro programa tendrá que tener tres cajones: Uno para cada número y otro para el
resultado. Cada cajón tiene un nombre en vez de una posición de memoria, de manera que
sólo hay que nombrarlo:

Necesito cajones A, B y Resultado

Lee un número y guárdalo en A
Lee un número y guárdalo en B
Suma A y B y guárdalo en Resultado
Imprime el contenido de Resultado

He aquí nuestro programa. Como cabe pensar, un procesador no tiene la instrucción "Imprime
por pantalla"; esto es una llamada a otra porción de código que, gracias a la abstracción,
nosotros no hemos escrito, o hemos escrito una sola vez; a partir de lo cual podemos imprimir
todo el texto que queramos en la pantalla.
Las posiciones de memoria A y B son Variables. Si queremos leerlas o escribirlas, podemos
hacerlo. Típicamente, existirán datos que no pensamos modificar; no querremos que el
usuario tenga que introducirlos cada vez, pues son de naturaleza más constante que otros
(como puede ser el valor Pi para calcular el perímetro o área de un círculo). Para evitar
modificarlos por error, podemos pedir al sistema variables especiales, que no puedan ser
reescritas. Son las Constantes. Un ejemplo:

Comentario: Este programa calcula el área de un círculo

Constante PI = 3'14159265
Variable R
 Variable Resultado;
Leer número y guardar en R
Calcular PI * (R * R) y guardar en Resultado
Imprimir Resultado;

El uso de variables y constantes se asemeja al uso que se les da en el álgebra o en otras

ramas matemáticas.
Nótese también la clara separación entre estructuras de datos y algoritmos. Según los
lenguajes, esto puede ser o no obligatorio, pero es recomendable en aras de una mayor
claridad del trabajo.

Comentarios
El útil concepto del comentario: son líneas de texto que el compilador o el intérprete no
consideran como parte del código, con lo cual no están sujetas a restricciones de sintaxis y
sirven para aclarar partes de código en posteriores lecturas y, en general, para anotar
cualquier cosa que el programador considere oportuno.
Uno como programador debe tener como prioridad documentar nuestro código fuente ya que
al momento de depurar nos ahorrará mucho tiempo de analisis para su corrección o estudio.
Los programadores profesionales tienen la buena costumbre de documentar sus programas
con encabezados de texto (encabezados de comentarios) en donde describen la función que
va a realizar dicho programa, la fecha de creación, el nombre del autor y en algunos casos las
fechas de revisión y el nombre del revisor.
Por lo general algunos programas requieren hacer uso de llamadas a subprogramas dentro de
una misma aplicación por lo que cada subprograma debería estar documentado, describiendo
la función que realizan cada uno de estos subprogramas dentro de la aplicación.

Estructuras de datos y de control

Estructuras de control
Las estructuras de control pueden dividirse en dos: Estructuras de control Condicional y
Estructuras de control Repetitivo.
Las estructuras de control condicional son las que incluyen alternativas de seleccion con base
al resultado de una operación booleana, como por ejemplo, una comparación (A==B). Según
la expresión sea cierta o falsa, se ejecutará una sección de código u otro. Es el caso de la
sentencia IF THEN ELSE de Pascal o Basic:

IF A==0 THEN
PRINT "A vale 0"
ELSE
PRINT "A no vale 0"
Otra sentencia de control son las de tipo SWITCH CASE. En este tipo de sentencias se
especifica la variable a comparar y una lista de valores con los que comparar. Aquel que sea
el verdadero, se ejecutará:

SWITCH A
CASE 0:
PRINT "A vale 0"
CASE 1:
PRINT "A vale 1"

Otras herramientas imprescindibles del control de la ejecución de nuestro código son los
BUCLES o CICLOS. Consisten en un método que permite repetir un trozo de código varias
veces.
Hay básicamente dos tipos:
- Bucle FOR:
El bucle FOR consiste en una sentencia que engloba un grupo de instrucciones y tiene una
variable cuyo valor se va modificando en cada vuelta. En general se utiliza cuando sabemos
cuántas veces tenemos que repetir el código.

FOR A=0 TO 9 Especificamos en este caso que A variará desde 0

hasta 9, con lo que repetiremos el bucle 10 veces.
PRINT "Estamos en el bucle"
NEXT A Con esto cerramos el bucle e indicamos el final
del bloque de instrucciones que se repiten

- Bucle WHILE:
El bucle WHILE consiste en un bucle en el que el código se repite mientras se cumpla alguna
condición booleana (es decir, una expresión que dé como resultado verdadero o falso). Hay
variaciones, como el REPEAT...UNTIL, que se diferencia en el momento de comprobar si se
hace verdadera o no la condición.

WHILE A<>(B*2) DO Aquí especificamos la expresión que

evaluamos y aquí se comprueba
A=A+1 Incrementamos el valor de A mientras
sea distinto a B*2
DONE Como en el FOR, necesitamos
especificar donde acaba el bucle y el código.

Estructuras de datos
creo a como entero
creo b como entero
creo suma como entero
a=2
b=1
suma = a + b
imprimir suma

Estructura de una aplicación. Cualquier programa que se realice debe llevar una estructura
para disminuir la tarea de depuración ya que esta labor lleva más tiempo del estimado.
Si eres principiante en el área de programación debes definir el programa a realizar,
documentar cada uno de los pasos que realizas en tu programa, debes de considerar algún
metodo de captura de errores, etc.
En este subcapítulo abarcaremos el cómo estructurar una aplicación para mejorar o disminuir
el tiempo en depuración, así como localizar más rápidamente los errores.
Puedes buscar en Internet el concepto "pseudocódigo", que no es más que la escritura de un
algoritmo en un lenguaje más cercano al natural. Es decir, la orden en lenguaje Javascript que
repetiría el proceso de quitar suciedad añadiendo agua y jabón mientras se frota sería la
siguiente:

function frotar(cuanto){
var veces = 0;
for (veces = 0; suciedad < 0 || veces < cuanto ; veces++){
suciedad = suciedad - (agua + jabón);
}
}

Mientras que el algoritmo o pseudocódigo quedaría así:

función frotar (cuantas veces lo hago)

variable veces que llevo = 0
repetir (desde que vecesquellevo = 0 mientras la suciedad < 0 ó
vecesquellevo < cuantasveceslohago; aumentar vecesquellevo de una en
una)
suciedad = suciedad - (agua + jabón)
fin repetir
fin función

En primer lugar, es muy recomendable hacer un esquema sobre el papel con toda clase de
datos que se vayan a utilizar. Por ejemplo, si queremos hacer un programa para controlar una
empresa dedicada al alquiler de coches, podríamos necesitar:

 Matrícula del coche

 Marca del coche
 Modelo del coche
 Color del coche
 Estado del coche (si está alquilado, en reparación o disponible)
 Situación del coche (en qué lugar del garaje o en qué localidad está)
 Kilometraje del coche
 Precio por hora del coche
por un lado, y:

 Nombre del cliente

 Apellidos del cliente
 Dirección del cliente
 DNI del cliente
 Permiso de conducir del cliente
 Número de cuenta del cliente
... etc. por otro.

Enlaces externos
 Pseudocódigo De Programación
 Ejemplos de Pseudocódigos

Introducción a la programación estructurada

<<- Anterior (Técnicas básicas de programación) | (Aplicaciones de los tipos de datos estructurados) Siguiente->>
Versión para imprimir esta pagina

Introducción
La programación estructurada nació como solución a los problemas que presentaba la
programación no estructurada, la cual se empleó durante mucho tiempo antes de la invención
de la programación estructurada.
Un programa no estructurado es un programa procedimental: las instrucciones se ejecutan en
el mismo orden en que han sido escritas. Sin embargo, este tipo de programación emplea la
instrucción "goto". Una instrucción "goto" permite pasar el control a cualquier otra parte del
programa. Cuando se ejecuta una instrucción "goto" la secuencia de ejecución del programa
continúa a partir de la instrucción indicada por "goto". De esta forma, para comprender como
funciona un programa es necesario simular su ejecución. Esto quiere decir que en la mayoría
de los casos es muy difícil comprender la lógica de un programa de este tipo. Algunos
compiladores crean referencias cruzadas a las instrucciones apuntadas por los "goto",
posibilitando una navegación rápida a través del código fuente. Sin embargo, es algo común
en muchos lenguajes de programación el empleo de una variable en asociación con el destino
del "goto", no permitiendo la creación automática de tablas de referencias cruzadas. Existen
problemas similares en algunos lenguajes de programación estructurada, por ejemplo cómo
implementar las vistas en diferentes idiomas, de forma que varias personas puedan visualizar
la misma información, pero cada una en su idioma.
Esto se opone a la idea de utilizar algún tipo de abstracción que permita comprender cómo
funciona realmente un programa, que es lo que hace la programación estructurada.
Por este motivo, Dijkstra propuso la eliminación de la sentencia "goto".
Introducción a las estructuras de datos y tipos
de datos
La estructura y tipos de datos varia con cada lenguaje de programacion. Estos se pueden
definir como la forma y modo de programar que corresponde a una acción y le define una
funcion especifica.
La estructura no es mas que la forma que sigue ese lenguaje, por ejemplo:
abrir
ejecutar acción 1.
ejecutar acción 2.
cerrar.
(esta puede ser una estructura simple, pero cada lenguaje dice cuales y como
se usaran esas estructuras).
Por ejemplo:
En C, para poder crear una variable se necesita especificar el tipo de ella. (la
estructura quedaria mas o menos asi)
<abrir>
variable tipo carácter a = hola mundo.
variable tipo numero entero b = 123
variable tipo numero decimal c = 1.25
imprimir a,b,c
<cerrar> Esta claro que cada lenguaje usa sus propios
terminos para definir sus tipos de datos. (En C quedaria así)

#include <stdio.h> //cabezera estandar de

entrada y salida (aqui estan los ficheros
necesarios).

void main() //parte de la estructura de C, en

dependencia del compilador se debe usar int
main()
{
Char a[12] = Hola Mundo.;
int b = 123;
float c = 1.25;

printf ("%s %d %f",a,b,c);

} // define el fin del programa.(fin de la
estructura)

Pueden ver estas secciones para observar la estructura y tipo

de datos en C: puedes consultar en el Wikibook de C enlace
 a Wikipedia: Tipos de datos enlace a busqueda de google
"tipo+dato+programacion"

Aplicaciones de los tipos de

datos estructurados
<<- Anterior (Introducción a las estructuras de datos) | (Archivos) Siguiente->>
Versión para imprimir esta pagina
Los tipos de datos se utilizan para asignar una variable o una
constante con un nombre fijo que tome una porción de
memoria y que almacene una información en memoria, si el
tipo de dato es numérico solo almacenará datos numéricos y
si el tipo de dato es una cadena de caracteres almacenará
texto.
Y dependiendo el tipo de datos numérico se podrá almacenar
una cantidad de dato dependiendo la precisión que tenga la
variable.
En programacion los tipos de datos son (o pueden ser)
distintos entre si, cada tipo corresponde a como se va a jugar
con la memoria, es decir un dato numerico puede usar entre
2 y 4 byte (depende del compilador), mientras que un dato
carácter usara un byte por cada carácter, es por eso que se
especifica que es lo que se necesita.
En C, algunos tipos de datos son:
INT : Para numero enteros.
Ej:
Int a=5;
CHAR : Para caracteres. Se usa [] con un valor para
hacer una cadena de caracteres, por ejemplo una
palabra.
Ej:
Char [4] a=Hola;
FLOAT : Para numeros decimales.
Ej:
Float a=1.25;
En Visual Basic / Visual.Net, algunos tipos de
datos son (cabe resaltar que en este lenguaje de
programación se anticipa la instrucción "DIM"
que declara y asigna espacio para almacenar
una o más variables).
Integer : Para números enteros
Ej:
Dim a as integer
a= 4
 String: Para cadena de caracteres
Ej:
Dim cadena as string
cadena="Visual Basic"
Double: Para número decimales.
Ej:
Dim b as doublé
b=4.12
-
Hay muchos mas, pero estos son
mas comunes y son usados en otros
lenguajes (son como un estandar,
pero no son regla).

Archivos
<<- Anterior (Aplicaciones de los tipos de
datos) | (Herramientas de desarrollo) Siguiente-
>>
Versión para imprimir esta
pagina
Un archivo es un fichero (dato)
almacenado en algun recurso de
memoria, generalmente en Disco
Duro, pero dependiendo del uso (en
ciertos casos) son almacenados en
RAM.
Un Fichero tiene muchas funciones,
en programación, estos almacenan
códigos o parte de ellos (en
ocasiones se divide el código en
varios archivos). También es posible
que se necesita almacenar datos
que el usuario introduce ("Como sus
datos, nombre de usuario y
contraseña, etc.), estos se
empaquetan en un archivo y podrán
ser usados luego por el programa
por ejemplo, cuando el usuario
desee loguearse de nuevo.
En el lenguaje C++ y otros lenguajes
orientados a objetos, se suele
decir, "Todo es un archivo", debido
a como trabajan estos.
Archivos, en ocasiones puede
referirse a las librerias, pero creo
prudente hacer diferencias, una
librería es una utilidad para el
lenguaje en que programamos,
mientras que un archivo es una
utilidad mas cercana a nosotros (en
lo posible, desarrollado por
nosotros).

Herramientas de
desarrollo
Las herramientas de desarrollo son
aquellos programas o aplicaciones
que tengan cierta importancia en el
desarrollo de un programa
(programación). Pueden ser de
importancia vital (como un
ensamblador, un compilador o un
editor) o de importancia secundaria,
como una IDE (Integrated
Development Environment - Entorno
de Desarrollo Integrado).

Compiladores
Los compiladores son programas
que «traducen» un fichero de código
fuente de cualquier lenguaje al
lenguaje ensamblador y lo llama,
cuando sea necesario, igual que al
enlazador (o linker). Los más
importantes son GCC (GNU
Compiler Colector) para C, G++ para
C++, G77 para Fortran 77 y
Microsoft Visual C++, entre otros

Ensambladores
Los ensambladores son aquellos
programas que se encargan de
desestructurar el código en lenguaje
ensamblador y traducirlo a lenguaje
binario. Los archivos en lenguaje
binario se enlazan posteriormente en
un único fichero, el ejecutable.
Los más importantes son tas, gas,
nasm...

Enlazadores
(Linkers)
Son los programas que enlazan
varios ficheros objeto en lenguaje
binario para crear un único fichero,
el ejecutable del programa.
El más importante es ld. y también
es una de las mas usadas

Depuradores
(Debuggers)
Como su nombre lo indica, sirven
para corregir los errores o fallas de
la programación (bugs). Se
encargan de ejecutar, paso a paso
un programa, alertando sobre los
errores presentados y los valores de
las variables, entre otros. Son
particularmente útiles cuando el
programa parece estar bien, pero no
se obtiene el resultado esperado (se
cuelga, da resultados erróneos...).
El más importante es GDB.
Actualmente casi todas las IDEs
incluyen uno, o deberían.

Editores de texto
Son tan importantes como un
compilador pues es el editor de la
programación; actualmente incluyen
funciones específicamente
dedicadas a la programación, como
resaltado de sintaxis, y
autoindentación, entre otras
Grandes editores de texto son GNU
Emacs, Vim, Scite, Notepad++...

Otras herramientas
No son tan importantes como las
anteriores, pero también tienen su
importancia:

 IDEs (Interfaz de Desarrollo

Estructurada): juntan en un sólo
programa editor de texto,
compilador, enlazador,
ensamblador, depurador...
Ejemplos de ellas son Anjuta,
Dev-Cpp, Codeblocks...
 Programas de indentación:
sirven para aclarar el código
escrito confusamente. El único
que conozco es indent. De todas
formas, un editor de texto
medianamente decente suele
incluir sus propias funciones de
indentado.

Hola mundo
ABAP/IV
REPORT HOLAMUNDO.
WRITE '¡Hola, mundo!'.

ABC
WRITE "¡Hola mundo!"

ActionScript
trace("¡Hola, mundo!");

ADA
with Ada.Text_IO;

procedure Hola_Mundo is
begin

Ada.Text_IO.Put_Line("¡Hola
, mundo!");
end Hola_Mundo;

ASP
<%

Response.Write("Hola
Mundo")

%>

ASSEMBLY
.model small
.stack
.data
saludo db "Hola
mundo!!!", "$"
.code
main proc
;Init process
mov ax,seg saludo
mov ds,ax ;ds
= ax = saludo
mov ah,09
;Function(print string)
lea dx,saludo ;DX
= String terminated by "$"
int 21h
;Interruptions DOS
Functions
mov ax,4c00h
;Function (Quit with exit
code (EXIT))
int 21h
;Interruption DOS Functions
main endp ;End
process
end main

AWK
#!/bin/awk -f
BEGIN{
print "¡Hola, mundo!";
}

Bash
#!/bin/bash
echo "Hola mundo"

Basic
PRINT "Hola Mundo"

C
#include <stdio.h>

int main(void)
{
printf("Hola,
mundo!\n");
return 0;
}

C++
#include <iostream>

using namespace std;

int main() {

cout << "¡Hola,

mundo!" << endl;
}

C++/CLI
int main()
{

System::Console::WriteLine(
"Hola, mundo!");
return 0;
}

C#
using System;

class MainClass
{
public static void
Main()
{

Console.WriteLine("¡Hola
Mundo!");
}
}

COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.
MAIN SECTION.
DISPLAY "Hola mundo"
STOP RUN.
ColdFusion
<cfset variable="Hola
Mundo">
<cfoutput>#variable#</cfout
put>

MS-DOS
En sistemas operativos de la familia
DOS como MS-DOS o PC-DOS que
usan el Intérprete de
comandos COMMAND.COM o
sistemas que usan como intérprete
de comandos CMD.EXE
(OS/2 y Windows de la rama NT) se
pueden crear archivos de proceso
por lotes con extensiones BAT y
CMD respectivamente con el
siguiente contenido:

@echo ¡Hola, Mundo!

Eiffel
class HOLA_MUNDO
create
make
feature
make is
do

io.put_string("%nHola mundo
%N")
end
end -- HOLA_MUNDO

Erlang
-module(hola).
-export([hola_mundo/0]).

hola_mundo() ->
io:fwrite("Hola mundo!\n").

Fortran
PROGRAM HOLA
PRINT *, '¡Hola, mundo!'
END

Haskell
holaMundo :: IO ()
holaMundo = do putStrLn
("Hola mundo!")

HTML/JavaScript
<html>
<head>
<title>Hola
Mundo</title>
<script
type="text/javascript">
alert("¡Hola
mundo!");
</script>
</head>
<body>
</body>
</html>

INTERCAL
PLEASE DO ,1 <- #13
 DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #112
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #238
DO ,1 SUB #7 <- #26
PLEASE DO ,1 SUB #8 <- #22
DO ,1 SUB #8 <- #248
DO ,1 SUB #9 <- #168
DO ,1 SUB #10 <- #24
DO ,1 SUB #11 <- #16
DO ,1 SUB #12 <- #158
DO ,1 SUB #13 <- #52
PLEASE READ OUT ,1
PLEASE GIVE UP

Java
public class HolaMundo
{
public static void
main(String[] args)
{

System.out.println("¡Hola,
mundo!");
}
}

Programación en
Lexico (POO en
castellano)
Aplicación con un solo algoritmo:

tarea muestre "Hola mundo"

Aplicación con solo clases:

clase tarea
publicos:
mensajes:
Principal muestre "Hola
Mundo"

Aplicación con interfaz gráfica:

clase ventana derivada_de

"System.Windows.Forms.Form"
publicos
métodos
ventana copie "Hola mundo"
en ventana.Text

LISP
(format t "¡Hola, mundo!")

Liberty BASIC
print "¡Hola, mundo!"

MATLAB
close all;
% cierra todas las ventanas
que pueda haber
clear all;
% borra todas las variables
clc;
% limpia la pantalla

disp('hola mundo');
% muestra el mensaje
NATURAL
WRITE '¡Hola, mundo!'.

Object REXX
Utilizando los métodos de REXX
clásico:

say "Hola Mundo"

call lineout , 'Hola,
mundo.'
call charout , 'Hola,
mundo.'||eol /* eol
definido previamente */

Utilizando objetos:

.output~say('Hola, mundo.')
.output~lineout('Hola,
mundo.')
.output~charout('Hola,
mundo.'||eol) -- eol
definido previamente

Pascal
Program HolaMundo;
begin
Writeln('¡Hola,
mundo!');
end.

NetREXX
Utilizando la instrucción say que
proviene de REXX clásico:
say "Hola Mundo"

o directamente utilizando clases y

métodos Java:

System.out.println("¡Hola
mundo!");

OpenInventor
#Inventor V2.1 ascii
Text3 {
string "Hola mundo"
}

Perl
#!/usr/bin/perl
print "Hola, mundo.\n";

PHP
<?php
echo "Hola Mundo";
?>

Python
print "Hola mundo"

QBasic
PRINT "Hola mundo"

REXX
say "Hola Mundo"

Ruby
puts "Hola Mundo"

SAPScript
MAIN
P1 Hola Mundo
/

Seed7
$ include "seed7_05.s7i";

const proc: main is func

begin
writeln("Hola Mundo");
end func;

Smalltalk
Transcript show: '¡Hola,
mundo!'

SQL
Variante de Oracle:

SELECT 'HOLA MUNDO'

FROM DUAL;

Unlambda
```s``sii`ki
``s``s`ks
``s``s`ks``s`k`s`kr

``s`k`si``s`k`s`k

`d````````````.H.o.l.a.
.m.u.n.d.o
k
k
`k``s``s`ksk`k.*

Visual Basic
Sub Main()
MsgBox "¡Hola, mundo!"
End Sub

X3
SubProg HOLAMUNDO()
Infbox "Hola Mundo"
End

xBase
? "Hola Mundo"