Ir al contenido


Foto

Lenguajes de Programacion del Lado del Escritorio

Comenzado por javsolis3 , ene 31 2012 10:21

  • Por favor identifícate para responder
52 respuestas en este tema

Encuesta: Cual de estos lenguajes de programacion te gusta programar y por que? (19 miembros han emitido voto)

Cual de estos lenguajes de programacion te gusta programar y por que?

  1. Delphi (14 votos [73.68%])

    Porcentaje de voto: 73.68%

  2. Visual Studio (1 votos [5.26%])

    Porcentaje de voto: 5.26%

  3. C ++ (3 votos [15.79%])

    Porcentaje de voto: 15.79%

  4. C (1 votos [5.26%])

    Porcentaje de voto: 5.26%

Votar Los invitados no pueden votar

#21 escafandra

escafandra

    Advanced Member

  • Administrador
  • 4.107 mensajes
  • LocationMadrid - España

Escrito 10 febrero 2012 - 04:18

Yo soy de la opinión que es cuestión del programador y no del lenguaje la limpieza y el buen código.


Exactamente.  (y)

En delphi también se puede escribir código ininteligible, y como en C, también puede ser código claro como el agua, pero claro, para el que entienda dichos lenguajes.

El código lo escriben las personas y como las palabras,  no dependen del idioma que hables para hablar enrevesado o claro como el agua. Personalmente el ruso no lo entiendo pero he leído literatura traducida y es una delicia.


Saludos.

  • 0

#22 egostar

egostar

    missing my father, I love my mother.

  • Administrador
  • 14.448 mensajes
  • LocationMéxico

Escrito 10 febrero 2012 - 04:48


Yo soy de la opinión que es cuestión del programador y no del lenguaje la limpieza y el buen código.


Exactamente.  (y)

En delphi también se puede escribir código ininteligible.......


Bueno, tú (como otros grandes amigos de por aquí) sueles hacer código initelegible para los humanos :D :D :D

Salud OS
  • 0

#23 escafandra

escafandra

    Advanced Member

  • Administrador
  • 4.107 mensajes
  • LocationMadrid - España

Escrito 10 febrero 2012 - 05:33

Bueno, tú (como otros grandes amigos de por aquí) sueles hacer código initelegible para los humanos :D :D :D


:s Yo creí que se entendía...

Bueno... eso es un punto mas en favor de la idea de que depende mas del que lo escribe que del propio lenguaje... :D :D :D


Saludos.
  • 0

#24 egostar

egostar

    missing my father, I love my mother.

  • Administrador
  • 14.448 mensajes
  • LocationMéxico

Escrito 10 febrero 2012 - 05:43


Bueno, tú (como otros grandes amigos de por aquí) sueles hacer código initelegible para los humanos :D :D :D


:s Yo creí que se entendía...

Bueno... eso es un punto mas en favor de la idea de que depende mas del que lo escribe que del propio lenguaje... :D :D :D


Saludos.


jajaja, pues se entiende muy bien........................... cuando corres el exe. :D :D :D


Saludos


  • 0

#25 casi

casi

    Advanced Member

  • Miembro Platino
  • PipPipPip
  • 191 mensajes

Escrito 10 febrero 2012 - 06:30

Aunque llevo usando delphi desde 1998, he votado por C  :)
Porque me daba pena que nadie lo haya votado, estaba ahí solito el pobre sin nadie que lo quiera :)

Bueno, en realidad es que gustarme, me gusta más el lenguaje C, pero no el C++ ni el C# (este último sólo tiene básicamente de C el nombre).
Yo aprendí C allá por 1989, con Turbo C 2.0 de Borland :), con un debugger integrado fabuloso, era increiblemente rápido, y en cuanto a complejidad, la verdad, siempre me pareció muy sencillo, es el lenguaje que más fácil me resultó aprender. Aunque hace muchos años que no lo uso, ya digo, pero siempre fue mi favorito.

  • 0

#26 Marc

Marc

    Advanced Member

  • Moderadores
  • PipPipPip
  • 1.484 mensajes
  • LocationMallorca

Escrito 11 febrero 2012 - 11:26


Yo soy de la opinión que es cuestión del programador y no del lenguaje la limpieza y el buen código.


Exactamente.  (y)

En delphi también se puede escribir código ininteligible, y como en C, también puede ser código claro como el agua, pero claro, para el que entienda dichos lenguajes.

El código lo escriben las personas y como las palabras,  no dependen del idioma que hables para hablar enrevesado o claro como el agua. Personalmente el ruso no lo entiendo pero he leído literatura traducida y es una delicia.


Saludos.


Lo siento pero no puedo estar de acuerdo con vosotros.

Es cierto que un buen programador siempre hace la diferencia, y que un mal programador es un mal programador sea cual sea el lenguaje que utilice.

Pero no estoy de acuerdo en que la legibilidad del código es la misma entre derivados de Pascal y derivados de C. El lenguaje Pascal es más cercano al lenguaje natural, o al pseudocódigo que se utiliza para aprender a programar. Por eso su código es más comprensible a simple vista (especialmente para programadores angloparlantes).

