what valuable useful the programming programing most learn languages language demand best programming-languages language-agnostic

programming languages - valuable - ¿Cuáles son las cinco cosas que odias de tu idioma favorito?



programming languages in demand (30)

Perl

  • Uso mixto de sigilos.

    my @array = ( 1, 2, 3 ); my $array = [ 4, 5, 6 ]; my $one = $array[0]; # not @array[0], you would get the length instead my $four = $array->[0]; # definitely not $array[0] my( $two, $three ) = @array[1,2]; my( $five, $six ) = @$array[1,2]; # coerce to array first my $length_a = @array; my $length_s = @$array; my $ref_a = /@array; my $ref_s = $array;

    • Por ejemplo, ninguno de estos son los mismos:

      $array[0] # First element of @array @array[0] # Slice of only the First element of @array %array[0] # Syntax error $array->[0] # First element of an array referenced by $array @array->[0] # Deprecated first element of @array %array->[0] # Invalid reference $array{0} # Element of %array referenced by string ''0'' @array{0} # Slice of only one element of %array referenced by string ''0'' %array{0} # Syntax error $array->{0} # Element of a hash referenced by $array @array->{0} # Invalid reference %array->{0} # Deprecated Element of %array referenced by string ''0''

    En Perl6 está written :

    my @array = ( 1, 2, 3 ); my $array = [ 4, 5, 6 ]; my $one = @array[0]; my $four = $array[0]; # $array.[0] my( $two, $three ) = @array[1,2]; my( $five, $six ) = $array[1,2]; my $length_a = @array.length; my $length_s = $array.length; my $ref_a = @array; my $ref_s = $array;

  • Falta de verdadero OO

    package my_object; # fake constructor sub new{ bless {}, $_[0] } # fake properties/attributes sub var_a{ my $self = shift @_; $self->{''var_a''} = $_[0] if @_; $self->{''var_a''} }

    En Perl6 está written :

    class Dog is Mammal { has $.name = "fido"; has $.tail is rw; has @.legs; has $!brain; method doit ($a, $b, $c) { ... } ... }

  • Características de expresiones regulares mal diseñadas

    /(?=regexp)/; # look ahead /(?<=fixed-regexp)/; # look behind /(?!regexp)/; # negative look ahead /(?<!fixed-regexp)/; # negative look behind /(?>regexp)/; # independent sub expression /(capture)/; # simple capture /(?:don''t capture)/; # non-capturing group /(?<name>regexp)/; # named capture /[A-Z]/; # character class /[^A-Z]/; # inverted character class # ''-'' would have to be the first or last element in # the character class to include it in the match # without escaping it /(?(condition)yes-regexp)/; /(?(condition)yes-regexp|no-regexp)/; //b/s*/b/; # almost matches Perl6''s <ws> /(?{ print "hi/n" })/; # run perl code

    En Perl6 está written :

    / <?before pattern> /; # lookahead / <?after pattern> /; # lookbehind / regexp :: pattern /; # backtracking control / ( capture ) /; # simple capture / $<name>=[ regexp ] /; # named capture / [ don''t capture ] /; # non-capturing group / <[A..Z]> /; # character class / <-[A..Z]> /; # inverted character class # you don''t generally use ''.'' in a character class anyway / <ws> /; # Smart whitespace match / { say ''hi'' } /; # run perl code

  • Falta de despacho múltiple

    sub f( int $i ){ ... } # err sub f( float $i ){ ... } # err sub f($){ ... } # occasionally useful

    En Perl6 está written :

    multi sub f( int $i ){ ... } multi sub f( num $i ){ ... } multi sub f( $i where $i == 0 ){ ... } multi sub f( $i ){ ... } # everything else

  • Mala sobrecarga del operador

    package my_object; use overload ''+'' => /&add, ... ;

    En Perl6 está written :

    multi sub infix:<+> (Us $us, Them $them) | (Them $them, Us $us) { ... }

Últimamente ha habido un grupo de Perl-hate en Stack Overflow, así que pensé en llevar mi pregunta " Cinco cosas que odias sobre tu lenguaje favorito " a Stack Overflow. Toma tu lenguaje favorito y dime cinco cosas que odias al respecto. Esas pueden ser cosas que simplemente lo molestan, los defectos de diseño admitidos, los problemas de rendimiento reconocidos o cualquier otra categoría. Solo tienes que odiarlo, y tiene que ser tu idioma favorito.

No lo compare con otro idioma, y ​​no hable sobre idiomas que ya odia. No hables de las cosas que te gustan en tu idioma favorito. Solo quiero escuchar las cosas que odias pero las toleras para que puedas usar todas las demás cosas, y quiero escuchar sobre el lenguaje que desearías que otras personas usaran.

