Esta es una eterna discusión entre muchos programadores, y siempre he tenido un punto de vista muy claro frente al tema: No hay mejor o peor, simplemente hay: el indicado.
Un buen programador no se define por el lenguaje de programación, se define por dar una solución efectiva y práctica bajo los lineamientos tecnológicos y requerimientos del cliente.
He recorrido muchos lenguajes y plataformas, desde Assembler (Ensamblador), hasta HTML5, pasando por Visual Basic, C++, ASP.NET, PHP, Javascript, y muchos otros, en varias de sus versiones, y puedo hablar tranquilamente que no se trata del lenguaje, sino del proyecto como tal.
Esta discusión es llevada a cabo, en su mayoría por los diseñadores (codificadores, programadores), más que por los analistas (arquitectos); y considero que es debido a su conocimiento actual del lenguaje que ya manejan.
Cuando un novato pregunta a cualquier programador con cuál lenguaje puede comenzar, todos (y hasta el momento no he escuchado al primero que no sea así) siempre le recomiendan el lenguaje con el que tienen mayor experiencia. De esta manera, cada lenguaje ha ganado su reputación es gracias a la herencia de sus aprendices.
Lo mismo ocurre a nivel de bases de datos, cuál es la mejor y cuál es la peor, todo depende del proyecto, no de la tecnología en sí.
Algunos argumentan la estructuración mental que te brinda trabajar en un lenguaje o en otro, pero con el tiempo la estructuración mental solo se adquiere programando en varios lenguajes. Si se quiere tener estructuración mental a nivel de programación, entonces recomiendo
Brainfuck (es mejor que cualquier Sudoku enrazado en Tetris).
Otros aspectos que argumentan esta discusión es el origen del lenguaje, si es código abierto o no, por aquello de contribuir o no a las grandes compañías. Yo solo tengo un punto de vista para esto: si se quiere ser un programador con vocación de monje, puede seleccionar el lenguaje que prefiera, pero si es alguien mercenario que le trabaja al mejor postor, entonces es el cliente el que selecciona el lenguaje.
La pregunta inicial es tan fácil como difícil de contestar, pero no quiero dar ni la más fácil ni la más difícil, solo la mejor respuesta: "Es cuestión del proyecto". En cuanto a habilidades de aprendizaje, solo el programador tiene esa respuesta, para orientar un poco al novato, o incluso para que el conocer pueda incursionar, aquí dejo una lista de varios lenguajes de programación con un ejercicio muy sencillo, poner "Hola Mundo" en la pantalla (tomado originalmente de Wikipedia, pero lo traigo porque corregí algunos errores que allí tienen y me he dado cuenta que algunos fanáticos ponen errores en aquellos lenguajes que no gustan):
En ABAP/IV
REPORT HOLAMUNDO.
WRITE '¡Hola, mundo!'.
En ABC
WRITE "¡Hola mundo!"
En ActionScript
En ActionScript 3.0
Opción 1
package
{
import flash.display.Sprite;
public class Main extends Sprite
{
public function Main()
{
trace("¡Hola, Mundo!");
}
}
}
|
Opción 2
package
{
import flash.display.Sprite;
import flash.text.TextField;
public class Main extends Sprite
{
public function Main()
{
var txtField = new TextField();
txtField.text = "¡Hola, Mundo!";
addChild(txtField);
}
}
}
|
En Ada
with Ada.Text_IO;
procedure Hola_Mundo is
begin
Ada.Text_IO.Put("¡Hola, mundo!");
end Hola_Mundo;
En ALGOL
BEGIN
FILE F (KIND=REMOTE);
EBCDIC ARRAY E [0:12];
REPLACE E BY "HOLA MUNDO!";
WHILE TRUE DO
BEGIN
WRITE (F, *, E);
END;
END.
En AppleScript
display dialog "Hola, Mundo!" buttons {"OK"} default button {"OK"}
En ASP
<HTML><BODY>
<%
Response.Write("Hola Mundo")
%>
</BODY></HTML>
En AutoIt
MsgBox(0,"","Hola Mundo!")
En Autoplay Media Studio
Dialog.Message("Noticia", "Hola, Mundo!", MB_OK, MB_ICONINFORMATION, MB_DEFBUTTON1);
En AWK
#!/bin/awk -f
BEGIN{
print "¡Hola, mundo!";
}
En Bash
#!/bin/bash
echo "Hola mundo"
En Basic
print "Hola Mundo"
En Batch
@echo off
echo ¡hola mundo!
En Boo
#!/usr/bin/booish
print "Hola mundo"
En Brainfuck
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
En C
#include <stdio.h>
int main()
{
printf("¡Hola, mundo!\n");
return 0;
}
En C++
#include <iostream>
using namespace std;
int main()
{
cout << "¡Hola, mundo!" << endl;
return 0;
}
En C++/CLI
Opción 1
int main()
{
System::Console::WriteLine("Hola, mundo!");
return 0;
}
|
Opción 2
#include <iostream>
using namespace std;
void main()
{
cout << "Hola mundo\n";
}
|
En C#
using System;
class MainClass
{
public static void Main()
{
System.Console.WriteLine("¡Hola, mundo!");
}
}
En Centura
Call SalMessageBox('Hola Mundo', 'Saludo', MB_IconExclamation | MB_Ok)
En Clipper
? "Hola Mundo!"
En CLIPS
(printout t "Hola Mundo" crlf)
En COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
DATA DIVISION.
PROCEDURE DIVISION.
DISPLAY "Hola mundo".
STOP RUN.
En ColdFusion
<cfset variable="Hola Mundo">
<cfoutput>#variable#</cfoutput>
En CSS (2.0 en adelante)
Sólo para navegadores que cumplan con el estándar CSS 2.0 en adelante.
body:after {
content: 'Hola Mundo.';
}
En D
import std.stdio;
void main()
{
writefln("Hola mundo");
}
En Delphi
program PHolaMundo;
uses
Dialogs;
begin
MessageDlg('Hola Mundo', mtInformation, [mbOK], 0);
end.
En DIV Games Studio y Fenix GNU
PROGRAM Hola Mundo;
PRIVATE fuente1;
BEGIN
fuente1 = load_fnt("help\help.fnt");
write(fuente1, 160, 100, 4, "Hola Mundo");
LOOP
FRAME;
END
END
En DOS
En sistemas operativos de la familia DOS como MS-DOS o PC-DOS que usan como shell el intérprete de comandos
COMMAND. COM o
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:
En Eiffel
class HOLA_MUNDO
create
make
feature
make is
do
io.put_string("%nHola mundo%N")
end
end -- HOLA_MUNDO
En ensamblador de PowerPC para Mac OS X
# hola-ppc.S para Mac OS X
# gcc -nostdlib hola-ppc.S -o hola-ppc
.data ; datos
hola:
.ascii "Hola, mundo!\n"
hola_len = . - hola
.text ; aquí vive el codigo
.globl start
start:
li r0, 4 ; llamada al sistema 4 (sys_write)
li r3, 1 ; arg. 1: descriptor de archivo (stdout)
lis r4, ha16(hola) ; arg. 2: puntero a la cadena (parte alta)
addi r4, r4,lo16(hola) ; sumamos la parte baja del mismo
li r5, hola_len ; arg. 3: longitud de la cadena
sc ; llamamos al sistema
nop
li r3, 0 ; el valor que vamos a devolver
li r0, 1 ; llamada al sistema sys_exit
sc
nop
En ensamblador de PowerPC para GNU/Linux
# hola-ppc.S para GNU/Linux
# gcc -nostdlib hola-ppc.S -o hola-ppc
.data # datos
hola:
.string "Hola, mundo!\n"
hola_len = . - hola
.text # aqui vive el codigo
.global _start
_start:
li 0, 4 # llamada al sistema 4 (sys_write)
li 3, 1 # arg. 1: descriptor de archivo (stdout)
lis 4, hola@ha # arg. 2: puntero a la cadena (parte alta)
addi 4, 4,hola@l # sumamos la parte baja del mismo
li 5, hola_len # arg. 3: longitud de la cadena
sc # llamamos al sistema
nop
li 3, 0 # el valor que vamos a devolver
li 0, 1 # llamada al sistema sys_exit
sc
nop
En ensamblador de x86 para DOS
.model small
.stack
.data
Cadena1 DB 'Hola Mundo.$'
.code
programa:
mov ax, @data
mov ds, ax
mov dx, offset Cadena1
mov ah, 9
int 21h
end programa
En ensamblador de x86 para GNU/Linux
Nasm:
section .data
msg db "¡Hola Mundo!", 0Ah
len equ $ - msg
section .text
global _start
_start:
mov eax, 04h
mov ebx, 01h
mov ecx, msg
mov edx, len
int 80h
mov eax, 01h
mov ebx, 00h
int 80h
Gas:
.section .rodata
.MSG
.string "¡Hola Mundo!"
.section .text
.globl main
main:
movl $.MSG,(%esp)
call puts
movl $1,%eax
movl $0,%ebx
int $0x80
En Erlang
-module (hola).
-export([hola_mundo/0]).
hola_mundo() -> io:fwrite("Hola mundo!\n").
En Fortran
PROGRAM HOLA
IMPLICIT NONE
PRINT *, '¡Hola, mundo!'
END
En Google Go
package main
import "fmt"
func main() {
fmt.Println("Hola mundo")
}
En Groovy
En GWBasic
print "Hola Mundo"
En Haskell
holaMundo :: IO ()
holaMundo = putStrLn "Hola mundo!"
En HTML
<html>
<head>
<title>Hola Mundo</title>
</head>
<body>
¡Hola Mundo!
</body>
</html>
En Icon
procedure main ()
write ( "Hola Mundo" );
end
En IDL
En INTERCAL
PLEASE NOTE Hola mundo en INTERCAL
DO ,1 <- #13
DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #28
DO ,1 SUB #3 <- #192
DO ,1 SUB #4 <- #176
DO ,1 SUB #5 <- #82
DO ,1 SUB #6 <- #48
PLEASE DO ,1 SUB #7 <- #78
DO ,1 SUB #8 <- #8
DO ,1 SUB #9 <- #56
DO ,1 SUB #10 <- #80
DO ,1 SUB #11 <- #48
DO ,1 SUB #12 <- #114
DO ,1 SUB #13 <- #52
PLEASE READ OUT ,1
PLEASE GIVE UP
En IHTML
<!iHTML CACHE=TRUE>
<iSET message="Hola Mundo">
<html>
<head>
<title>:message</title>
</head>
<body>
¡:message
</body>
</html>
En Java
public class HolaMundo
{
public static void main(String args[])
{
System.out.print("Hola Mundo");
}
}
En JavaScript
<script type="text/javascript">
document.write("¡Hola, mundo!");
</script>
En JCL
//Paso1 EXEC PGM=T9971591
//DDUNO DD IN
%% Hola mundo
En JSP
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
<%! String hola = "hola mundo"; %>
<head>
<title>
<%= hola %>
</title>
</head>
<body>
<%= hola %>
</body></html>
En Korn Shell
#!usr/bin/ksh
print "Hola Mundo";
En LabVIEW
En Liberty BASIC
En LISP
(format t "¡Hola, mundo!")
En Logo
Opción 1
escribe [¡Hola mundo!]
|
Opción 2
Rotula "Hola GD 90 sl av 50 Rotula "mundo
|
En LOLCODE
HAI
CAN HAS STDIO?
VISIBLE "HAI WORLD!"
KTHXBYE
En Lua
Opción 1 (PC)
print("¡Hola, Mundo!\n")
|
Opción 2 (PSP)
Nombre=color.new(R, G, B)
screen.print(x, y, "Hola, Mundo!",Nombre)
|
En Malbolge
(=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**
hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCAA@98\6543W10/.R,+O<
En Maple
"hola mundo";
En Mathematica
Opción 1
hola mundo
|
Opción 2
Print["hola mundo"]
|
Opción 3
"hola mundo"
|
En MATLAB
En mIRC Scripting
on 1:start: {
echo ¡Hola Mundo!
}
En Modula-2
MODULE Hola;
FROM InOut IMPORT WriteString;
BEGIN
WriteString ("Hola Mundo");
END Hola.
En Natural
WRITE "HOLA MUNDO"
En NetLinx
send_string 0,'Hola Mundo'
En NetREXX
Opción 1: Con REXX clásico
Utilizando la instrucción say que proviene de REXX clásico:
say "Hola Mundo"
|
Opción 2: Con clases y métodos Java
Utilizando clases y métodos Java:
System.out.println("¡Hola mundo!");
|
En ObjectPAL
method holaMundo()
msgInfo( "", "¡hola mundo!")
endMethod
method run(var eventInfo Event)
msgInfo( "", "¡hola mundo!")
endMethod
En Object Pascal
procedure tform1.button1click (sender:tobject);
//Despues de crear y presionar el botón "button1"
begin
showmessage('HOLA MUNDO');
end;
end.
En Object REXX
Opción 1: Con REXX clásico
Utilizando los métodos de REXX clásico:
say "Hola Mundo"
call lineout , 'Hola, mundo.'
call charout , 'Hola, mundo.'||eol
|
Opción 2: Utilizando objetos
Utilizando objetos:
.output~say('Hola, mundo.')
.output~lineout('Hola, mundo.')
.output~charout('Hola, mundo.'||eol) -- eol definido previamente
|
En Ocaml
print_endline "Hola mundo";;
En OpenInventor
#Inventor V2.1 ascii
Text3 {
string "Hola mundo"
}
En Oz
declare
{Browse 'Hello World'}
En Pascal
Program HolaMundo;
Begin
Write('¡Hola, Mundo!');
End.
En Pauscal
'Pauscal: Lenguaje de programación en español
Importar "Pauscal.prp"
Mensaje("¡Hola Mundo!")
En Pawn
main () {
print("Hola, mundo!\n");
}
En Perl
En Perl v5.10
En PHP
Opción 1
<?php echo 'Hola Mundo!'; ?>
|
Opción 2
<?php print "Hola Mundo!"; ?>
|
Opción 3
|
En PL/1
Hola: procedure options(main);
put skip list('¡Hola Mundo!');
end Hola;
En PL/SQL
BEGIN
DBMS_OUTPUT.Put_Line( 'Hola Mundo' );
END;
En Prolog
En Python
En Python 3.0
En QBasic
En RapidQ
ShowMessage("Hola, mundo!")
En REXX
say "Hola Mundo"
En Ruby
En SAPScript
MAIN
P1 Hola Mundo
/
En Scala
object HolaMundo {
def main(args: Array[String]) =
println("Hola, mundo")
}
En Scheme
(let ((HOLA MUNDO
(lambda ()
(display "Hola, mundo")
(newline))))
(hola-mundo))
o, simplemente
(display "Hola, mundo\n")
En Scilab
En Scratch
En Seed7
$ include "seed7_05.s7i";
const proc: main is func
begin
writeln("Hola Mundo");
end func;
En Smalltalk
Transcript show: '¡Hola, mundo!'
En SQL
Variante de Oracle:
SELECT 'HOLA MUNDO'
FROM DUAL;
Otros SQL (MySQL, Microsoft SQL Server, etc.)
SELECT 'HOLA MUNDO';
print('HOLA MUNDO')
En Tcl
En Template Toolkit
[% GET "Hola mundo!"; %]
En TiBasic
print "Hola Mundo|"
En TrueBasic
print "Hola Mundo"
En Unlambda
```s``sii`ki
``s``s`ks
``s``s`ks``s`k`s`kr
``s`k`si``s`k`s`k
`d````````````.H.o.l.a.,. .m.u.n.d.o.!
k
k
`k``s``s`ksk`k.*
En Vala
Opción simple:
void main () {
print ("Hola mundo\n");
}
Usando orientación a objetos:
class Sample : Object {
void run () {
stdout.printf ("Hola mundo\n");
}
static void main (string[] args) {
var sample = new Sample ();
sample.run ();
}
}
En Visual Basic
Private Sub Form_Load()
Msgbox "Hola Mundo"
End Sub
En Visual Basic .NET
Private Sub Form_Load() Handles Form1.Load
Messagebox.show("¡Hola, mundo!")
End Sub
'modo consola.
Private Sub Main()
Console.WriteLine("¡Hola, mundo!")
End Sub
En Visual FoxPro
En X3
SubProg HOLAMUNDO()
Infbox "Hola Mundo"
End
En xBase
? "Hola Mundo"
En XUL
<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
<window
id="Hola"
title="Ejemplo: hola mundo"
orient="vertical"
persist="screenX screenY width height"
xmlns= "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
<description style='font-size:24pt'>Hola mundo</description>
<description value='Hola mundo' style='font-size:24pt'/>
<label value = 'Hola mundo' style='font-size:24pt'/>
</window>