Cierto que aunque Pascal no permite las aberraciones de C (la que puedes liar si te dedicas a enmerdar con punteros y operadores unitarios), si lo coge un mal programador puede crear perfectamente una unidad Pascal con código espagueti que no haya ni Dios que le pueda seguir el rastro.

Pero eso es la excepción de la regla, y habiendo programado con los dos, no tengo la menor duda de que un código Pascal de calidad promedio es notablemente más comprensible a simple vista para un programador promedio de Pascal, que un código promedio C para un programador promedio de C.

Saludos.
  • 0

#27 escafandra

escafandra

    Advanced Member

  • Administrador
  • 4.107 mensajes
  • LocationMadrid - España

Escrito 11 febrero 2012 - 06:59

Lo siento pero no puedo estar de acuerdo con vosotros.

Eso es lo que enriquece y da sentido a las discusiones.  :) (y)

Cierto que aunque Pascal no permite las aberraciones de C (la que puedes liar si te dedicas a enmerdar con punteros y operadores unitarios),

¿Permitir aberraciones?. Cualquier lenguaje permite que un mal programador cometa esas cosas. Delphi permite usar punteros y esta práctica, al igual que con C, puede generar errores difíciles de depurar si no se sabe exactamente lo que se está haciendo. Eso no es culpa del lenguaje. Si queremos potencia y control a bajo nivel, el lenguaje nos debe dar ciertas licencias bajo nuestra entera responsabilidad. Y es en este punto, precisamente, donde encuentro mas virtudes en el lenguaje C frente a otros, salvando al asm (lenguaje que en un tiempo me apasionó).

Creo que un programador promedio en C, grupo entre los que me incluyo, es capaz de entender casi cualquier código C, otra cosa es que sepa lo que hace dicho código, cuando usa librerias externas, APIs o manejo a muy bajo nivel de sistemas que poco conoce. Pero eso le pasa a cualquier programador en cualquer lenguaje de esas características, incluido el Pascal.

Y sí, he de de reconocer que algunas construciones sintácticas del Pascal son mas conprensibles o cómodas de usar que las equivalentes en C. Y que algunas contracciones de C son crípticas (rara vez las uso), no así el ejemplo que pusiste c += 1; o i++ que entiende y practica cualquier iniciado en C.

Yo me siento cómodo en Pascal y en C pero he de reconocer que algunas cuestiones las pienso primero en C para buscar, después, su equivalencia en Pascal. Entiendo que otras personas no lo sientan de ese modo. Pero he de resumir diciendo que ambos son grandes lenguajes.


Saludos.
  • 0

#28 Marc

Marc

    Advanced Member

  • Moderadores
  • PipPipPip
  • 1.484 mensajes
  • LocationMallorca

Escrito 12 febrero 2012 - 01:30

Hola escafandra.

Si realmente crees que Pascal permite las mismas aberraciones que C, te invito a que me enseñes un código Pascal tan simple como el siguiente y tan absolutamente incomprensible. Por cierto, te voy a felicitar si como programador experto en C me sabes deducir en que algoritmo se basa para calcular el nº PI con esas dos escasas líneas.



delphi
  1. #define _ -F<00||--F-OO--;
  2. int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()
  3. {
  4.             _-_-_-_
  5.        _-_-_-_-_-_-_-_-_
  6.     _-_-_-_-_-_-_-_-_-_-_-_
  7.   _-_-_-_-_-_-_-_-_-_-_-_-_-_
  8.  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  9.  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  10. _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  11. _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  12. _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  13. _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  14.  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  15.  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_
  16.   _-_-_-_-_-_-_-_-_-_-_-_-_-_
  17.     _-_-_-_-_-_-_-_-_-_-_-_
  18.         _-_-_-_-_-_-_-_
  19.             _-_-_-_
  20. }



Y me reafirmo en que los operadores += y ++ me parecen absolutas aberraciones. Solo sirven para ahorrarte escribir de nuevo la variable, lo cual es una ventaja miserable y en cambio su precio es que al alejarte del lenguaje natural, cuando combinas varios operadores de esos en una misma expresión, tienes que coger un lápiz y ponerte a analizar para deducir lo que pretende hacer. En Pascal nunca te puede ocurrir eso (y por esta razón no puedes escribir en Pascal un código como el ejemplo anterior), porqué te obliga a usar solo una sintaxis estricta, cercana al lenguaje natural, y por tanto, fácil de comprender siempre a simple vista. NOTA: Y no me digas que estas expresiones no se ponen, porqué está lleno de gente que si la sintaxis lo permite, lo va a utilizar, y encima se creerán muy listos y se quedarán tan satisfechos y orgullosos de como han comprimido cinco líneas de código en una única expresión (aunque naturalmente, si tú tienes que corregir su código, unos años después, te vas a acordar de la santa madre del listillo).

Respecto a los punteros e indirecciones, recuerdo que en la facultad me harté de ellos, escribiendo en C, eran inevitables para escribir código en ese lenguaje. En cambio en los últimos diez años escribiendo en Delphi (Object Pascal), no recuerdo haber necesitado utilizar un puntero ni una sola vez (solo están para casos muy extraordinarios y fuera de lo corriente en que se va a manejar directamente la memoria).