Le pregunto esto cada vez que alguien trata de darme su lenguaje favorito y, a veces, como una pregunta de entrevista. Si alguien no puede encontrar cinco cosas que odiar de su herramienta favorita, no lo sabe lo suficiente como para abogar por ella o sacar los grandes dólares usándola. Él no lo ha usado en suficientes situaciones diferentes para explorarlo completamente. Lo defiende como una cultura o religión, lo que significa que si no elijo su tecnología favorita, me equivoco.

No me importa mucho qué idioma usas. ¿No quieres usar un idioma en particular? Entonces no lo hagas ¿Pasas por la diligencia debida para tomar una decisión informada y aún no la usas? Multa. A veces, la respuesta correcta es "Tienes un equipo de programación fuerte con buenas prácticas y mucha experiencia en Bar. Cambiar a Foo sería una estupidez".

Esta es una buena pregunta para revisiones de código también. Las personas que realmente conocen una base de código tendrán todo tipo de sugerencias, y quienes no la conozcan tan bien tendrán quejas inespecíficas. Le pregunto cosas como "Si pudieras volver a empezar en este proyecto, ¿qué harías de manera diferente?" En esta tierra de fantasía, los usuarios y los programadores se quejan de cualquier cosa y de todo lo que no les gusta. "Quiero una mejor interfaz", "Quiero separar el modelo de la vista", "Usaré este módulo en lugar de este otro", "Cambiaré el nombre de este conjunto de métodos", o lo que sea que realmente no usen No me gusta de la situación actual. Así es como entiendo cuánto sabe un desarrollador en particular sobre el código base. También es una pista sobre cuánto del ego del programador está relacionado con lo que me está diciendo.

El odio no es la única dimensión de averiguar cuánto sabe la gente, pero me parece que es bastante buena. Las cosas que odian también me dan una idea de lo bien que están pensando en el tema.

¿Qué hay de las cinco cosas que odio de las listas de "Cosas que odio de un lenguaje"? :RE

5- Pintar una naranja roja no la convierte en una manzana.

Cuando se diseña un lenguaje, los diseñadores suelen tener en cuenta para qué sirve. Usarlo para algo completamente diferente puede funcionar, pero quejarse cuando no es así es simplemente tonto. Toma Python. Estoy seguro de que alguien tiene o alguien hará algún día una utilidad para crear exe a partir del código de Python. ¿Por qué demonios querrías hacer eso? Estaría limpio, no me malinterpretes, pero no sirve de nada. Así que deja de quejarte de ello!

Un proyecto bien diseñado probablemente contenga código de varios idiomas. No quiere decir que no pueda completar un proyecto con un solo idioma. Algunos proyectos pueden estar bien dentro de las habilidades de cualquier idioma que esté utilizando.

4- ¿Estás de pie sobre las piernas de madera?

La plataforma puede ser una gran influencia de lo que puede hacer el lenguaje. Con los recolectores de basura de hoy en día, o incluso los primeros intentos de "recolección de basura" de los pascales, pueden ayudar a que la memoria se desvanezca (¿tal vez malloc más ram ??). Las computadoras son más rápidas y, por supuesto, esperamos más de nuestros idiomas. Y francamente, probablemente deberíamos. Sin embargo, hay un gran precio que pagar por la conveniencia del compilador para crear tablas hash o cadenas o una variedad de otros conceptos. Estas cosas pueden no ser heredadas a la plataforma de la que se utilizan. Decir que son fáciles de incluir en un idioma simplemente me dice que es posible que no tenga una pierna en la que apoyarse.

3- ¿Quién tiene la culpa es realmente?

Loco. Ya sabes. Me encantan los bichos. ¿Por qué me encantan los bichos? Porque significa que me quedo con mi trabajo. Sin bichos, habría muchas pizzerías cerradas. Sin embargo, los usuarios odian los errores. Pero aquí hay un poco de agua fría. Cada error es culpa de los programadores. No de la lengua. Un lenguaje con una sintaxis tan estricta que reduciría significativamente la cantidad de errores posibles de generar sería un lenguaje completamente inútil. Sus habilidades probablemente podrían ser contadas con una mano. ¿Quieres flexibilidad o poder? Tienes bichos. ¿Por qué? Porque no eres perfecto, y cometes errores. Tomemos un ejemplo realmente identificable en C:

int a[10]; for (int idx = 0; idx < 15; idx++) a[idx] = 10;

Todos sabemos lo que va a hacer. Sin embargo, lo que tal vez algunos de nosotros no nos damos cuenta es que la funcionalidad puede ser muy beneficiosa. Dependiendo de lo que estés haciendo. El exceso de búfer es el costo de esa funcionalidad. Ese código de arriba. Si de hecho lo lancé al público. Eso es otra vez .. dilo conmigo .. "Mi culpa". No C por permitirme hacerlo.

2- ¿No deberíamos poner eso en la papelera de reciclaje?

