Sintaxis humana

[Casimiro Noteví]

Yo vengo del lenguaje C y el código que estaba acostumbrado a escribir y ver en compañeros y amigos era "legible". Cierto es que por ahí veía código C que no lo entendía ni al derecho ni al revés.
Cuando llegué a delphi me pareció un lenguaje muy claro de entender pero no me gustó que había que escribir mucho. Quedaba legible también, muy legible, pero me parecía que escribía código innecesario, por ejemplo:

if(1)
{
  ...
}

if 1 then
begin
  ...
end

Es un ejemplo simplón, pero teclear 7 caracteres a 17 sólo en algo tan simple me parecía absurdo.

Ahora estoy acostumbrado, pero aún así me parece casi siempre que estoy tecleando demasiado.

Edito: Lo que quería explicar es que el lenguaje C me parecía lo más sencillo del mundo, te podías complicar tanto como quisieras, pero si no te gusta meterte en berenjenales entonces quedaba super claro, sencillo, conciso, simple, legigle (depende de cada uno).

[[duilioisola]]

Si piensan que Delphi, C o inclus0 Asembler tienen una sintaxis difícil, es porque no leyeron suficientes post en ClubDelphi.

Para muestra un botón

¿Qué es CFD?
¿Complemento de Impuestos locales? ¿Locales de dónde? ¿Locales al ordenado, al país, a la empresa?
¿nodo complemento<complmento>? ¿Es un árbol, una lista, alguna otra cosa?

¿En qué lenguage está delcarando la cuestión?

[ContraVeneno]

Empezado por duilioisola

Si piensan que Delphi, C o inclus0 Asembler tienen una sintaxis difícil, es porque no leyeron suficientes post en ClubDelphi.

Para muestra un botón

¿Qué es CFD?
¿Complemento de Impuestos locales? ¿Locales de dónde? ¿Locales al ordenado, al país, a la empresa?
¿nodo complemento<complmento>? ¿Es un árbol, una lista, alguna otra cosa?

¿En qué lenguage está delcarando la cuestión?

CFD: comprobante fiscal digital, factura electrónica.
Impuestos locales: determinados en base a la legislación estatal vigente. Algún impuesto que cobran solo en ese estado o municipio.
<complemento>: sección del archivo XML donde se guarda la información de el CFD, en este caso, quiere guardar los impuestos locales dentro del XML en su nodo Complemento.

saludos

[marcoszorrilla]

A mi el lenguaje más humano siempre me parecio el Cobol, otra cosa es que el compilador sea eficiente o no y lo que se pueda hacer o no.

MULTIPLY 5 BY RESULTADO.
//Este otro es mucho menos humano.
Mov ah,5
Mov al,5
Mul ah,al

Un Saludo.

[[coso]]

Hola,
sigo defendiendo que la sintaxis de C es mucho mejor que la de pascal, aunque lo que se gana en simplicidad al escribir se pierde en lectura. Para ejemplo, un programa de ajedrez...

#define    F getchar())
 #define H(z)*n++=z;
       #include        <setjmp.h>
    #define v main(0,0,0
           #define Z while(
                                                 #define _ if(
#define o(d)(S=63,u[l]=0,l[d]=6^e,q=1e4>v,0),l[d]=0,u[l]=e^6,S=b,q)
#define I(H,n) { _ r=l[x=H],!r|(r^e)<-1){ _ j=u[l],-7==r|6==r\
){ n; e=~e; return 1e5-443*f; } u[l]=0,t=j+1,i=j-1; _!i&89<\
x)i=j,t=6; _-1==t&30>x)t=j,i=-7; Z++i<t){ d =0; S&= 63; \
a=((j^e)!=1?6!=(j^e)?O[32+x/10]-O[u/10+32]-q:(S|=6!=j?8\
:1,2==u-x)*9+9*(x-u==2):(d=1==j?x-u:u-x)/8+!(!((x-u)%\
10)|r)*99+(j==1?90<x:29>x)*(9*O[28+i]-288))+O[r+28\
]*9-288+O[x%10+33]-f-O[33+u%10]; x[l]=i; S|=(21=\
=u|21==x)*2+(u==28|28==x)*4+(91==u|x==91)*16+32\
*(u==98|x==98)+(20==d)*64*x; a-=k>f?main(a,f+1\
,M,k):0; _ i==c&u==h&!f&N&a>-1e4&x==y)longjm\
p(z,1); S=b; _!N|f&&(a>M||!f&a==M&&1&rand()\
)){ _!f){ _ k){ c=i; h=u; y=x; } } else _ \
L-a<N){ n; e=~e; u[l]=j; x[l]=r; return\
 a; } M=a; } } x[l]=r; u[l]=j; n; } }