Lo siento, pero la legibilidad de un código C promedio no es la misma que la legibilidad de un código Pascal promedio, porqué como te dije, Pascal está mucho más cerca del lenguaje natural, y con C tienes que hacer un esfuerzo mucho mayor de abstracción (y mejor no hablamos, si el código C lo ha escrito un listillo con ganas de comprimir código usando las burradas que C permite).

Saludos.
  • 0

#29 escafandra

escafandra

    Advanced Member

  • Administrador
  • 4.107 mensajes
  • LocationMadrid - España

Escrito 12 febrero 2012 - 07:02

Hola Marc.

Si realmente crees que Pascal permite las mismas aberraciones que C.

Aberraciones:

Grave error del entendimiento. Acto o conducta depravados, perversos, o que se apartan de lo aceptado como lícito.

Las aberraciones las cometen las personas y sólo ellas son responsables. Si te refieres a códigos difíciles de leer, entonces es claro que depende del que lo escribe y no sólo de las licencias del lenguaje. Este es meramente una herramienta. Cada lenguaje nació para cubrir una necesidad y se le ha dotado para ello.

Delphi permite el uso de punteros, eso no quiere decir que permita aberraciones. Pero si que puede dar lugar a errores difíciles de encontrar y depurar. Por poner un ejemplo de código mío puedes ver esta sencilla función en C, delphi y asm. Podría poner ejemplos de código delphi que cuesta mas trabajo de descifrar, escrito en este mismo foro por excelentes programadores que todos conocemos. Y el hecho de que sea algo mas críptico no  los convierte en códigos aberrantes. Determinadas tareas, aveces requieren determinada forma de escribir un código.


Por cierto, te voy a felicitar si como programador experto en C me sabes deducir en que algoritmo se basa para calcular el nº PI con esas dos escasas líneas.

php
  1. #define _ -F<00||--F-OO--;
  2. int F=00,OO=00;main(){F_OO();printf("%1.3f\n",4.*-F/OO/OO);}F_OO()....


No soy un programador experto en nada, en eso google nos saca ventaja y eso le hace perder la gracia.


...En Pascal nunca te puede ocurrir eso (y por esta razón no puedes escribir en Pascal un código como el ejemplo anterior), porqué te obliga a usar solo una sintaxis estricta, cercana al lenguaje natural, y por tanto, fácil de comprender siempre a simple vista.

¿Seguro?. Ten en cuenta que muchos de esos códigos anecdóticos son el resultado de un juego y como ejemplo te pongo este enlace de nuestro amigo cHackAll o este hilo de DA donde se trata de jugar con el código. No creo que eso sea aberrante, mas bien divertido.


Y no me digas que estas expresiones no se ponen, porqué está lleno de gente que si la sintaxis lo permite, lo va a utilizar, y encima se creerán muy listos y se quedarán tan satisfechos y orgullosos de como han comprimido cinco líneas de código en una única expresión

En realidad si se usan los operadores unarios pero la media no va mucho mas allá. Como te dije yo no soy muy partidario se esas compresiones de código a las que te refieres, si de los operadores unarios y aritmética de punteros cuando me hace falta. Me da la sensación que has tenido algún problema con alguno de esos listillos de los que hablas, no es la primera vez que repites la expresión.


Lo siento, pero la legibilidad de un código C promedio no es la misma que la legibilidad de un código Pascal promedio, porqué como te dije, Pascal está mucho más cerca del lenguaje natural, y con C tienes que hacer un esfuerzo mucho mayor...

Ya se que prefieres el Pascal y yo no pretendo convencerte de nada.

Por algún motivo que no está en tus palabras, no eres tolerante con el C. Pienso que los calificativos que usas en contra del C, no son muy afortunados y tienen cierta carga agresiva. Lamentablemente conozco otras personas que se alinean como tú, en posiciones enfrentadas al C, sacando simbólicas espadas. Son posturas que no comprendo ni comparto.

El lugar del C está claro, es indiscutible y sigue siendo necesario. Posiblemente sobrevivirá a muchos lenguajes que hoy conocemos.



Saludos.
  • 0

#30 egostar

egostar

    missing my father, I love my mother.

  • Administrador
  • 14.448 mensajes
  • LocationMéxico

Escrito 12 febrero 2012 - 10:14

Hola

Cuando he dicho que lo que escribe escafandra y demás compañeros y que no menciono porque no quiero caer en omisiones, es que no entiendo su código no porque sea ilegible sino porque desconozco las funciones que utilizan y su forma de abstraer los problemas sea en C o Delphi, si, por supuesto, me cuesta más trabajo o a veces no puedo entender lo que se hizo en C, pero porque desconozco la estructura y las funciones propias del lenguaje, no porque esté mal escrito.

Si, efectivamente, en cualquier lenguaje se puede escribir con las patas y suele ser que cuando nos toca continuar con un código que otro programador desarrolló y para entenderlo nos cuesta uno y la mitad del otro, pero eso no dice que sea malo ni sucio, es que no podemos tener la misma perspectiva de lo que el desarrollador original tuvo.

Saludos
  • 0

#31 casi

casi

    Advanced Member

  • Miembro Platino
  • PipPipPip
  • 191 mensajes

Escrito 13 febrero 2012 - 03:47