Es muy fácil señalar una característica en un idioma que no entendemos porque no lo usamos a menudo y lo llamamos estúpido. Reclama que está ahí, etc. Goto siempre me entretiene. La gente siempre se queja de que Goto está en un idioma. Sin embargo, apuesto a que su último programa incluía un tipo de goto. Si alguna vez has usado un descanso o una continuación, has usado un goto. Eso es lo que es. Por supuesto, es un goto "seguro", pero es lo que es. Goto tiene sus usos. Si se utilizan gotos "implícitos" como continuar o romper, o gotos explícitos (usando la palabra clave real "goto" para cualquier idioma). No es que los desarrolladores de lenguajes sean impecables, pero típicamente ... si la funcionalidad ha existido desde el principio de los tiempos (para ese idioma). Probablemente ese aspecto sea una cualidad definitoria de ese lenguaje. Lo que significa que se está utilizando y es probable que no esté dando vueltas debido a la compatibilidad con versiones anteriores. Se está utilizando hoy. Como hace 5 minutos. Y se utiliza correctamente. Bueno ... podría decirse que alguien lo está usando incorrectamente también, pero eso se relaciona con el # 3 en mi lista.

1.- Todo es un objeto.

Ok ... este es realmente un subconjunto de # 2. Pero esta es, con mucho, la queja más molesta que veo en las listas de odio. No todo es un objeto. Hay una gran cantidad de conceptos que no pertenecen o necesitan ser objetos. Poner las cosas donde no pertenecen es solo feo y puede disminuir la eficiencia de un programa. Por supuesto. Tal vez no mucho dependiendo del idioma. Esto también se relaciona con # 5. Esto significa ... sí. Global están bien. Las funciones que se aplican a los métodos estáticos están bien. Combinar la programación OO con funciones globales está bien. Ahora ... eso no significa que todos debamos salir y "liberar" nuestro código de sus modelos de objetos tampoco. Al diseñar una sección de código o un proyecto completo, lo que sucede detrás de la escena se debe considerar al armarlo. No solo donde vive ese concepto y muchos otros factores. ¿Por qué envolver funciones globales dentro de clases o conceptos de espacio de nombres si no sirve para nada? Tomar variables miembro estáticas. Eso me divierte mucho porque ... bueno ... Dependiendo del lenguaje y la implementación, por supuesto, pero en general, acaba de declararse global. Sí, hay algunas razones para envolver estos conceptos que no son OO en envoltorios OO. Uno de ellos, por supuesto, siendo el código auto documentado Eso puede tener sentido. Así que ... como digo. No salgas y "liberas" tu código. Pero cualquier buen lenguaje moderno tendrá un concepto global fuera de su modelado OO. Sí, tengo la intención específica de señalar que un lenguaje de programación OO sin un concepto global probablemente tenga un defecto de diseño serio. Sin embargo, una vez más, depende de la intención y el diseño del lenguaje, así que no estoy tratando de elegir un idioma específico y hay demasiados para analizar aquí. En cualquier caso, considere dónde debe vivir el código y ser el más efectivo. Agregar un montón de destello a algo que no agrega funcionalidad o soporte simplemente desgasta el teclado más rápido. No hace ningún bien a nadie. Bueno ... a menos que te gusten los puntos brownie de la persona que probablemente te enseñó incorrectamente que todo es un objeto.

En resumen, la programación no es solo tocar el teclado sin pensar. Hay muchas consideraciones de diseño para cualquier proyecto. Sé que es un cliché, pero hay que mirarlo desde todos los ángulos. Incluso con los idiomas de hoy en día de tipo seguro. No solo quitas el código y esperas que funcione bien. Claro ... puede funcionar, pero puede que no sea la forma correcta de hacerlo. En general, elija el idioma y el formato que mejor se adapte a su trabajo específico Y al medio ambiente. Pero ningún lenguaje quita el pensamiento detrás de eso. Si no estás pensando ... estás escribiendo.

Aquí hay algunas cosas que no me gustan de Java (que no es mi idioma favorito):

  • Genérico tipo de borrado (es decir, no genéricos reificados)
  • Incapacidad para capturar múltiples excepciones (de diferentes tipos) en un solo bloque catch
  • La falta de destructores (finalizar () es un sustituto muy pobre)
  • No hay soporte para cierres o tratamiento de funciones como datos (las clases internas anónimas son un sustituto muy detallado)
  • Excepciones comprobadas en general, o más específicamente, haciendo que se revisen las excepciones no recuperables (por ejemplo, SQLException)
  • No hay soporte a nivel de idioma para colecciones literales
  • No hay inferencia de tipo cuando se llaman constructores de clases genéricas, es decir, los parámetros de tipo deben repetirse en ambos lados de ''=''

