¿Cuáles son los trucos más impresionantes que un IDE podría lograr con el código? [cerrado]

Los IDE modernos tienen muchos trucos bajo la manga para ayudar con la escritura, refactorización y búsqueda de códigos. Todos estos son muy útiles, pero rara vez alguno de ellos parece una verdadera "magia" y me hace pensar "¡Guau! ¿Cómo se dio cuenta de eso?"

¿Puedes nombrar algunas características impresionantes de automatización de código IDE (u otras) que te dejaron boquiabierto la primera vez que las viste?

Depuración hacia atrás

Visual Studio 2010 (y ahora 2012) me permite depurar hacia atrás con IntelliTrace.

Nunca más tendré que volver a vivir el momento en que golpeé F10 demasiadas veces y tendré que reiniciar la depuración.

Completar código

Cuando todo lo que has visto es un editor de texto, esto es impresionante.

La capacidad de ReSharper de adivinar lo que quiero una variable llamada continúa asombrándome. Aquí hay un ejemplo muy simple, pero te haces una idea.

Estaba muy impresionado con las herramientas de refactorización de Eclipse cuando las encontré por primera vez. La capacidad de extraer métodos (que, cuando estás aprendiendo un mejor diseño es algo común) de una gran porción de código y tener todo manejado para mí fue bastante genial.

Burbujas de código. http://www.andrewbragdon.com/codebubbles_site.asp