Por supuesto que C permite escribir código más difícil de leer que la mayoría de lenguajes, pero también se puede escribir código "normal" que se entiende como en cualquier otro lenguaje.
Pero ya sabemos que sobre gustos... a algunos les gusta cobol :)

  • 0

#32 escafandra

escafandra

    Advanced Member

  • Administrador
  • 4.107 mensajes
  • LocationMadrid - España

Escrito 13 febrero 2012 - 04:28

Hola

Cuando he dicho que lo que escribe escafandra y demás compañeros y que no menciono porque no quiero caer en omisiones, es que no entiendo su código no porque sea ilegible sino porque desconozco las funciones que utilizan y su forma de abstraer los problemas sea en C o Delphi, si, por supuesto, me cuesta más trabajo o a veces no puedo entender lo que se hizo en C, pero porque desconozco la estructura y las funciones propias del lenguaje, no porque esté mal escrito.

Si, efectivamente, en cualquier lenguaje se puede escribir con las patas y suele ser que cuando nos toca continuar con un código que otro programador desarrolló y para entenderlo nos cuesta uno y la mitad del otro, pero eso no dice que sea malo ni sucio, es que no podemos tener la misma perspectiva de lo que el desarrollador original tuvo.

Saludos


En lo que me toca, siempre entendí tus palabras :) que fueron comentarios cargados de humor. Entiendo la dificultad que se puede tener al leer código de otra persona, sobre todo en problemas algo complejos y que no sabemos como están enfocados. Realmente no se trata de sólo leer sino de descifrar un cómo resolvió el problema, sobre todo si el código no está comentado.

Por supuesto que C permite escribir código más difícil de leer que la mayoría de lenguajes, pero también se puede escribir código "normal" que se entiende como en cualquier otro lenguaje.
Pero ya sabemos que sobre gustos... a algunos les gusta cobol :)


Claro, es por eso que el programador es libre y responsable de lo que hace. C no le obliga.


Saludos.
  • 0

#33 Marc

Marc

    Advanced Member

  • Moderadores
  • PipPipPip
  • 1.484 mensajes
  • LocationMallorca

Escrito 13 febrero 2012 - 05:23

Escafandra no hagas trampas y no me juntes distintas descripciones de la palabra aberración, en una sola. Solo la segunda aceptación de la palabra se refiere a actos o conductas humanas. En cambio cuando digo que C es un lenguaje con apartados sintácticos aberrantes, me refiero claramente a la primera aceptación de esa palabra : "grave error del entendimiento" (por poner otro ejemplo, ¿ a que acto o conducta humana crees que se refiere una expresión tan común como aberración de la naturaleza ?).

No hay punto de comparación entre el código que enlazas de cHackAll, con el que te he enlazado yo (la única parte de ese código que no es meridianamente clara, es el código ensamblador adjuntado, pero evidentemente eso no tiene nada que ver con Pascal). Como te he dicho ya, en Pascal no vas a poder hacer un código ininteligible, no de esa forma.

El único problema de Pascal, es el código espagueti. Pero para eso tienes que tener un montón de unidades de código, mal estructurado, con todas las unidades llamándose entre si. El código es perfectamente legible, pero es difícil seguir su ejecución y por tanto predecir su comportamiento.

Esto te va a ocurrir en cualquier lenguaje, y es culpa del programador. Pero es que en C te puedes perder con dos simples líneas de código, y cuando ocurre eso, ya no es culpa del programador sino del lenguaje mismo. Personalmente yo prefiero mantenerme muy lejos de este tipo de lenguajes, puesto que me gusta disfrutar de la programación y no sufrirla.
  • 0

#34 Marc

Marc

    Advanced Member

  • Moderadores
  • PipPipPip
  • 1.484 mensajes
  • LocationMallorca

Escrito 13 febrero 2012 - 05:42

Por supuesto que C permite escribir código más difícil de leer que la mayoría de lenguajes, pero también se puede escribir código "normal" que se entiende como en cualquier otro lenguaje.
Pero ya sabemos que sobre gustos... a algunos les gusta cobol :)


Sí, pero el problema es que tu puedes controlar el código que tu escribes, pero no el que escriben tus compañeros. Por eso, para el mantenimiento de las aplicaciones en que ha trabajado más de una persona, es por lo que me gusta trabajar en Delphi.

Aunque no entiendo el empecinamiento de escafandra en no admitir que C permite escribir código más difícil de leer que la mayoría de lenguajes.
  • 0

#35 casi

casi

    Advanced Member

  • Miembro Platino
  • PipPipPip
  • 191 mensajes

Escrito 13 febrero 2012 - 05:58

Sí, pero el problema es que tu puedes controlar el código que tu escribes, pero no el que escriben tus compañeros. Por eso, para el mantenimiento de las aplicaciones en que ha trabajado más de una persona, es por lo que me gusta trabajar en Delphi.


Bueno, para ese caso nosotros tenemos unas normas para la codificación, nomenclaturas para variables, campos, etc. por lo que no se sabe quién ha escrito un código. Es normal entre nosotros la frase: "¿Quién ha escrito esto, tú o yo?", y normalmente cuando es un código de hace tiempo, no sabemos quién lo escribió.