C # / .NET:

  • Las clases deben estar selladas por defecto
  • No debería haber una declaración de lock ; en su lugar, debería tener objetos de bloqueo específicos, y debería haber métodos como Acquire cuáles devuelven tokens de bloqueo desechables. Corolario: no debería haber un monitor para cada objeto.
  • GetHashCode() y Equals() no deberían estar en System.Object , no todo es adecuado para el hash. En su lugar, tenga un IdentityComparer que haga lo mismo y mantenga las IComparer<T> , IComparable<T> , IEqualityComparer<T> e IEquatable<T> para realizar comparaciones personalizadas.
  • Mal apoyo para la inmutabilidad.
  • Mala forma de descubrir métodos de extensión: debería ser una decisión mucho más consciente que solo el hecho de que estoy usando un espacio de nombres.

Estaban fuera de mi cabeza. Pregúntame mañana y obtendré un 5 diferente :)

C ++

  • Es demasiado fácil corromper aleatoriamente la memoria y crear errores casi imposibles de encontrar (aunque, Valgrind va muy lejos para solucionar este problema).
  • Plantilla de mensajes de error.
  • Cuando se usan plantillas, es fácil terminar teniendo que incluir todo en un archivo y luego obtener tiempos de compilación estúpidos.
  • La biblioteca estándar es una broma en la era moderna (¿aún no hay hilos o redes por defecto?)
  • Un montón de pequeños trozos desagradables de C asomando (en particular, todas las conversiones entre short / int / unsigned / etc ..)

Cinco cosas que odio de Java (que actualmente es mi idioma favorito) en ningún orden en particular.

  1. Por mucho que sea un fanático de Java Generics, hay muchas rarezas que surgen de la forma en que fue diseñado. Como tal, existe una miríada de limitaciones molestas con los genéricos (algunos de los cuales son el resultado del borrado de tipo).
  2. La forma en que funcionan Object.clone () y las interfaces clonables está totalmente dañada.
  3. En lugar de tomar la ruta principal y convertir todo en un objeto (a.la. SmallTalk), Sun wimped creó dos categorías distintas de tipos de datos: Objetos y primitivos. Como resultado, ahora hay dos representaciones para tipos de datos fundamentales y curiosidades extrañas, como el boxeo / unboxing y no poder colocar primitivos en una colección.
  4. El swing es demasiado complejo. No me malinterpretes: hay muchas cosas geniales que uno puede hacer con Swing, pero es un gran ejemplo de ingeniería excesiva.
  5. Esta queja final es igualmente culpa de Sun y de quienes han escrito bibliotecas XML para Java. Las bibliotecas XML de Java son demasiado complicadas. Para leer simplemente en un archivo XML, a menudo tengo que preocuparme sobre qué analizador estoy usando: ¿DOM o SAX? Las API para cada uno son igualmente confusas. El soporte nativo en el lenguaje para fácilmente analizar / escribir XML sería muy bueno.
  6. java.util.Date apesta. No solo es innecesariamente complicado, sino que todos los métodos útiles han sido desaprobados (y reemplazados por otros que aumentan la complejidad).

Cinco cosas que odio de Java:

  • No hay funciones de primera clase.
  • No hay inferencia de tipo.
  • Falta de valores predeterminados sanos en, por ejemplo, gráficos.
  • NullPointerException no contiene más información sobre lo que es nulo.
  • La proliferación de marcos sin valor "configurables" / interfaces de proveedores de servicios / clases de fábrica / sistemas de inyección de dependencia. La capacidad de configuración casi nunca se usa, DRY se viola de manera grave, y el código se cuadruplica en tamaño y la mitad en legibilidad.

Lo sé, debería echarle un vistazo a Scala.

Haré PHP como me gusta a veces y Python se hará demasiado.

  • Sin espacio de nombres; todo está en una especie de espacio de nombres muy grande que es el infierno en entornos más grandes

  • Falta de estándares cuando se trata de funciones: las funciones de matriz toman una aguja como primer argumento, haystack como segundo (ver array_search ). Las funciones de cuerdas a menudo toman el pajar primero, luego la aguja (vea strpos ). Otras funciones solo usan diferentes esquemas de nombres: bin2hex , strtolower , cal_to_jd

    Algunas funciones tienen valores de retorno extraños, fuera de lo normal: esto obliga a tener una tercera variable declarada de la nada, mientras que PHP podría interpretar eficientemente una matriz vacía como falsa con su tipo de malabarismo. No hay cerca de otras funciones haciendo lo mismo.

    $var = preg_match_all(''/regexp/'', $str, $ret); echo $var; //outputs the number of matches print_r($ret); //outputs the matches as an array

  • El lenguaje (hasta que PHP6) hace todo lo posible para respetar una compatibilidad hacia atrás casi retardada, lo que hace que lleve las malas prácticas y las funciones cuando no es necesario (consulte mysql_escape_string vs. mysql_real_escape_string ).

  • El lenguaje evolucionó de un lenguaje de plantillas a uno completo. Esto significa que cualquiera puede emitir cualquier cosa cuando lo desee, y se abusa de ello. Terminas con los motores de plantillas para un lenguaje de plantillas ...

  • Apesta a la importación de archivos. Tiene 4 formas diferentes de hacerlo (include, include_once, require, require_once), todas son lentas, muy lentas. De hecho todo el lenguaje es lento. Al menos, bastante más lento que python (incluso con un marco) y RoR de lo que recopilo.