typedef int G; char J [ 78 ], O [ ]
=   "HRQAMS#-smaqrh[UTZYTU[|TBA("
"$#(ABT|ba`gg`ab8>GK[_`fFDZXEYR"         "L\t####"
"##B#A#@#G#F#E#D#K\t\3Zlv#tjm"         "\3J#tjm\3Pwb"
"ofnbwf\3Joofdbo\3)&`&`.&`&`"         "#+&g*\t"; G y,
c,h,e,S,*s,l[149]; jmp_buf z         ; G main(G L,G f,
G N,G k){ G u=99,p,q,r,j,i,x         ,t,a,b=S,d,M=-1e9
; char *n; if( *l){ e=~e; Z       u >21){ q= l[--u]^e;
_!-- q){ _!l[p=e?u-10:u+10]){   I(p,)_ e?u>80   & !l[p
-=10]:u<39&!l[p+=10])I(p,)} _ l[p=e?u-11:9+u]   )I(p,)
else _ u-1==S>>6){ l[u-1]=0; I(p,l[u-1]=-2^e);  } _ l[
p=e?u-9:11+u])I(p,)else _ S>>6==1+u){ l[1+u]=0; I(p,l
[1+u]=e^-2); } } _!--q){ n=O+41; Z++n<50+O)I(u+80-*n,
)} _ 0<q&4>q){  n=q==2?53+O:O+49; Z++n<O+(q!=1)*4+54
){ p=u; do I(p-=*n-80,)Z!p[l]); } } _ 4==q){ n=49+O
 ; Z++n<O+58)I(u-*n+80,)_ e&!(S&24)|!e&!(S&3)   &&
 !l[u-2]&!l[u-1]&!l[u-3]&&o(u)&&o(u-1)){ l[u-1]=4
  ^e; l[u-4]=0; I(u-2,l[u-1]=0; l[u-4]=e^4); } _
  e&!(S&40)|!e&!(S&5)  &&!l[u+1]&!l[2+u]&&o(u)&&
   o(1+u)){ l[u+1]=e^4; l[3+u]=0;   I(u+2,l[1+u
   ]=0; l[u+3]=4^e); } } } e=~e;   return M; }
    Z h<130){l[h]=-(21>h|98<h|2       >(h+1 )%
    10); O[h++]^=3; } n=O +14;       s=20+l; Z
     ++s<29+l){ 10[s]=1; 70[s]=~    ( * s = *
      n++ -+84); 60 [ s] =-2; } Z  n=J){ puts
       (58+O); u=19; Z++u<100){ H(32)_!( u%10
       ))H(32)H(O[7+l[u]])_(9+u)%10>7){ H(58
        -u/10)H(32)_ u&1)puts(n=J); } } puts
         (O+58); _-1e4 >v , 1)){ e=~e; puts
          (O+(v,0)> 1e4?e?90:82:96)); break
           ; } _ 1<L&e) { d=v,2+L); printf
            (O+114,h%10+64,58-h/10,y%10+64
             ,58 -y/10,d); } else{ putchar
              (62+e); h= (95 & F-44; c=l[h
                +=(56-F *10]; y=(95&F-44; y
                   +=(56-F*10; Z 10!=(u=(95
                    &F)){ c=5; Z--c>1&&u!=c
                      [O]); c=e^c-7; } } _!
                         setjmp(z)){ v+1,1);
                               puts(   106+
                                O); }   } Z
                                 10!=
                                  F; }

XD de un ofuscated C contest.

PD : dejo el link

[ContraVeneno]

buen código... pero creo que está al revés...

[[AzidRain]]

Todas las sintaxis al final son humanas pues no las interpreta una máquina sino un humano. Lo que dice Al es como pensar que las series de Fourier o las transformadas de La Place, fueran no humanas tan solo porque para los no entendidos del tema no signifiquen gran cosa.

Al final de cuentas Pascal nació como un lenguaje de "proósito general" por lo que tenía que ser entendido por "la generalidad de los programadores". Para muchos Pascal fue nuestra puerta de entrada y gracias a el logramos aprender rápidamente C, Java y demás cosas simplemente pensando "{=Begin, }=end, ...etc." Pascal es estupendo para entender la lógica de un programa y como se ejecuta. Una vez dominado todo lo básico estás listo para irte al lenguaje que desees. Pero de eso a que sea más o menos humano creo que dista muchísimo, como ya comenté.
Obviamente cuando ya te entiendes con el ya sale sobrando si te tardas 4 caracteres mas en escribir "begin" que "{" al final como es mi lema "Lo importante es el resultado".

Acoto: Casí nadie programa para otros, salvo honrrosísimas excepciones, todos tenemos nuestro propio estilo y nos cuesta mucho adaptarnos a esquemas ajenos.