Lo único que cambia algunas veces es la colocación del begin, que puede estar al final de la línea o al principio de la siguiente.


delphi
  1. if algo then begin
  2.   xxx
  3. end




delphi
  1. if algo then
  2. begin
  3.   xxx
  4. end



Por lo demás, todo es igual.


EDITO:
  En "general", C es más difícil de leer, si se toma un código de hace algunos años, uno escrito en el delphi y otro en C, lo normal es que el de delphi se entienda bastante mejor, sin embargo el de C hay que hacer más esfuerzo para recordar qué estábamos haciendo. 
Ahora bien, si es un código actual o reciente, no hay problema, en ninguno de los lenguajes, puesto que "lo tenemos en la cabeza".



  • 0

#36 Marc

Marc

    Advanced Member

  • Moderadores
  • PipPipPip
  • 1.484 mensajes
  • LocationMallorca

Escrito 13 febrero 2012 - 06:09

Esto no resultaría divertido, si no tuviera tantísimo de cierto.

http://www.netjeff.c...file=c.hoax.txt
  • 0

#37 escafandra

escafandra

    Advanced Member

  • Administrador
  • 4.107 mensajes
  • LocationMadrid - España

Escrito 13 febrero 2012 - 07:22

Escafandra no hagas trampas y no me juntes distintas descripciones de la palabra aberración, en una sola. Solo la segunda aceptación de la palabra se refiere a actos o conductas humanas. En cambio cuando digo que C es un lenguaje con apartados sintácticos aberrantes, me refiero claramente a la primera aceptación de esa palabra : "grave error del entendimiento" (por poner otro ejemplo, ¿ a que acto o conducta humana crees que se refiere una expresión tan común como aberración de la naturaleza ?).

No hago trampas si fuese así no hubiese puesto las dos acepciones, ¿no crees?. El termino aberrante tiene una carga peyorativa subyacente, y es por eso que critico su uso en este caso. Sólo es atribuible un error al humano, ni la naturaleza ni la máquina se equivocan. Esas expresiones a las que te refieres son el resultado de una humanización de las cosas como licencia literaria. Y en el caso del tipo de código que criticas no hay errores, solo dificultad de lectura.
 

Como te he dicho ya, en Pascal no vas a poder hacer un código ininteligible, no de esa forma.

He de decirte que el código en C que me expusiste tiene un pequeño error. Yo cambiaría


cpp
  1. #define _ -F<00||--F-OO--;

por


cpp
  1. #define _ F-->0||F-OO--;

Así funciona perfecto.

Pero si quieres algo aberrante (como tu dirías) también en delphi, entonces compila y ejecuta esto:


delphi
  1. program Pi;{$APPTYPE CONSOLE}uses SysUtils; var F: integer = 0; OO: integer = 0;
  2. procedure O; begin inc(OO); end; function _: integer; begin result:=integer(F>0);dec(F); result:=integer(result or F);result:=result-OO;end;procedure F_OO;
  3. begin
  4.             _;_;_;_;O;
  5.       _;_;_;_;_;_;_;_;_;O;
  6.     _;_;_;_;_;_;_;_;_;_;_;_;O;
  7.   _;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  8. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  9. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  10. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  11. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  12. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  13. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  14. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  15. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  16.   _;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  17.     _;_;_;_;_;_;_;_;_;_;_;_;O;
  18.         _;_;_;_;_;_;_;_;O;
  19.             _;_;_;_;O;
  20. end; begin F_OO; Write(Format('%1.3f', [4*-F/OO/OO])); ReadLn; end.

¿Acaso en delphi no se puede escribir de forma críptica?
 

Personalmente yo prefiero mantenerme muy lejos de este tipo de lenguajes, puesto que me gusta disfrutar de la programación y no sufrirla.


Estás en tu derecho.

Yo disfruto tanto con delphi como con C y el ejemplo que te he puesto es el resultado de un juego que me ha resultado bastante divertido.


Saludos.


  • 0

#38 casi

casi

    Advanced Member

  • Miembro Platino
  • PipPipPip
  • 191 mensajes

Escrito 13 febrero 2012 - 07:42

Esto no resultaría divertido, si no tuviera tantísimo de cierto.
http://www.netjeff.c...file=c.hoax.txt


Creo que eso es un "hoax" o como se diga, porque ese mismo texto, cambiando algunos nombres, datos, etc.  recuerdo haberlo visto antes, pero hablando de otro lenguaje :)


  • 0

#39 casi

casi

    Advanced Member

  • Miembro Platino
  • PipPipPip
  • 191 mensajes

Escrito 13 febrero 2012 - 08:11

Por cierto, curiosamente hoy ha aparecido esta entrada en mi google reader:
http://www.elclubdel...t=Google Reader
  • 0

#40 Marc

Marc

    Advanced Member

  • Moderadores
  • PipPipPip
  • 1.484 mensajes
  • LocationMallorca

Escrito 13 febrero 2012 - 08:20

El termino aberrante tiene una carga peyorativa subyacente, y es por eso que critico su uso en este caso.



Esto es una valoración personal tuya. El diccionario lo dice cuando una expresión es despectiva, y no es el caso de este término.