Aunque todavía me gusta PHP. Es la motosierra del desarrollo web: ¿desea que un sitio pequeño a mediano se realice realmente rápido y asegúrese de que cualquiera pueda hospedarlo (aunque las configuraciones pueden diferir)? PHP está justo ahí, y es tan ubicuo que solo lleva 5 minutos instalar una pila LAMP o WAMP completa. Bueno, voy a volver a trabajar con Python ahora ...

PHP:

1) Me obliga a hacer variables innecesarias:

$parts = explode(''|'', $string); $first = $parts[0];

2) Una implementación de lambdas tan poco convincente es más o menos equivalente a usar eval() y, por tanto, horriblemente mal, nunca la he usado (consulte http://www.php.net/create_function ).

3) Un sistema try / catch que solo puede capturar alrededor del 80% de los errores que pueden ocurrir.

4) El soporte Regex es tan pobre como el soporte Lambda porque tiene que estar escrito dentro de cadenas regulares, lo que hace que una de las herramientas de programación más difíciles de aprender sea tres veces más difícil. Y se supone que PHP es un lenguaje "fácil"?!?!?

5) No hay forma de sacar cosas de $ _POST de forma segura sin escribirlas dos veces o crear su propia función, o usar el operador ''@'':

$x = isset($_POST[''foo''][''bar'']) ? $_POST[''foo''][''bar''] : null;

6) Respuesta de bonificación: ''@''. Si no puede ser molestado escribiendo su código correctamente, simplemente agregue ''@'', y es muy malo para cualquier persona que tenga que depurar su código más tarde.

Wow, me sorprende que SQL aún no haya llegado hasta aquí. Supongo que eso significa que nadie lo ama :)

  • Sintaxis inconsistente a través de implementaciones
  • Las diferencias de código sutiles pueden tener ramificaciones de rendimiento masivas por razones aparentemente oscuras
  • Pobre soporte para la manipulación de textos.
  • Fácil costo de entrada, pero una curva de aprendizaje empinada hacia el dominio del idioma
  • Mínima estandarización en la comunidad para las mejores prácticas, esto incluye el estilo de sintaxis.

... Y algunas razones adicionales para odiarlo, sin cargo adicional

  • La cláusula WHERE va en último lugar, lo que facilita la ejecución prematura de una ACTUALIZACIÓN o SUPRIMIR, destruyendo toda la tabla. En cambio, el DÓNDE debe ir a algún lugar por delante.
  • Es difícil implementar la división relacional.
  • Puedo establecer un valor en NULL, pero no puedo probar su igualdad con NULL. Puedo verificar IS NULL, pero eso solo complica el código, innecesariamente, en mi opinión.
  • ¿Por qué necesitamos volver a especificar completamente la fórmula para una columna agrupada, en lugar de establecer un alias en la columna y luego agrupar por el alias (o índice de columna como en SORT)?

do

  • Manipulación de cuerdas.

Tener que lidiar manualmente con los búferes de cadena es un dolor propenso a errores. Dado que tanta computación es realmente conmovedora y que modifica cadenas (las computadoras no se usan tanto para cosas con grandes cálculos numéricos como la gente pensaba que estarían muy atrás), es realmente agradable poder usar lenguajes administrados o la cadena de C ++. Objetos para tratar con estos. Cuando tengo que hacerlo en línea recta, se siente como nadar en arenas movedizas.

BrainF * ck

  • Lo más destacado es que estás completo de Turing ? ¡Puedo hacer más en expresiones regulares de Perl!

  • Falta de objetos. ¡Vamos gente! Es como, hola ...

  • No hay bibliotecas de redes. Todo lo que quiero es raspar una página web, GOSH.

  • No hay funciones de primera clase. Enhorabuena: puedes compadecer a tus amigos de Java.

  • Una cinta infinita para el almacenamiento y nada más. Esto es tan pretencioso que podríamos estar escribiendo Lisp.

C ++

  1. Sintaxis de plantillas
  2. Problemas de herencia de diamante
  3. La plétora / falta de bibliotecas estándar que tienen los idiomas modernos (aunque el impulso se acerca).
  4. IOStreams
  5. La sintaxis utilizada alrededor de IOStreams

Pitón

  1. Los espacios son significativos (a veces)
  2. palabras clave subrayadas
  3. Soporte limitado de hilos (al menos actualmente)
  4. "yo" en lugar de "esto"
  5. Los espacios son significativos (a veces)

C objetivo

1) No hay espacios de nombres, solo convenciones de nomenclatura manuales: no me importa en términos de separación de clases, pero no puedo importar todas las definiciones de clase en un espacio de nombres en una sola línea (como import com.me.somelibrary). *).