Me encanta Visual Studio y Eclipse por las herramientas que me dan para cambiar el código, pero Code Bubbles realmente me emociona por poder navegar y ver mi código. Lástima que no esté disponible públicamente = - {

El entorno de programación más impresionante del que he oído hablar es el sistema operativo Genera.

Puede hacer clic en cualquier widget en el sistema de ventanas y obtener una lectura completa del código fuente y la documentación del artículo. Al ser un lenguaje de programación dinámico (Lisp), puede editar la fuente del widget sobre la marcha.

Todavía se dice que ZMACS del mundo Lisp Machine es un mejor editor que Emacs, que es un entorno de editor sin igual.

Mostrar visualmente la estructura del programa (programas / funciones / rutinas / ...)

La capacidad de ReSharper para refactorizar. En la divulgación completa, puedo estar detrás de la curva aquí, ya que creo que Java con Eclipse ha tenido este tipo de funcionalidad durante algún tiempo, pero no trabajo regularmente con Java.

El delta en capacidad que ReSharper agrega a Visual Studio es tan grande que es increíble. Sé que sueno como un anuncio, pero no creo que pueda volver a usar una instalación de Visual Studio sin ReSharper en la parte superior.

En términos más generales, una comprensión semántica del código le quitaría los pantalones a un editor de texto antiguo cualquier día. Esto lleva a cosas como "encontrar usos de variable" o "función en línea" u "oportunidad de usar un patrón idiomático", etc.

Depurador de Smalltalk:

• Acceso completo a toda la pila de llamadas (¿Cuál fue esta variable de instancia de los remitentes de ese objeto 3 en la pila?)
• Edite el código bajo prueba en el depurador, reinicie y continúe la ejecución del programa como si nada hubiera pasado.

Es perfectamente normal en Smalltalk pasar la mayor parte del tiempo escribiendo código desde el depurador.

(Recuerdo que me impresionó ejecutar un método, ver algo mal, cambiarlo y volver a ejecutar el método sin reiniciar la aplicación en el día con Visual Age para Java ... porque VA4J fue escrito en Visual Age para Smalltalk).

Buscador de métodos de Smalltalk

Method Finder le permite preguntar "¿qué mensaje podría enviar para tomar estos parámetros y obtener este resultado?" Pregúntalo 'abc'. 'def'. 'abcdeb'.y te lo dice 'abc' , 'def' --> 'abcdef'. Pregúntalo #(0 1 2 3)y dice #(0 1 2 3) sum --> 6. * Remitentes-de, implementadores-de todos ustedes para encontrar todos los remitentes (*) de un mensaje o todos los objetos que implementan ese mensaje.

(*) Excepto cuando haces cosas como crear nombres de mensajes en tiempo de ejecución: self perform: (#foo, #bar)para enviarte el mensaje #foobar, en cuyo caso sabes lo que estás haciendo y no te importa el potencial de levantarte sobre tu propio petardo.

Whyline

Whyline for Java realmente me impresionó cuando lo vi. Es una herramienta de análisis dinámico que le permite hacer preguntas sobre la salida del programa, y ​​no solo texto, sino también gráficos. Por ejemplo, puede preguntar "¿por qué esa línea era roja?" o "¿por qué no se llamó al método de pintura?"

Funciona instrumentando su programa y grabando una carrera. Por ejemplo, suponga que hay un error que puede reproducir. Instrumente su programa con Whyline, ejecute su programa en Whyline para reproducir el error y luego, cuando salga del programa, puede usar Whyline para inspeccionar el historial de ejecución.

Esta grabación y reproducción no es nueva, pero la forma en que Whyline la implementa es bastante ingeniosa. Puede ver el historial de acuerdo con eventos específicos (por ejemplo, enfocándose solo en eventos de arrastre del mouse o solo eventos de keydown) También asocia el resultado con qué parte del programa lo imprimió, para que pueda navegar desde el resultado hasta el código.

Para trabajar, utiliza la división de programas, para que pueda centrarse en las partes del código que son realmente relevantes. CMU ahora tiene una patente, y no sé cuáles son sus planes, pero espero que podamos ver más en producción. Es un juego de memoria, pero eso es probable porque es un prototipo y puede mejorar.

Debería ver la demostración en línea, pero también debería probarla usted mismo para obtener la experiencia completa. En todo caso, las demostraciones en línea superan la idea.

Creo que la característica IDE más impresionante que he visto es SyncEdit , que AFAIK solo está disponible en Delphi.

Lo que me gustaría ver en un IDE son estas características:

• Muestra el código de la forma en que estoy acostumbrado (independientemente de cómo esté formateado)
• Permitir incrustar tablas (digamos una hoja de cálculo de Excel donde puedo leer los valores de las celdas sheet[A3]) y dibujos en el código y acceder a ellos como cualquier variable.
• Permita omitir llaves y otro código innecesario que esté allí para hacer feliz el análisis.
• Buscar el código con un motor similar a Google (especialmente obtener resultados de búsqueda dentro de los 35 ms)
• Mostrar ifcondiciones complejas de forma similar a una tabla (aún buscando el enlace).
• Herramientas de refactorización que pueden encontrar código similar, extraer las diferencias y reducirlas al máximo.
• Soporte para la generación de código mientras se obedecen las reglas del lenguaje (piense: cree todos los captadores y definidores para las clases Java a menos que ya exista un método con el mismo nombre o que dependa de anotaciones)

Verificación de tipo para lenguajes dinámicos

Mientras su código no se vuelva demasiado 'meta', un IDE para Ruby o Python debería poder ejecutar una tarea en segundo plano que:

• para una función determinada, determina todas las clases posibles que se pasarán como argumentos
• para esas clases, asegura que respondan a todos los métodos invocados por esa función
• presenta una lista de las clases incompatibles con los métodos faltantes que necesita implementar

Todavía no he visto un IDE que haga esto.

Soy un gran fanático de la capacidad de varias líneas de clics alternativos en Vs2010, lo mejor que he encontrado sobre la nueva versión.

Eclipse's Auto Build es la característica que más admiro ... hace 7 años. Ahora solo lo doy por sentado.

Xcode 4 corrige los puntos y comas y los errores tipográficos, y usa flechas para mostrar cómo se produjo un error.

P.ej:

NSString *a = [[NSString alloc] init];
[a release];
int l = [a length];

Se dibujará una flecha de [a release]a [a length]para mostrar por qué no se puede usar [a length].

Plantillas de código y expansión, como CodeRush de DevExpress. En C #, a DependencyPropertyes un gran problema para crear, ya que la sintaxis puede volverse detallada, pero simplemente escribir "dp" trae algo parecido a un fragmento donde se completa el tipo, el nombre y el valor predeterminado, y todo lo demás se hace, incluido agregando las declaraciones de "uso" necesarias, y posiblemente referencias de proyecto si la memoria sirve.

El beneficio está en crear sus propias plantillas, para el código que a menudo reutiliza o reescribe, como implementaciones simples de INotifyPropertyChangedpropiedades, donde simplemente le da a la plantilla el nombre y el tipo de propiedad (si otro expansor no la ha manejado) que desea usar , y maneja el resto, incluida la creación de la variable de respaldo.

Pex hace una generación de pruebas unitarias automatizadas bastante interesante. Rastrea su código, determina puntos de bifurcación, utiliza un solucionador condicional para generar entradas que alcanzan cada bifurcación posible y luego le permite exportar los resultados como pruebas unitarias repetibles. Puede humillar el código complejo de manejo de cadenas.

En Eclipse Generate SEtters y getters automáticamente, de manera similar, cree métodos en la clase de implementos desde una interfaz

El apoyo de IntelliJ Idea a JPA

Mencione que tiene una DatabaseEntity:

@Entity
public class Customer{
[...]
String lasName;
[...]

ahora tienes algunas consultas JPA

Query q = "selecct s from Customer c where c.lasName=:lastName"

después de un tiempo, verá que cometió un error tipográfico dentro de su Entidad y decide refactorizar el nombre a lastName .

Ese IDE también refactorizará la consulta JPA.