Sólo es atribuible un error al humano, ni la naturaleza ni la máquina se equivocan.



Pero este lenguaje induce al error humano dada su sintaxis potencialmente críptica.

Esas expresiones a las que te refieres son el resultado de una humanización de las cosas como licencia literaria.


Aunque tuvieras razón, que no la tienes, entonces asume que me he tomado una licencia literaria.

Y en el caso del tipo de código que criticas no hay errores, solo dificultad de lectura.


Y dicha dificultad de lectura induce al error humano ... por no olvidar que es una pesadilla mantener código del estilo.



delphi
  1. program Pi;{$APPTYPE CONSOLE}uses SysUtils; var F: integer = 0; OO: integer = 0;
  2. procedure O; begin inc(OO); end; function _: integer; begin result:=integer(F>0);dec(F); result:=integer(result or F);result:=result-OO;end;procedure F_OO;
  3. begin
  4.             _;_;_;_;O;
  5.        _;_;_;_;_;_;_;_;_;O;
  6.     _;_;_;_;_;_;_;_;_;_;_;_;O;
  7.   _;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  8.  _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  9.  _;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  10. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  11. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  12. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  13. _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  14.  _;_;_;_;_;_;_;_;_;_;_;_;_;_;_; O;
  15.  _;_;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  16.   _;_;_;_;_;_;_;_;_;_;_;_;_;_;O;
  17.     _;_;_;_;_;_;_;_;_;_;_;_;O;
  18.         _;_;_;_;_;_;_;_;O;
  19.             _;_;_;_;O;
  20. end; begin F_OO; Write(Format('%1.3f', [4*-F/OO/OO])); ReadLn; end.


¿Acaso en delphi no se puede escribir de forma críptica?


No, para nada. Ese código no es críptico, solo lo puede parecer a muy simple vista. Este código, bien identado, corresponde exactamente a :



delphi
  1. program Pi;
  2. {$APPTYPE CONSOLE}
  3.  
  4. uses SysUtils;
  5.  
  6. var F: integer = 0;
  7.     OO: integer = 0;
  8.  
  9. procedure O;
  10. begin
  11.   inc(OO);
  12. end;
  13.  
  14. function _: integer;
  15. begin
  16.   result := integer(F > 0);
  17.   dec(F);
  18.   result := integer(result or F);
  19.   result := result - OO;
  20. end;
  21.  
  22. procedure F_OO;
  23. begin
  24.   _;
  25.   _;
  26.   _;
  27.   _;
  28.   O;
  29.   _;
  30.   _;
  31.   _;
  32.   _;
  33.   _;
  34.   _;
  35.   _;
  36.   _;
  37.   _;
  38.   O;
  39.   _;
  40.   _;
  41.   _;
  42.   _;
  43.   _;
  44.   _;
  45.   _;
  46.   _;
  47.   _;
  48.   _;
  49.   _;
  50.   _;
  51.   O;
  52.   _;
  53.   _;
  54.   _;
  55.   _;
  56.   _;
  57.   _;
  58.   _;
  59.   _;
  60.   _;
  61.   _;
  62.   _;
  63.   _;
  64.   _;
  65.   _;
  66.   O;
  67.   _;
  68.   _;
  69.   _;
  70.   _;
  71.   _;
  72.   _;
  73.   _;
  74.   _;
  75.   _;
  76.   _;
  77.   _;
  78.   _;
  79.   _;
  80.   _;
  81.   _;
  82.   O;
  83.   _;
  84.   _;
  85.   _;
  86.   _;
  87.   _;
  88.   _;
  89.   _;
  90.   _;
  91.   _;
  92.   _;
  93.   _;
  94.   _;
  95.   _;
  96.   _;
  97.   _;
  98.   O;
  99.   _;
  100.   _;
  101.   _;
  102.   _;
  103.   _;
  104.   _;
  105.   _;
  106.   _;
  107.   _;
  108.   _;
  109.   _;
  110.   _;
  111.   _;
  112.   _;
  113.   _;
  114.   _;
  115.   O;
  116.   _;
  117.   _;
  118.   _;
  119.   _;
  120.   _;
  121.   _;
  122.   _;
  123.   _;
  124.   _;
  125.   _;
  126.   _;
  127.   _;
  128.   _;
  129.   _;
  130.   _;
  131.   _;
  132.   O;
  133.   _;
  134.   _;
  135.   _;
  136.   _;
  137.   _;
  138.   _;
  139.   _;
  140.   _;
  141.   _;
  142.   _;
  143.   _;
  144.   _;
  145.   _;
  146.   _;
  147.   _;
  148.   _;
  149.   O;
  150.   _;
  151.   _;
  152.   _;
  153.   _;
  154.   _;
  155.   _;
  156.   _;
  157.   _;
  158.   _;
  159.   _;
  160.   _;
  161.   _;
  162.   _;
  163.   _;
  164.   _;
  165.   _;
  166.   O;
  167.   _;
  168.   _;
  169.   _;
  170.   _;
  171.   _;
  172.   _;
  173.   _;
  174.   _;
  175.   _;
  176.   _;
  177.   _;
  178.   _;
  179.   _;
  180.   _;
  181.   _;
  182.   O;
  183.   _;
  184.   _;
  185.   _;
  186.   _;
  187.   _;
  188.   _;
  189.   _;
  190.   _;
  191.   _;
  192.   _;
  193.   _;
  194.   _;
  195.   _;
  196.   _;
  197.   _;
  198.   O;
  199.   _;
  200.   _;
  201.   _;
  202.   _;
  203.   _;
  204.   _;
  205.   _;
  206.   _;
  207.   _;
  208.   _;
  209.   _;
  210.   _;
  211.   _;
  212.   _;
  213.   O;
  214.   _;
  215.   _;
  216.   _;
  217.   _;
  218.   _;
  219.   _;
  220.   _;
  221.   _;
  222.   _;
  223.   _;
  224.   _;
  225.   _;
  226.   O;
  227.   _;
  228.   _;
  229.   _;
  230.   _;
  231.   _;
  232.   _;
  233.   _;
  234.   _;
  235.   O;
  236.   _;
  237.   _;
  238.   _;
  239.   _;
  240.   O;
  241. end;
  242.  
  243. begin
  244.   F_OO;
  245.   Write(Format('%1.3f', [4 * -F / OO / OO]));
  246.   ReadLn;
  247. end.