2) Las bibliotecas aún tienen algunos agujeros en áreas importantes como el soporte de RegEx.

3) La sintaxis de propiedad es un poco torpe, requiere tres líneas (en dos archivos separados) para declarar una propiedad.

4) Me gusta el modelo de retención / liberación, pero es más fácil de lo que debería ser lanzar una referencia y luego usarla accidentalmente más tarde.

5) Aunque no es realmente una característica del lenguaje, Xcode está tan interrelacionado con el uso de Objective-C. No puedo dejar de pensar en ese aspecto ... básicamente el autocompletado, es muy dudoso. Es más como un sistema que le recompensa por encontrar algo que desea que exista, y luego lo presenta como una opción después. Pero entonces supongo que nunca me han gustado los motores autocompletados.

DO#

  • Desearía poder switch()en cualquier tipo, y esa casepodría ser cualquier expresión.

  • No se puede utilizar la sintaxis del inicializador de objetos con campos / lectura automática ''solo lectura'' private set. En general, quiero ayuda lingüística para hacer tipos inmutables.

  • El uso de {}para espacios de nombres y clases y métodos y propiedades / indexadores y bloques de múltiples instrucciones y inicializadores de matriz . Hace que sea difícil averiguar dónde se encuentra cuando están muy alejados o no coinciden.

  • Odio escribir (from x in y ... select).Z(). No quiero tener que recurrir a la sintaxis de llamada de método porque falta algo en la sintaxis de consulta.

  • Quiero una docláusula sobre la sintaxis de consulta, que es como foreach. Pero no es realmente una consulta entonces.

Realmente estoy llegando aquí. Creo que C # es fantástico, y es difícil encontrar mucho que esté roto.

JavaScript :

  1. Todas las cosas más geniales son increíblemente complejas, pero luego, toda la frialdad también está envuelta en una cantidad tan pequeña de código que te sientes estúpido por luchar para seguirla.

  2. ''+'' es una opción absurda de operador para la concatenación en un lenguaje débilmente tipado. ¿Estaban tratando de asustar a los noobs?

  3. Es un campo minado de compatibilidad entre navegadores (no importa si está encendido o no)

  4. Por lo general, no es de confianza: se asocia con problemas como bloquear el botón de retroceso, ventanas emergentes que nunca mueren, etc.

  5. Es casi imposible depurar porque solo hay unos pocos mensajes de error diferentes y algunos tipos diferentes (Número, Cadena, Objeto, etc.)

Si no fuera por jQuery, probablemente todavía lo odiaría tanto como solía hacerlo :)

JavaScript :

  • El Objectprototipo puede ser modificado. Cada objeto en su programa obtiene nuevas propiedades, y algo probablemente se rompe.

  • Todos los objetos son mapas hash, pero es difícil usarlos de manera segura como tales. En particular, si una de tus llaves está __proto__, estás en problemas.

  • Sin cierre de objeto en el tiempo de referencia de la función. De hecho, ningún cierre de objeto en absoluto, en cambio, thisse establece cada vez que se llama a una función con notación de objeto o el newoperador. Produce mucha confusión, especialmente cuando se crean devoluciones de llamada de eventos, porque thisno está configurado para lo que espera el programador.

    • Corolario: llamar a una función sin notación de objeto o los newresultados del operador thisse establece igual al objeto global, lo que resulta en una gran ruptura.

  • Operador de adición sobrecargado para realizar también la concatenación de cadenas, a pesar de que las dos operaciones son fundamentalmente diferentes. Resulta doloroso cuando un valor que espera que sea un número es, de hecho, una cadena.

  • ==y los !=operadores realizan coacción tipo. Las comparaciones entre diferentes tipos implican una lista de reglas que ningún mortal puede recordar en su totalidad. Esto se ve mitigado por la existencia de ===y !==operadores.

  • Ambos nully undefinedexisten, con significados sutilmente diferentes, pero redundantes. ¿Por qué?

  • Sintaxis extraña para la creación de cadenas prototipo.

  • parseInt(s)espera un número de estilo C, por lo que trata los valores con ceros iniciales como octales, etc. Al menos puede, parseInt(s, 10)pero el comportamiento predeterminado es confuso.

  • No hay ámbito de bloque.

  • Puede declarar la misma variable más de una vez.

  • Puede usar una variable sin declararla, en cuyo caso es global y probablemente rompa su programa.

  • with { } .

  • Realmente difícil de documentar con JavaDoc como herramientas.

JavaScript

  1. Números como cadenas: las matemáticas pueden ser frustrantes cuando los números se interpretan como cadenas. 5 + 2 = 52? Grrr ...
  2. permisos - todo lo mejor requiere permiso del usuario!
  3. Actualizaciones de pantalla: el navegador debe estar en estado estable para actualizar la pantalla. No parece haber una manera de forzar la actualización de la pantalla en medio de un script.
  4. Lento, aunque Chrome de Google es bueno ...
  5. Las diferencias en el navegador hacen que el uso del lenguaje sea [censurado].

