¿Qué significa esta afirmación sobre C # y Java siendo la mitad de un lenguaje? [cerrado]

En el artículo: Por qué POCO , hay esta oración:

Maciej Sobczak lo dice bien: "Simplemente no me gusta cuando alguien me da la mitad del idioma y me dice que es para mi propia protección".

No entiendo lo que quiere decir, aunque C # es propiedad de Microsoft y Java es propiedad de Oracle , eso no significa que tengan la mitad del lenguaje, ¿verdad? No encontré ninguna evidencia para probar esa oración, y tengo mucha curiosidad por esto. Y aún más curioso sobre la parte 'por mi propia protección'.

Sobczak no está hablando de propiedad corporativa. El "medio" lenguaje que le falta son todas esas cosas que no puedes hacer en muchos idiomas modernos, aunque como experto en informática bien educado sabe que podrían hacerse posibles: hereda de tantas clases como quieras. Asigne cualquier objeto a cualquier otro sin restricciones de tipo. Controle la asignación y la liberación de recursos manualmente en lugar de confiar en el compilador y el tiempo de ejecución para hacerlo por él.

La cuestión es que todas esas restricciones se pusieron en lenguajes de programación por una razón. Nosotros nos tenemos lenguas que permitieron todo esto. Con el tiempo descubrimos que el programador promedio está mejor con una cierta cantidad de restricciones y agarre manual, porque el potencial de cometer errores realmente malos es demasiado grande como para valer la potencia y la expresividad adicionales.

(Obviamente, esto a veces molesta a los programadores que realmente no necesitarían tanta mano. Sus quejas son a veces legítimas. Pero las personas son notoriamente malas para evaluar sus propias habilidades, y muchos que piensan que no necesitan las salvaguardas, en De hecho, los necesito mucho. No siempre es fácil distinguir entre los intelectos superiores reales que se sienten retenidos por las restricciones en los idiomas de alto nivel de los codificadores promedio que solo piensan que quejarse los hará parecer superiores, o que no saben mejor.)

Esto se explica bastante bien en la fuente original de la cita :

Decidí aprender más sobre C ++ y me convertí en su fiel apasionado; esto incluye mi interés en la forma en que es probable que evolucione este lenguaje. Además, he notado que se necesitan las técnicas más avanzadas y avanzadas para desarrollar bibliotecas útiles , no las aplicaciones reales. Teniendo esto en cuenta, he intentado escribir un par de mis propias bibliotecas para diferentes propósitos (ver mi página de descarga) y también trato de mirar por encima de los hombros de los desarrolladores de C ++ Boost (ver mi página de enlaces) para saber qué técnicas de alta gama son. Pasar tiempo en el desarrollo de bibliotecas que se supone que son genéricas y útiles al mismo tiempo es realmente exigente. Es por eso que los programadores nunca dejan de aprender.

[...]

Sigo jugando con C ++ y las técnicas para escribir software robusto. Para obtener una perspectiva más amplia en el área de software confiable, decidí invertir algo de tiempo en aprender Ada (y cosas relacionadas), que es un lenguaje que parece estar completamente abandonado por los negocios, aunque fue Ada quien realmente fue diseñado para ser complejo y confiable. sistemas. Tengo que admitir que aprender Ada fue realmente beneficioso para mí en el sentido de que me permitió echar un vistazo más fresco a mi trabajo y enfoques de desarrollo. Lo más importante es que algunas de las ideas del mundo Ada se pueden aplicar más o menos directamente a C ++ con buenos resultados en el área de robustez y corrección.

[...]