Ahora ya solo tienes que poner unos identificadores que signifiquen algo, cambiando "_" por algo como "InteriorCirculo" y "O" por "SaltarLinea", ... y te queda un código perfectamente legible, de este estilo, que hace exactamente lo mismo :



delphi
  1. program Pi;
  2. {$APPTYPE CONSOLE}
  3.  
  4. uses SysUtils;
  5.  
  6. var Area: integer = 0;
  7.     NumLineas: integer = 0;
  8.  
  9. procedure SaltarLinea;
  10. begin
  11.   inc(NumLineas);
  12. end;
  13.  
  14. Function InteriorCirculo: integer;
  15. begin
  16.   result := integer(Area > 0);
  17.   dec(Area);
  18.   result := integer(result or Area);
  19.   result := result - NumLineas;
  20. end;
  21.  
  22. procedure CalcularArea;
  23. begin
  24.   InteriorCirculo;
  25.   InteriorCirculo;
  26.   InteriorCirculo;
  27.   InteriorCirculo;
  28.   SaltarLinea;
  29.   InteriorCirculo;
  30.   InteriorCirculo;
  31.   InteriorCirculo;
  32.   InteriorCirculo;
  33.   InteriorCirculo;
  34.   InteriorCirculo;
  35.   InteriorCirculo;
  36.   InteriorCirculo;
  37.   InteriorCirculo;
  38.   SaltarLinea;
  39.   InteriorCirculo;
  40.   InteriorCirculo;
  41.   InteriorCirculo;
  42.   InteriorCirculo;
  43.   InteriorCirculo;
  44.   InteriorCirculo;
  45.   InteriorCirculo;
  46.   InteriorCirculo;
  47.   InteriorCirculo;
  48.   InteriorCirculo;
  49.   InteriorCirculo;
  50.   InteriorCirculo;
  51.   SaltarLinea;
  52.   InteriorCirculo;
  53.   InteriorCirculo;
  54.   InteriorCirculo;
  55.   InteriorCirculo;
  56.   InteriorCirculo;
  57.   InteriorCirculo;
  58.   InteriorCirculo;
  59.   InteriorCirculo;
  60.   InteriorCirculo;
  61.   InteriorCirculo;
  62.   InteriorCirculo;
  63.   InteriorCirculo;
  64.   InteriorCirculo;
  65.   InteriorCirculo;
  66.   SaltarLinea;
  67.   InteriorCirculo;
  68.   InteriorCirculo;
  69.   InteriorCirculo;
  70.   InteriorCirculo;
  71.   InteriorCirculo;
  72.   InteriorCirculo;
  73.   InteriorCirculo;
  74.   InteriorCirculo;
  75.   InteriorCirculo;
  76.   InteriorCirculo;
  77.   InteriorCirculo;
  78.   InteriorCirculo;
  79.   InteriorCirculo;
  80.   InteriorCirculo;
  81.   InteriorCirculo;
  82.   SaltarLinea;
  83.   InteriorCirculo;
  84.   InteriorCirculo;
  85.   InteriorCirculo;
  86.   InteriorCirculo;
  87.   InteriorCirculo;
  88.   InteriorCirculo;
  89.   InteriorCirculo;
  90.   InteriorCirculo;
  91.   InteriorCirculo;
  92.   InteriorCirculo;
  93.   InteriorCirculo;
  94.   InteriorCirculo;
  95.   InteriorCirculo;
  96.   InteriorCirculo;
  97.   InteriorCirculo;
  98.   SaltarLinea;
  99.   InteriorCirculo;
  100.   InteriorCirculo;
  101.   InteriorCirculo;
  102.   InteriorCirculo;
  103.   InteriorCirculo;
  104.   InteriorCirculo;
  105.   InteriorCirculo;
  106.   InteriorCirculo;
  107.   InteriorCirculo;
  108.   InteriorCirculo;
  109.   InteriorCirculo;
  110.   InteriorCirculo;
  111.   InteriorCirculo;
  112.   InteriorCirculo;
  113.   InteriorCirculo;
  114.   InteriorCirculo;
  115.   SaltarLinea;
  116.   InteriorCirculo;
  117.   InteriorCirculo;
  118.   InteriorCirculo;
  119.   InteriorCirculo;
  120.   InteriorCirculo;
  121.   InteriorCirculo;
  122.   InteriorCirculo;
  123.   InteriorCirculo;
  124.   InteriorCirculo;
  125.   InteriorCirculo;
  126.   InteriorCirculo;
  127.   InteriorCirculo;
  128.   InteriorCirculo;
  129.   InteriorCirculo;
  130.   InteriorCirculo;
  131.   InteriorCirculo;
  132.   SaltarLinea;
  133.   InteriorCirculo;
  134.   InteriorCirculo;
  135.   InteriorCirculo;
  136.   InteriorCirculo;
  137.   InteriorCirculo;
  138.   InteriorCirculo;
  139.   InteriorCirculo;
  140.   InteriorCirculo;
  141.   InteriorCirculo;
  142.   InteriorCirculo;
  143.   InteriorCirculo;
  144.   InteriorCirculo;
  145.   InteriorCirculo;
  146.   InteriorCirculo;
  147.   InteriorCirculo;
  148.   InteriorCirculo;
  149.   SaltarLinea;
  150.   InteriorCirculo;
  151.   InteriorCirculo;
  152.   InteriorCirculo;
  153.   InteriorCirculo;
  154.   InteriorCirculo;
  155.   InteriorCirculo;
  156.   InteriorCirculo;
  157.   InteriorCirculo;
  158.   InteriorCirculo;
  159.   InteriorCirculo;
  160.   InteriorCirculo;
  161.   InteriorCirculo;
  162.   InteriorCirculo;
  163.   InteriorCirculo;
  164.   InteriorCirculo;
  165.   InteriorCirculo;
  166.   SaltarLinea;
  167.   InteriorCirculo;
  168.   InteriorCirculo;
  169.   InteriorCirculo;
  170.   InteriorCirculo;
  171.   InteriorCirculo;
  172.   InteriorCirculo;
  173.   InteriorCirculo;
  174.   InteriorCirculo;
  175.   InteriorCirculo;
  176.   InteriorCirculo;
  177.   InteriorCirculo;
  178.   InteriorCirculo;
  179.   InteriorCirculo;
  180.   InteriorCirculo;
  181.   InteriorCirculo;
  182.   SaltarLinea;
  183.   InteriorCirculo;
  184.   InteriorCirculo;
  185.   InteriorCirculo;
  186.   InteriorCirculo;
  187.   InteriorCirculo;
  188.   InteriorCirculo;
  189.   InteriorCirculo;
  190.   InteriorCirculo;
  191.   InteriorCirculo;
  192.   InteriorCirculo;
  193.   InteriorCirculo;
  194.   InteriorCirculo;
  195.   InteriorCirculo;
  196.   InteriorCirculo;
  197.   InteriorCirculo;
  198.   SaltarLinea;
  199.   InteriorCirculo;
  200.   InteriorCirculo;
  201.   InteriorCirculo;
  202.   InteriorCirculo;
  203.   InteriorCirculo;
  204.   InteriorCirculo;
  205.   InteriorCirculo;
  206.   InteriorCirculo;
  207.   InteriorCirculo;
  208.   InteriorCirculo;
  209.   InteriorCirculo;
  210.   InteriorCirculo;
  211.   InteriorCirculo;
  212.   InteriorCirculo;
  213.   SaltarLinea;
  214.   InteriorCirculo;
  215.   InteriorCirculo;
  216.   InteriorCirculo;
  217.   InteriorCirculo;
  218.   InteriorCirculo;
  219.   InteriorCirculo;
  220.   InteriorCirculo;
  221.   InteriorCirculo;
  222.   InteriorCirculo;
  223.   InteriorCirculo;
  224.   InteriorCirculo;
  225.   InteriorCirculo;
  226.   SaltarLinea;
  227.   InteriorCirculo;
  228.   InteriorCirculo;
  229.   InteriorCirculo;
  230.   InteriorCirculo;
  231.   InteriorCirculo;
  232.   InteriorCirculo;
  233.   InteriorCirculo;
  234.   InteriorCirculo;
  235.   SaltarLinea;
  236.   InteriorCirculo;
  237.   InteriorCirculo;
  238.   InteriorCirculo;
  239.   InteriorCirculo;
  240.   SaltarLinea;
  241. end;
  242.  
  243. begin
  244.   CalcularArea;
  245.   Write(Format('%1.3f', [4 * -Area / NumLineas / NumLineas]));
  246.   ReadLn;
  247. end.



Toda la ofuscación que han podido hacer en Delphi es saltarse la identación, juntando líneas, y poner nombres de identificadores abstractos.

En cambio el código C equivalente es mucho peor de comprender, porqué su problema está en las perrerías que hace (porqué el lenguaje le deja) con expresiones del tipo : -F<00||--F-OO--


  • 0
Volver a Encuestas


  1. Comunidad Delphiaccess
  2. → COMUNIDAD
  3. → Encuestas
  4. Privacy Policy
IP.Board spam blocked by CleanTalk.