JavaScript

  • Cada script se ejecuta en un único ''espacio de nombres'' global ... algo que hay que tener en cuenta al trabajar con scripts de diferentes fuentes

  • Si se usa una variable pero no se ha definido de antemano, se considera una variable global

  • Los proveedores de navegadores crean estándares a su gusto, lo que hace que la codificación para nosotros los desarrolladores que utilizan un lenguaje tan hermoso sea más difícil de lo que debería ser

  • Sensibilidad a los casos: considerando que no hay un IDE decente para desarrollar js con verificación en tiempo de compilación

  • Soluciones provisionales (como el uso del hasOwnPropertymétodo) para realizar algunas operaciones sencillas.

PHP

  1. No hay funciones de depuración si no controlas el servidor, e incluso entonces son un poco chupadas
  2. La cantidad extrema de código PHP malo que flota alrededor da a todos los programadores de PHP un mal nombre
  3. Nombramiento de funciones inconsistentes
  4. Incapacidad de tener una variable de tipo estático si quiero una (soy un gran fanático de la escritura dinámica el 90% del tiempo)
  5. REGISTER_GLOBALS es el diablo

Ruby tiene muchos defectos relacionados con su velocidad, pero no los odio. También tiene fallas con el evangelismo de la comunidad que va por la borda, pero eso realmente no me molesta. Esto es lo que odio:

  • Los cierres (bloques) tienen 4 sintaxis de creación diferentes, y ninguna de ellas es óptima. La sintaxis elegante es incompleta y ambigua con hashes, y la sintaxis completa es fea.
  • La comunidad tiende a estar en contra de la documentación real, favoreciendo ''leer el código''. Encuentro esto infantil y perezoso.
  • El abuso de la metaprogramación, particularmente en las bibliotecas, hace que los errores sean una pesadilla para localizarlos.
  • En una nota relacionada, la metaprogramación generalizada hace que un IDE completo sea difícil, si no imposible, de realizar.

  • La forma en que se hace pasar el bloque a las funciones es tonta. No hay razón para que los bloques se pasen fuera de la lista de parámetros, o tengan una sintaxis especial impar para acceder (rendimiento). Soy de la opinión de que a los bloques se les debería haber dado una sintaxis menos ambigua (o hashes podrían haber usado diferentes delimitadores; quizás <> en lugar de {}), y pasar los parámetros a los métodos debería haber sido como todos los demás parámetros.

    object.method(1, {|a| a.bar}, "blah")

    Estas rarezas, como el bloque debe ser el último parámetro que se haya pasado y el paso de más de un bloque es diferente con una sintaxis más larga, realmente me molesta.

C (OK, no es mi favorito, pero aún no se ha hecho).

  • Sintaxis de la librería Socket.
  • Sin sobrecarga de funciones.
  • Cuerdas de estilo C
  • El exceso de búfer.
  • Sintaxis críptica. No sé cuántas veces busqué cosas como atoi, me golpeé la frente y grité "¡Por supuesto!"

EDITAR: Probablemente podría encontrar más si recurriera a más códigos de biblioteca (como hice con sockets, pero son particularmente malos), pero ya sentí que estaba engañando por buscar en C. Hay tantos idiomas solo para tomar Las partes buenas de C y reemplazan las malas que es como golpear a un caballo muerto.

C ++

  • Instrumentos de cuerda.
    No son interoperables con las cadenas de plataforma, por lo que terminas usando std :: vector la mitad del tiempo. La política de copia (copia en escritura o copia profunda) no está definida, por lo que no se pueden dar garantías de rendimiento para una sintaxis sencilla. A veces se basan en algoritmos STL que no son muy intuitivos de usar. Demasiadas bibliotecas hacen rodar las suyas que, desafortunadamente, son mucho más cómodas de usar. A menos que tengas que combinarlos.

  • Variedad de representaciones de cadenas
    Ahora, esto es un pequeño problema de plataforma, pero todavía espero que hubiera sido mejor cuando una clase de cadena estándar menos obstinada hubiera estado disponible antes. Las siguientes representaciones de cadena que uso con frecuencia:

    • genérico LPCTSTR,
    • LPC (W) STR asignado por CoTaskMemAlloc,
    • BSTR, _bstr _t
    • (w) cuerda,
    • Cuerda C,
    • std :: vector
    • una clase roll-my-own ( suspiro ) que agrega control de rango y operaciones básicas a un (w) char * buffer de longitud conocida

  • Modelo de construcción.
    Estoy harto de la muerte de todo el tiempo dedicado a confundir con quién incluye las declaraciones adelantadas, optimizando los encabezados precompilados e incluye para mantener soportables los tiempos de construcción incrementales, etc. Fue genial en los años ochenta, pero ¿ahora? Hay tantos obstáculos para empacar un trozo de código para que pueda reutilizarse que incluso las mamás se aburren de escucharme.

  • Difícil de analizar
    Esto hace que las herramientas externas sean especialmente difíciles de escribir y de hacer bien. Y hoy, los chicos de C ++ carecemos principalmente de la cadena de herramientas. Me encanta mi reflexión de C # y mis delegados, pero puedo vivir sin ellos. Sin gran refactorización, no puedo.

  • El subprocesamiento es demasiado difícil. El
    lenguaje ni siquiera lo reconoce (por ahora), y las libertades del compilador, aunque son grandiosas, son muy dolorosas.

  • Inicialización estática y bajo demanda Técnicamente, hago trampa aquí: esta es otra pieza del rompecabezas en el "código de cierre para reutilizar": es una pesadilla obtener algo que se inicialice solo cuando sea necesario. La mejor solución para todos los demás problemas de redistas es lanzar todo a los encabezados, este problema dice "más no puede".