OK, lo olvidé Un día juré no aprender Java. Pero lo hice. Bueno, en la medida que me permite leer y escribir código de trabajo. He leído 'Thinking in Java' (disponible en línea, gratis) y 'Core Java' (no en línea, no gratis), también me invocaron indirectamente en algunos desarrollos de Java, y ... Bueno, no compro eso. Simplemente no me gusta cuando alguien me da la mitad del idioma y me dice que es para mi propia protección. Es como un martillo de papel, hecho ligero para que nadie se lastime al golpear el dedo ... Lo mismo se aplica a C #. Elijo el martillo de acero, para poder estar seguro de que cuando quiera jugar al macho, resistirá.
La pregunta es: ¿por qué tanta gente lo usa (Java, C #, etc.)? Hmmm ... Tal vez porque es muy bueno en algunos lugares. Pero hay situaciones en las que tanto el lenguaje como la biblioteca muestran que fueron diseñados más bien para applets (inicialmente) que para convertirse en utilidades para hacer todo. Simplemente promete demasiado y da muy poco en cuanto a la tecnología global. O como una solución que podría superar cualquier competencia.

Me gusta C ++ cuando se necesita la máxima potencia y la perspectiva más amplia. En lugares donde la expresividad de C ++ no es imprescindible, lenguajes como Tcl o Python parecen encajar perfectamente. No solo son abiertos con respecto a su evolución, sino que uno puede extenderlos e incorporarlos, dependiendo de las necesidades particulares. Veo muchas posibilidades soñando en esas tecnologías. También tiendo a abandonar C como lenguaje para la programación regular; esta parece ser una opción razonable solo como un objetivo para la generación de código, de lo contrario es demasiado propenso a errores. Hoy, Ada es mi segunda opción probable para proyectos más serios, siempre que tenga libre elección (que, desafortunadamente, no es el caso la mayor parte del tiempo).

En otras palabras, al autor de esa cita le gusta C ++, y no le gusta Java, y siente que a Java le falta la mitad de C ++. Y eso es todo lo que hay en esa cita.

El artículo vinculado en el blog que publicaste se ha eliminado, por lo que es difícil estar seguro, pero como dice Kilian, es probable que cuando diga "la mitad del lenguaje" signifique que C # y Java se sienten como C ++ pero con mucho características y construcciones eliminadas para que sean más fáciles de usar o más seguras.

En 2006, cuando se escribió esto, cuando C # era relativamente joven y Java era inmaduro en muchos sentidos, y cuando el poder frente a la seguridad parecía una compensación donde solo se podía elegir uno, esta no era una posición totalmente irrazonable. .

En estos días esa posición no es razonable en absoluto. Solo pensando en los lenguajes convencionales, C # y Java han madurado enormemente, tomando prestadas características de otros lenguajes (particularmente funcionales) para promover la escritura de código seguro. También tenemos idiomas como Rust y Swift que se crean desde cero para hacer esto.

Si alguien menosprecia un idioma porque tiene tu mano, o dice que un idioma que es difícil de usar es algo bueno, tomaría cualquier cosa que dijera con un grano de sal. Solo tiene que mirar la vergonzosa cantidad de errores encontrados en el código del que dependemos todos los días, escritos por las mentes más brillantes de la industria, que se habrían evitado trivialmente mediante el uso de lenguajes 'seguros', para ver por qué.

Mirando hacia atrás en los archivos , parece que esta cita fue de 2003 (a pesar del artículo que cita que es de 2006). En ese momento, C # estaba en la Versión 1. x , y carecía de muchas de sus características modernas :

Nuevas características

C # 2.0

• Genéricos
• Tipos parciales
• Métodos anónimos
• Iteradores
• Tipos anulables
• Getter / setter accesibilidad separada
• Método de conversiones grupales (delegados)
• Covarianza y contravarianza para delegados
• Clases estáticas
• Inferencia delegada

C # 3.0

• Variables locales escritas implícitamente
• Inicializadores de objetos y colecciones.
• Propiedades implementadas automáticamente
• Tipos anónimos
• Métodos de extensión
• Consultar expresiones
• Expresión lambda
• Árboles de expresión
• Métodos parciales

C # 4.0

• Enlace dinámico
• Argumentos nombrados y opcionales
• Co y contravarianza genéricas
• Tipos de interoperabilidad integrados ("NoPIA")

C # 5.0

• Métodos asincrónicos
• Atributos de información del llamante

C # 6.0

• Compilador como servicio (Roslyn)
• Importación de miembros de tipo estático en el espacio de nombres
• Filtros de excepción
• Esperar en la captura / finalmente bloques
• Inicializadores de propiedades automáticas
• Valores predeterminados para propiedades solo de captador
• Miembros con cuerpo de expresión
• Propagador nulo (operador condicional nulo, verificación nula sucinta)
• Interpolación de cuerdas
• nombre del operador
• Inicializador de diccionario

C # 7.0

• Fuera de las variables
• La coincidencia de patrones
• Tuplas
• Deconstruccion
• Funciones locales
• Separadores de dígitos
• Literales binarios
• Ref devoluciones y locales
• Tipos de retorno asíncrono generalizado
• Constructores y finalizadores con cuerpo de expresión
• Getters y setters con cuerpo de expresión

C # 7.1

• Asíncrono principal
• Expresiones literales predeterminadas
• Nombres de elementos de tupla inferidos

- "C Sharp" , Wikipedia (referencias y enlaces eliminados)

Probablemente sea más comprensible que C # pareciera medio lenguaje en ese contexto, ya que le faltaba mucho de lo que C # es hoy. ¡Es extraño pensar que ni siquiera tenía staticclases!

También faltaban más cosas, ya que C # estaba vinculado a .NET. Por ejemplo, WPF no estaba en ese entonces; todo fue WinForms.

Se quejaba de la falta de características del lenguaje que permiten un control detallado. Estas incluyen herramientas para

• Hacer cumplir la inmutabilidad (como la constpalabra clave C ++ )
• Controlar la vida útil y la propiedad del objeto
• Controlar el uso de la memoria, el estilo de copia y asignación

Esto me recuerda una de mis críticas a Java:

todo es un puntero, pero los punteros no existen.

En los objetos C ++, los punteros y las referencias son tres conceptos distintos con una semántica clara. En Java solo tienes el pseudo-objeto-puntero. Al combinar esto y evitar la semántica de puntero verdadero, el modelo de objeto es menos claro.

En un programa C ++ bien definido, el programador puede esperar que las referencias sean válidas y no nulas. Debido a su modelo simplificado, Java no puede hacer las mismas garantías.

Los síntomas de este modelo menos claro incluyen el patrón de objeto nulo y yoda condicionales como 5.equals(potentiallyNullIntegerReference).

Estoy de acuerdo con la respuesta de @Kilian pero agregaré algunos elementos.

1- Ejecutar contra una máquina virtual, no el sistema operativo

Como Java y C # se ejecutan a través de una máquina virtual, lógicamente se espera que no pueda hacer exactamente lo que quiere cuando está directamente en el sistema operativo, ya que es probable que corrompa algo en la máquina virtual. Además, con Java orientada como plataforma independiente, es aún más lógica.

2- Toneladas de aplicaciones no requieren que necesites ese tipo de cosas.

Hay toneladas de aplicaciones que realmente no necesitan que revises tantos detalles, pero si lo haces con un lenguaje que requiere que lo hagas, obtienes:

• Más riesgos de tener errores debido a esas cosas innecesarias.
• ¡Más costos de desarrollo, administración de memoria y pruebas toman tiempo y dinero!

3- Los idiomas se toman en función del costo / uso / riesgos de ponderación, como ... todo.

Con C ++ puedes hacer casi lo que quieras, esa es la elección de las personas de C ++. Sin embargo, cuanto más haya, más tendrá que manejar.

Entonces, cosas como la herencia múltiple no se abandonan solo por el hecho de que son peligrosas, sino que se abandonan porque su implementación tiene un costo (desarrollo, mantenimiento), todo por eso para una característica que rara vez se usa correctamente y puede generalmente se reescribirá de manera diferente.

Simplemente ponga todas las restricciones en lenguajes de alto nivel como C # y Java para proteger al programador. No existen tanto para proteger al programador de sí mismo, sino para proteger al programador de otros programadores.

¿Cuántas veces, como programadores, encontramos bibliotecas que eran francamente atroces en sus prácticas de codificación y diseño, pero que nos vimos obligados a usar por una razón u otra?

Estos programas suelen tener el sello distintivo del antiguo método de programación de procedimientos, con falta de encapsulación, muchas escrituras de memoria directa con poca o ninguna captura o manejo de errores. Los Segfaults persiguen en masa cuando intentan usarlos en cualquier proyecto a gran escala.

Ahí es donde los lenguajes como Java y C # son extremadamente útiles; no es que disfruten el hecho de que no nos dejan hacer todas las cosas buenas que hacen otros idiomas, es que disfrutamos la falta de dolores de cabeza que tenemos que soportar porque otros programadores abusarían de las cosas buenas que otros idiomas pueden hacer.

Las interfaces bien merecen cualquier tipo de compensación en términos de memoria o velocidad de ejecución en mi mente. ¡Espero que puedan ver que en cualquier tipo de aplicación de misión crítica de tiempo limitado, todas esas protecciones, el manejo adecuado de errores y, en general, estar seguros de que la memoria no se está agitando son cosas buenas!