Por supuesto, mucho de eso va más allá del alcance estricto del lenguaje, pero en mi opinión, toda la cadena de herramientas debe ser juzgada y debe evolucionar.

Delphi:

  • IDE es un poco inestable.
  • El conocimiento del código a veces se confunde.
  • La depuración es a veces con errores.
  • La actualización de varios archivos de proyecto puede ser complicada.
  • Si se inicia cuando uno o más paquetes no están disponibles, el mensaje de error aparece varias veces.

Haskell:

  1. Fugas de espacio de la evaluación perezosa.
  2. Jerarquía numérica no construida con respecto a las abstracciones matemáticas.
  3. La IO monádica estricta puede dificultar la depuración.
  4. Las grandes implementaciones manejan la E / S de maneras que no parecen ser bastante compatibles con el estándar. (En particular, los caracteres de salida solo generan los 8 bits bajos, y luego se construye el código que utiliza esta suposición para hacer I / O binario. Ick).
  5. La asociatividad del ($)operador podría cambiarse para hacer algunas expresiones más bonitas.

La mayoría de estos no alcanzan el nivel de odio, y hay personas que intentan arreglar o construir soluciones sólidas para cada uno de estos.

Edit: Ha habido cierta confusión sobre el punto 5. En particular, algunas personas parecen pensar que quise decir el orden de los argumentos, que no. En lugar de explicar lo que quise decir, solo señalaré a las personas el siguiente enlace, http://hackage.haskell.org/trac/haskell-prime/wiki/ChangeDollarAssociativity , que lo expresa bien.

Lisp Común:

  1. Las palabras clave son a menudo demasiado largas.
  2. El apoyo de la biblioteca es lamentable.
  3. No funciona bien en sistemas operativos que desean manejar la memoria de manera más estricta.
  4. No tiene buenas instalaciones para interactuar con el sistema operativo.
  5. La función de "bucle" no está bien definida, y seguro que no parece Lispy.

PHP:

  • Nunca se puede estar seguro de que ciertas extensiones casi comunes estén disponibles en todos los servidores web.
  • Intenta ser todo en el futuro (goto, cierres, ...).
  • Muchos riesgos de seguridad para usuarios inexpertos.
  • más sobrecarga del operador sería agradable
  • todos los programadores pobres que no aprenden a hacer que funcione correctamente, y le dan un mal nombre

Sin embargo PHP es el lenguaje (scripting). ;-)

Pitón:

  • Falta de tipificación estática
  • Manejo de argumentos predeterminado (específicamente el hecho de que puede cambiar el argumento predeterminado para futuros llamantes)
  • Demasiados guiones bajos requeridos (los constructores deben ser llamados __init__)
  • Falta de funciones y miembros privados apropiados (la convención simplemente dice que la mayoría de las cosas que comienzan con un guión bajo son privadas, excepto que todas las cosas así __getattr__no son)
  • Sintaxis divertida para printingresar a un archivo (pero están solucionando eso en Python 3)

Ruby es mi idioma favorito, esto es lo que no me gusta:

  • Hilos verdes + bloqueo de bibliotecas C = falla gigante
  • Tan pálidamente lento
  • La biblioteca estándar en sí misma es inconsistente con su uso de bang! metodos
  • El módulo incluir + extender es desordenado.
  • Las "Clases abiertas" no pueden tener un ámbito: quiero agregar un dostuff String #, pero no quiero que se filtre en todas las bibliotecas de terceros
  • No hay solución de empaquetado de despliegue binario.

VB6

  1. Sólo Windows.
  2. Ya no es compatible.
  3. Las matrices pueden comenzar en cualquier número, en lugar de normalizarse a 0.
  4. Las aplicaciones compiladas dependen de muchos archivos DLL para funcionar correctamente.
  5. Muchos controles complicados, como el control de un navegador o piezas de código complicadas, tienden a romper el IDE cuando se ejecuta el código sin compilar, pero funcionan bien cuando se compilan.