¿Qué pequeños hábitos te hicieron un mejor ingeniero de software?

Answer 1

Ahí lo tienes: 5 hábitos que te harán un mejor desarrollador de software.

Hábito:

• una prenda larga y suelta usada por un miembro de una orden religiosa.
• una tendencia o práctica establecida o regular, especialmente una que es difícil de abandonar.

Nos centraremos en el segundo.

Los hábitos son cosas muy poderosas. Es probable que un mal hábito como fumar disminuya la duración de su vida, mientras que un buen hábito como caminar 10,000 pasos al día probablemente lo incremente.

El mayor poder de los hábitos es que no hacemos ningún esfuerzo para hacerlos. No tiene que pensar en cepillarse los dientes por la mañana, solo lo hace en piloto automático.

Entonces, si hay un comportamiento que nos mejora de alguna manera y somos capaces de consolidar un hábito, nuestra calidad general mejorará.

Me gustaría compartir 5 pequeños hábitos que nos pueden hacer mejores desarrolladores de software. La lista no está ordenada.

1. Siempre ten un plan

Antes de comenzar a escribir el código, deténgase y asegúrese de tener un plan, no solo escriba su camino a través de una característica o una corrección de errores. Use lápiz, papel, pizarra, hable con su pato de goma y elabore un plan, una serie de pasos secuenciales para completar la tarea.

Esto puede parecer sentido común, pero encontré que muchos desarrolladores, incluyéndome a mí, con demasiada frecuencia solo piensan ” Sé cómo hacerlo ” y terminan con un resultado de mala calidad.

Estoy seguro de que todos ustedes están haciendo un plan de desarrollo antes de comenzar el desarrollo de grandes piezas de código, pero lo que digo aquí es siempre hacer un plan. Se puede ganar mucho valor con solo pensarlo un poco, sin importar lo pequeños que sean.

Dado que todos estamos de acuerdo en que tener un plan es bueno, si tiene la costumbre de hacer un plan , entonces al comenzar el desarrollo de cualquier cosa su cerebro automáticamente y sin costo mental adicional comenzará a hacer un plan. Gran ganancia, de forma gratuita.

Para crear este hábito, asegúrese de tener siempre lápiz y papel al lado del teclado. Si se encuentra codificando cosas sin haber hecho primero un plan, deténgase, haga un plan y comience de nuevo.

2. Comprometerse a menudo, cometer atómicamente.

Hay mucha literatura sobre por qué hacer cometidos atómicos pequeños es una buena idea, así que lo cortaré. Los pequeños ataques atómicos hacen que el desarrollo sea más seguro, son más simples de fusionar y revertir, y facilitan la tarea de rastrear la fuente de errores. Puedes comenzar a leer más sobre el tema aquí y aquí.

Tratar el control de la fuente de esta manera no es fácil al principio, pero los beneficios son enormes.

Para desarrollar este hábito, tendrás que ser disciplinado en todos tus proyectos, incluso si trabajas solo o es personal.

Los hábitos se construyen a través de la repetición comprometida. ¿Recibiste el juego de palabras?

Consejo de poder: git commit -p te permite realizar pruebas de forma interactiva, incluso líneas individuales de código.1

3. Escribir pruebas

El 2014 ha sido bastante controvertido con respecto a las pruebas, comenzando con la charla de DHH en Rails Conf, el seguidor picante de Gary Bernardt, y una serie muy perspicaz de lugares de reunión donde DHH, Martin Fowler y Kent Beck discutieron sobre el tema.

La opinión mía y de muchos otros es que escribir pruebas primero es útil y da como resultado un mejor software. Es por eso:

• Proporcionan otro cliente para su código.
• Si es difícil probar algo, es más probable que sea difícil trabajar con él, y ahora puede hacerlo más simple, antes de tener que interactuar con él “de verdad”.
• Te dan confianza al refactorizar.

Para implementar este hábito, sobrecarga . Escribe pruebas para todo! Ninguna línea de código debe escribirse sin una prueba. Pruebe todo, incluso cosas que podrían parecer tontas de probar, como valores de constantes, colores, métodos que hacen cosas simples. El punto aquí es entrar en la mentalidad de prueba. Una vez que escriba automáticamente las pruebas para todo, podrá dar un paso atrás y probar solo lo que realmente importa.

4. Aprende un nuevo atajo de teclado al día.

¿Qué pasaría si te dijera que podrías durar 366 días?

Digamos que su IDE tiene una función que usa 60 veces al día, y al usar un atajo de teclado en lugar del mouse, puede ahorrar 1 segundo cada vez. Eso es 1 minuto guardado por día. A lo largo de un año calendario, digamos, 47 semanas laborales de 5 días cada una son 235 minutos guardados.

¡Casi 4 horas, con un solo atajo de teclado!

Adquiera el hábito de buscar un nuevo método abreviado de teclado como lo primero que hace en su jornada laboral.

¿Ya conoces todos los accesos directos de tu IDE favorito? ¿Qué hay de hacer alias para los comandos de shell más utilizados, como gp para git push , crear fragmentos de los bits de códigos más utilizados, automatizar tareas repetitivas? ¡Las posibilidades son infinitas!

5. Mantente enfocado

Todos sabemos que los desarrolladores de software funcionan mejor durante largos períodos de tiempo ininterrumpidos. Esto se debe al famoso costo del “cambio de contexto” y al hecho de que nuestro trabajo consiste en mantener vivos muchos pequeños detalles en nuestra memoria a corto plazo, y evaluarlos todos al mismo tiempo.

Si revisa cada correo electrónico, menciona, le gusta y el texto que recibe, tendrá que “pagar” el costo del cambio de contexto cada vez. Al concentrarse y agrupar todas las actualizaciones sociales y la comprobación de correo electrónico al final de una sesión de codificación, ganará productividad. ¿Y adivina qué? Debido a que no tiene que perder tiempo para volver a la zona , sus tareas se terminarán más rápido.

Algunos consejos para mantener este hábito: use la famosa técnica Pomodoro, considere girar el teléfono en modo avión cuando trabaje en tareas importantes y califique su nivel de enfoque durante el día, haciendo un seguimiento de lo que hace que pierda el enfoque para evitarlo.

Conclusión, pero esto es solo el comienzo.

Es posible que estos 5 hábitos no sean los mejores, pero están funcionando muy bien para mí y quería compartirlos.

Construir hábitos es algo que requiere compromiso, pero que a la larga se paga. Se necesita entre uno y dos meses para consolidar un nuevo hábito, y es mejor concentrarse en un número reducido de hábitos a la vez, para no agotar la fuerza de voluntad necesaria para implementarlos.

Puede aprovechar el poder de los hábitos en casi todos los aspectos de su vida. ¡Ser un mejor desarrollador es solo el comienzo!

¿Quieres salir con solteros adinerados y atractivos, sí o no? Solo ven aquí— Elite People Meet . Millones de solteros adinerados y encantadores están allí para encontrar su verdadero amor. Dirección de descarga y registro gratis: Apple Store y Google Play . Espero que tenga sentido para ti 🙂

Answer 2

• Desarrollar primero las soluciones de picos : este fue uno de los hábitos que surgió de mis experiencias iniciales con la programación ágil / eXtreme. Las soluciones de Spike son prototipos desechables que lo ayudan a validar si está en el camino correcto antes de realizar una gran inversión en un conjunto particular de supuestos.

  Esto difiere de solo un prototipo porque sigue la regla de que finalmente tirará el código de “pico” después de terminar su investigación. Se le permite cortar esquinas y actuar con rapidez porque nunca estará en producción ni terminará en una revisión de código.

  Esto ayuda a descubrir rápidamente qué partes de un diseño se desconocen actualmente sin intentar tomar decisiones arquitectónicas o de diseño demasiado pronto.

• Compromiso con el control de versiones en pequeñas porciones coherentes : con algo como CVS / Subversion, cada confirmación se envió directamente al servidor. No fue sencillo hacer confirmaciones parciales de archivos.

  Con el advenimiento de Git, se hizo realmente fácil solo enviar un par de líneas de un archivo más grande, realizar los registros de la fase y rebautizar / fusionar los compromisos anteriores localmente antes de enviarlos a un repositorio remoto.

  Una vez que adopté pequeños compromisos incrementales mientras trabajaba en funciones más grandes, mi productividad se disparó. Mantuvo mi espacio de cabeza claro para cosas más importantes.

• Siempre esté programando . Recientemente, he estado trabajando en: una plataforma de automatización y colaboración empresarial basada en la web (PHP / MySQL), un agregador de métricas en tiempo real basado en la nube y API utilizando hashes de round robin (Node.js / Redis ), un juego de mesa para la tienda de aplicaciones iOS (Swift / SpriteKit), una alternativa de cronjob basada en URL especializada para servicios SaaS basados ​​en web (Java), etc.

  Trabajar con tantos marcos e idiomas me ayuda a pensar de forma abstracta y algorítmica.

  He traído tantas grandes lecciones de herramientas como Eclipse RCP, Tapestry e Hibernate a mis proyectos PHP. Especialmente a principios de la década de 2000, antes de que existiera el ecosistema empresarial similar a Java para PHP. Aprendí mucho sobre redes y arquitecturas orientadas a mensajes de Unity / C #.

  Nunca hubiera descubierto esos conceptos si me hubiera limitado a una sola plataforma y comunidad.

• Escribir código simple : solía escribir código elaborado como un desafío para mí mismo. Ahora el desafío es escribir un código que sea elegante pero simple, hasta el punto de que todos deberían sentir que podrían haberlo hecho (incluso si no pudieran). Las cosas simples suelen evolucionar a partir de varias iteraciones de cosas complejas.

  Antoine de Saint Exupéry dice: ” Parece que se alcanza la perfección, no cuando no hay nada más que agregar, sino cuando no hay nada más que quitar ” .

  Esto también hace que sea fácil regresar a un proyecto después de un largo período de inactividad, y animar a otros a participar.

• Optimización del último : es fácil caer en la trampa de tratar de ser más inteligentes que los usuarios o la computadora, y pre-optimizar para todo tipo de casos de borde. Enfoque en el principio de Pareto (80% del efecto proviene de 20% del trabajo). Escriba código, ejecute el código y concéntrese en los mayores cuellos de botella cuando sea necesario. Esto también ayuda a mantener las bases de código simples.

  Decir “No optimizar primero” no significa “Escribir código descuidado”. Siempre desea escribir código delgado y elegante, pero no quiere pasar todo el día tratando de exprimir el último 10% de algo que ya funcionó lo suficientemente bien. Su productividad disminuye, usted introduce más complejidad, las soluciones se vuelven menos generalizables, etc.

• Centrándose en “Lo más importante primero” : siempre hay áreas de un proyecto que son más divertidas o desafiantes que otras. La tentación es trabajar siempre en las cosas divertidas en lugar de las cosas necesarias.

  Es posible hacer un poco de ambos usando cosas divertidas como kindling antes de atacar las cosas importantes.

  Solo, el concepto de romper grandes problemas en pequeños es un tópico. Todos saben eso. Sin embargo, comienzo mi día anotando un par de “ganancias rápidas” para acumular impulso y flujo (lo que puede ser cualquier cosa, incluida la diversión y pequeños desafíos), y luego cobro lo correcto por “lo más importante (casi) primero”.

• Comprender la pila completa : cuando empecé, no había nada peor que esperar a que alguien más hiciera su parte antes de que pudiera continuar con mi parte (artistas, diseñadores, personal de servicios de fondo, personal de aplicaciones, personal de bases de datos, servidor). personas, etc).

  Cuando comencé mi propia compañía de desarrollo de software en el año 2000, tomé una decisión consciente para entender la pila completa. Sabía que no sería el mejor en todo o, en última instancia, la única persona responsable de todo, pero quería poder hacer prototipos de principio a fin porque estoy impaciente por ver el progreso.

  Cada vez que necesitaba algo que tocaba un área que no entendía, lo investigaba. Aprendí administración de servidores, administración de bases de datos, diseño, desarrollo de front-end / back-end, arquitecturas en la nube, etc.

  Al comprender lo que hacen los otros roles, también puedo escribir código que sea consciente de sus necesidades.

Estoy seguro de que algunos de esos puntos no parecen ser “pequeños hábitos”, pero les aseguro que son el resultado de pequeños cambios durante aproximadamente 20 años. Lo importante no era la importancia de los cambios de comportamiento, sino más bien lo mucho que practiqué el oficio (probablemente 4000-5000 horas al año durante los últimos 10 años). Con tanta práctica, terminas viendo patrones y aprendes mucho de las cosas que no iban de acuerdo con el plan.

Entonces, realmente, mi enfoque se parecía más a la pregunta “¿Qué pequeños hábitos llevaron a un software peor y una menor productividad?”, Y luego simplemente adopté el enfoque antipatrón.

Answer 3

1. Cuando esté resolviendo una cosa específica, siempre pregúntese ¿Cuál es el caso general, de que este problema es un ejemplo específico de? – puede comenzar simplemente preguntando ¿Qué otros problemas tiene este problema? . Primero, eso te hace hacer las preguntas correctas para salir y encontrar algo que ya lo resuelva. En segundo lugar, si lo necesita, puede codificar el caso general y luego usarlo para su problema específico, y tiene algo que puede reutilizar en lugar de dedicar tiempo a escribir otra vez la próxima vez que tenga un problema similar.

Por ejemplo: supongamos que tiene una lista de cosas en la memoria, y acaba de recibir una lista actualizada de cosas de algún lugar, y necesita averiguar qué ha cambiado. Un programador junior pasará horas escribiendo código para comparar cada elemento de la lista; uno de mayor categoría se dará cuenta de que está haciendo un diff (de la misma manera en que se diferencian dos archivos en el control de versiones), que es un problema muy bien resuelto con una serie de algoritmos para elegir uno, y encontrar o escribir una solución para diferentes cosas, donde agregas un pequeño código de pegamento para adaptarlo a las cosas particulares que necesitas diferenciar.

No toma más tiempo escribir soluciones genéricas a las cosas una vez que lo domina, y le ahorra a su futuro mucho tiempo y lo hace mejor para mirar debajo de la superficie de los problemas. Es un hábito de pensamiento que se vuelve más fácil cuanto más lo haces.

2. Si no puede encontrar el caso general, pregúntese si realmente tiene múltiples problemas, en los que había pensado que era solo uno grande. Luego descomponerlo y resolverlos uno por uno. Si algo parece muy complicado y enredado cuando lo piensas, es probable que haya más de un problema allí.

3. Tan pronto como creas que sabes cómo resolver un problema, pregúntate ¿Cómo falla esto? ¿Cuáles son las cosas que pueden salir mal? ¿Qué pasa si lo hacen? Todo falla, dadas las circunstancias correctas: el objetivo es no fallar por razones estúpidas, fallar en silencio (parece que está funcionando) o hacer algo sin sentido en ese caso.

4. Cuando era niño, observé a mi padre desviarse de su camino para evitar usar el cinturón de seguridad: los autos no los tenían cuando aprendió a conducir, y una vez que su ’72 VW tuvo un timbre que hizo ruido cuando no lo era. abrochado, recurrió a hacerlo detrás del asiento y todo tipo de travesuras. Pero los cinturones de seguridad son una buena idea. Así que cuando empecé a conducir, decidí que iba a usar el cinturón de seguridad desde el primer día, y entonces no me molestaría porque siempre lo había hecho.

Dos cosas que conozco de la programación son como abrocharse el cinturón de seguridad antes de conducir : enhebrado y localización. Si existe la posibilidad de que los mensajes de texto de algo que escribas se muestren a una persona real en vivo, averigua cómo vas a hacer la localización y hazlo desde el principio. No toma mucho más tiempo, pero la adaptación de todas las cadenas que su código puede producir para ser localizadas después del hecho es un infierno. Lo mismo ocurre con el subprocesamiento: si es multiproceso, piense en qué subprocesos hace qué, qué necesitará protección frente a modificaciones simultáneas y cómo minimizar esos puntos. Es casi imposible adaptar un modelo de subprocesamiento sobre un código base sin uno con la confianza de que sea realmente seguro de usar.

Por ejemplo, supongamos que está escribiendo una aplicación GUI (anticuado, lo sé, pero es un buen ejemplo, ya que viene con subprocesos obvios). La E / S del disco o de la red en el caso de que el hilo se detenga de forma impredecible, y es posible que no lo vea, pero el usuario que se ejecuta desde una memoria USB o cualquier circunstancia extraña que no haya pensado en la voluntad. Entonces, a priori, haga que sea un error hacer E / S en el hilo de eventos, punto: envuelva todas sus E / S en llamadas que lo revisarán y fallarán inmediatamente. Luego, solo asegúrese de tener una buena cobertura de prueba que conduzca su UI, y de que se detecten los errores antes de tiempo.

5. Genere mensajes de error detallados y significativos, y falle pronto en una entrada incorrecta. ¿Cuántas horas de programador se han desperdiciado porque una nula se colocó en una estructura de datos donde no debería haber estado, y alguien tuvo que pasar días repasando sus pasos para averiguar de dónde venía? Si estás paranoico sobre el rendimiento, no lo seas. Primero, los cheques simples son baratos. Segundo, puedes darte una forma de apagarlos si eso es realmente un problema. En tercer lugar, el hardware es más barato que el tiempo del programador: un par de días arreglando uno de estos costos más que otro servidor.

6. Mientras estamos en ello, diferenciar entre errores anticipados e imprevistos. Por ejemplo, Java tiene una NullPointerException cuando intenta hacer referencia a algo que no existe. No los lance usted mismo si está, por ejemplo, verificando los argumentos de entrada: use una excepción diferente (por ejemplo, IllegalArgumentException o IllegalArgumentException rodar su propia NullArgumentException ). El punto es que la segunda vez que vea un mensaje de error, no querrá tener que mirar el código para averiguar si alguien me llamó con una entrada incorrecta en lugar de que algo esté roto en mi código . Ahorra un montón de tiempo por adelantado para averiguar dónde empezar a buscar el problema.

7. Usa el control de versiones para todo: lo tuyo, lo único que puedes hacer para probarlo, lo que quieras. La instalación de Gitolite en una computadora portátil vieja que puede guardar en un armario toma minutos, y garantiza que haya al menos dos copias de cualquier cosa que haga, y luego, si su hijo vierte un vaso de leche en su computadora portátil, bueno, eso apesta, pero no tanto como podría haberlo hecho.

8. En caso de duda, resuelve el problema una vez por ti mismo. Apenas en la semana pasada, he estado buscando cosas distribuidas en forma de cola para un inicio: elegir entre Kafka, NATS streaming y algunos otros. Finalmente cedí y dediqué un par de días a leer el documento ZAB (zookeeper) y algunos otros, e implementar un sistema similar para asegurarme de que entendía el espacio del problema lo suficientemente bien como para hacer una buena elección. Entonces es una cuestión de resistir la tentación de terminar su propia solución y hacer la elección madura de usar algo que ya existe (todos podemos reinventar la rueda y hacerla más redonda, pero eso no siempre es un buen uso del tiempo).

9. Si está usando un lenguaje muy tipificado, use tipos + el compilador para eliminar ciertas categorías de errores. Toma una firma de llamada como esta:

double computeDistance(double latitude, double longitude, double altitude)

Ahora, ¿qué tan fácil es llamar a eso con un par de argumentos intercambiados? ¿Y qué tan costoso sería ese error? (Depende de lo que esté escribiendo, pero si su código vuela un avión, de hecho es caro). Este es un tipo de problema simple que se inventó para resolver: simplemente escriba algunos tipos de envoltorios triviales y obtendrá

Distance computeDistance(Latitude latitude, Longitude longitude, Altitude altitude)

No solo ha eliminado por completo una clase de error de las llamadas a este código, sino que esas clases de envoltorio también pueden resolver la conversión de unidades si lo desea.

10. Si tienes la suerte de usar un lenguaje con una forma de hacer que las variables sean inmutables, la versión final de Java moderna o moderna, ¡ const siempre que puedas! Esta es otra forma en la que puede aprovechar el compilador o el tiempo de ejecución para hacer que una categoría de errores sea simplemente una imposibilidad, en lugar de improbable.

Los programas son grandes en estos días, por lo que las personas tienden a no pensar ¿Cuáles son todos los estados posibles que mi programa podría tener y que debería probar? , pero vale la pena pensar en combinatoria por un momento. Digamos que tengo un programa con dos booleanos:

  bool a;
 bool b;

Si quisiera probar todos los estados posibles de mi programa (todas las diferentes combinaciones posibles de variables en él, todas las cosas que podrían ser diferentes en diferentes ejecuciones), y probar que se comportó correctamente en cualquier circunstancia, tendría que probar cuatro indica: { a and b, a and not b, not a and b, not a and not b}.

Agregue otro booleano, y tenemos otra potencia de dos, y tenemos 8 estados para probar: estamos agregando otro bit, por lo que el número de estados es el número más grande que podría representar con tres bits. Y así es, con potencias de dos, lo que significa que la cantidad de estados posibles se hace increíblemente grande muy rápido, por lo que, como cuestión práctica, todos nos conformamos con la cobertura de la prueba, no probamos todos los estados posibles porque el sol haría una supernova antes de que estemos a la mitad pruebas.

Por supuesto, cuando introduce algo como cadenas en la mezcla, que puede ser de cualquier longitud y contener casi cualquier cosa, la idea de estados a medida que los bits desaparecen de la ventana: una cadena con el número máximo de caracteres que caben en un bit de 32 bits. el número entero es 34,359,738,368 bits (sin mencionar las diferentes longitudes posibles significa que estás tratando con un múltiplo de eso). Bajo el capó todavía funciona de esa manera, pero no es una forma práctica de abordar el problema.

Entonces, esta es la razón por la que nadie va a sugerir hacer una prueba de corrección en su aplicación web.

Sin embargo, si tiene final o const , tiene una herramienta que puede reducir drásticamente la cantidad de estados posibles que puede tener su programa (sin mencionar, ¿qué diablos cambió este valor?! Bugs). Cualquier cosa que no pueda ser cambiada no tiene que probar para ser cambiada.

Cuantos más estados posibles tenga su programa, mayor será el beneficio que obtendrá de cualquier herramienta que le permita eliminar algunos estados posibles, ya que no solo está eliminando un estado: haga que una variable final y su número de potenciales no sean válidos Estados es ahora la raíz cuadrada de lo que era.

Por lo tanto, no importa que la inmutabilidad no llegue a un territorio a prueba de corrección. Si puede reducir el número de posibles errores de forma exponencial con una sola palabra clave, debe aprender a amar la inmutabilidad y hacerlo cada vez que tenga la oportunidad.

Answer 4

Compartiré el hábito más importante que desarrollé hace muchos años, en el ejemplo de un compañero / mentor: mantener un registro de trabajo. Si solo tomas un consejo de esta pregunta, deja que sea esto. Santa moly

Solía ​​dedicar varios minutos al día a descifrar dónde estaba, ya sea el día anterior o simplemente regresar de una reunión:

• ¿Verifiqué ese código?
• ¿Dónde estaba yo en esa solución?
• ¿Decidí heredar para esa nueva clase o simplemente implementar una interfaz?
• ¿Cuál fue el nombre de ese script que reinició el servidor dev?
• ¿Cuál era el nombre del entorno donde se implementa la solución?

Fue una pérdida de tiempo, pero no pensé mucho en ello. Pensé que era una parte necesaria del trabajo. Entonces un amigo me mostró su registro de trabajo. Incluía lo que hizo ese día, los elementos de acción de las reuniones y muchas pequeñas notas para él. No lo recomendó explícitamente, pero para mí, un noob comparado con él, fue increíble. Todo lo que hizo o necesitaba hacer estaba allí, ¡al alcance de su mano!

Implementó el suyo en HTML, así que seguí su ejemplo. Luego me cambié a Word. Entonces Evernote. Entonces OneNote. Lo que usa para guardar sus notas no es tan importante como MANTENER LAS NOTAS.

Aquí hay un breve ejemplo de algunas de mis notas de una tarea:

• Mirando la llamada que hace el “botón”

• Como de donde obtiene su información
• Están usando system.getHost (), no el host proporcionado en la configuración

Probando la implementación de “referencia”

• ¡Funciona!

Código de trabajo

• Ya sabes, arreglarlo
• ¡¡¡TRABAJOS!!!

¡VERIFICANDO A ESTE SUCKER!

• ¡Hecho!

Como puede ver, mi formato es una lista, pero puede usar el formato que más le convenga. Y recuerda, son solo para ti, por lo que puedes anotarlos de la forma que quieras. Personalmente, hago un seguimiento de las tareas separadas en páginas separadas; Un aumento a mi hábito que desarrollé recientemente.

También sirven como una buena herramienta CYA. Si su jefe se acerca a usted y le dice: “Roger, no creo que estés haciendo nada”. Tu LOC es cero durante la última semana “. Puedes sacar tu registro de trabajo y mostrarle todas las notas que has guardado en tu diseño para tu nueva función y mostrarle todas las reuniones inútiles a las que te obligó a asistir que te mantienen de cerrar código.

Mantenga un registro de trabajo y sea exitoso y más productivo. Aquí termina la lección.

Answer 5

Me tomó un tiempo antes de comenzar a desarrollar algunos hábitos que me hicieron un mejor ingeniero de software. Al trabajar con diferentes clientes y diferentes industrias, comienzo a desarrollar algunos hábitos internos que me cuesta dejar de hacer ahora porque en la mayoría de los casos me permitió ser mejor cada día.

Éstos son algunos de mis hábitos:

Arquitecto cada aplicación de software

Casi nunca codifico ninguna aplicación sin tenerla correctamente diseñada primero. La mayoría de las veces, usé las mejores prácticas, como tener en cuenta cuándo usar los patrones de diseño , separar las responsabilidades del código utilizando los principios de SOLID y el enfoque de Diseño impulsado por dominio (DDD) . No lo sé. Tal vez sea un poco perfeccionista en lo que respecta a la limpieza del código porque creo que me ahorrará mucho tiempo en el futuro. Y minimizará aún más la frecuencia de los códigos de espagueti que aumentan la Entropía de Software con el tiempo.

Creo que en cada software que realice, debe haber una mejor arquitectura. Es más probable que seas productivo cuando intentas que el código sea lo más separado y limpio posible. Cuando aprendí cómo separar mejor mi repositorio y mi capa de servicio en la aplicación, pude mejorar mi velocidad de codificación a un ritmo increíble. No solo eso, también pude insertar algunas Pruebas unitarias en la mezcla gracias a una mejor separación de inquietudes.

Más aún cuando me moví al paradigma MVC y lancé DDD a la mezcla. Fueron los momentos más productivos de mi vida como Ingeniero de Software .

La única excepción a esto es cuando estoy codificando algunos fragmentos de código de muestra que necesito probar. O alguna aplicación de software experimental para pruebas.

Escribe blogs / artículos de lo que has aprendido.

Creo que algunas personas descuidan la idea de escribir sus descubrimientos / hallazgos en un pedazo de papel. O crea un artículo de blog para ello .

Como lo entiendo, escribir artículos para las cosas que acabas de realizar en la programación de hecho te hará mejor. Especialmente cuando lo escribes y lo compartes con programadores de todo el mundo.

No solo pudiste compartir tus ideas y ayudar a los programadores en sus problemas a nivel mundial, sino que también pudiste expresar tu singularidad y peculiaridades.

Otro beneficio de escribir artículos para ello es que aumenta la retención de esa información en su cerebro. La investigación ha demostrado que cuanto más escriba la información, mejor retendrá y procesará mejor la información.

Una ventaja adicional para esto es que te permites comunicarte con los programadores y estás abierto a las críticas. De esta manera, podrás mejorar y aprender de sus consejos. O corregirlos. Esto abre una conversación para que cualquiera de ustedes pueda beneficiarse.

Puede que hayas notado que los buenos ingenieros de software escribieron blogs. Esto es lo que probablemente están apuntando.

Usa el sistema de control de versiones como git.

No estoy completamente seguro de por qué la mayoría de los desarrolladores en mi ciudad aún no saben cómo hacer esto como una norma en su día a día como desarrollador de software. Para mí, usar git fue el descubrimiento más importante que exploré en toda mi vida. Me salvó muchos dolores de cabeza.

Debido a los controles de versión como git, puedo crear sucursales que se relacionan con las características específicas en las que necesitas trabajar. En este caso, no es necesario que retroceda, ya que lo más probable es que no fusione su rama de características con su rama maestra hasta que la haya probado a la perfección y esté funcionando bien. Si las cosas no salen como debe, puede dejar esa rama y no fusionarla con su rama maestra.

Los controles de versión son potentes. Es el que hace que el trabajo remoto sea muy exitoso hasta ahora. Imagine trabajar con desarrolladores con diferentes zonas horarias y no tiene ese control de versión que registrará / supervisará sus cambios y simplemente copiará / pegará sus proyectos en el almacenamiento en la nube. ¡Eso será desastroso!

Usar tablero kanban

Cuando tomo en serio el proyecto o la idea que estoy construyendo, estoy usando aplicaciones de kanban board como trello para eliminar todas mis ideas / errores / problemas que encuentro al momento de crear mi MVP.

Me ahorró mucho dolor de cabeza. Fue más fácil entender a dónde me dirijo actualmente y qué ideas ya se han hecho.

Resolver problemas en un ángulo diferente.

Se podría decir que estoy un poco obsesionado con resolver problemas desde un ángulo diferente. Especialmente con la optimización, me preguntaba constantemente cómo puedo optimizar la consulta aunque ya esté optimizada.

También trato de analizar la velocidad del algoritmo tras bambalinas (Big O Notation).

Ejercicio / Golpear el gimnasio.

Por lo general, voy al gimnasio alrededor de 3 a 4 veces por semana. Esto es para asegurar que estoy haciendo que mi cerebro sea más saludable, lo que me permite pensar mejor y resolver problemas complejos para mis clientes.

Leer libros

Por último, este es el hábito que más odiaba. Libros de lectura. Ahora lo aprecio. Leo libros todos los dias

Me hizo un mejor pensador y un mejor ingeniero de software en general.

Answer 6

La innovación proviene de la mercantilización. Una vez que el almacenamiento se convirtió en un producto básico, Amazon podría ofrecer sus soluciones de almacenamiento flexibles. Una vez que las conexiones rápidas de Internet se convirtieron en un producto básico, Netflix podría ofrecer sus servicios a pedido.

Tu tiempo es precioso, ahorra todo lo que puedas. Automatiza todo. Una vez que su tiempo sea una mercancía, puede lograr su próxima gran innovación.

• Use un IDE potente (como vim) y configúrelo para que haga todo lo posible por usted. Luchar por un solo comando Construir / Probar / Implementar / Ejecutar.
• Si te encuentras haciendo cosas con frecuencia, haz que ocurran con solo presionar un botón o con un clic. O mejor aún, haz que sucedan automáticamente.
• Aprende los atajos de teclado y la línea de comandos de Unix. Casi cualquier IDE le permitirá ejecutar comandos de compilación complejos e incluso comandos de terminal arbitrarios; estos pueden ser potentes y le ahorrarán una cantidad significativa de tiempo.
• Haga preguntas, luego haga más preguntas. Si está sucediendo algo que no entiendes, pregunta por qué. Entonces pregunta por qué es eso. Luego vete a buscar alternativas, y propóntelas. Haga preguntas hasta que pueda explicar en detalle al próximo nuevo desarrollador que pregunta por qué. Con frecuencia me sorprende la cantidad de desarrolladores que no hacen esto y solo confían en “porque siempre ha sido / ha funcionado así”.
• Desafíe el status quo proporcionando mejores soluciones alternativas, y dé pasos significativos hacia su implementación. Si sus pruebas están incompletas, o se ejecutan una vez al día / semana, conviértase en el gurú local de Integración Continua: presente a su equipo los beneficios y aplíquelo. Una vez que lo estés usando y te ayude a trabajar mejor, haz que tu equipo lo use también.
• No solo desafíes a los demás, desafíate a ti mismo. ¿Nunca escribiste una aplicación web? Escribe uno. ¿Nunca has hecho python? Secuestre UAVs con python.
• Poseer algo. Crear algo No tiene que ser un proyecto técnico, podría ser un evento, como una reunión o un hackathon, podría ser un juego, un sitio web, un blog.
• Enseñar algo. Java, oratoria, escritura, ajedrez, vim, tenis.
• Ser un faro de excelencia. ¿Tienes una clase / componente que es basura? Arreglalo. Escribe el código de la manera correcta. No tome atajos en su código. Tome decisiones inteligentes y justifique los pros y los contras por los que tomó esa decisión a quienes le rodean. Siempre haga mejoras a su código. ¿Ves un TODO que llevaría menos de una hora? Simplemente hazlo.
• Explore el Intercambio de pilas en un tema que le resulte familiar, como su idioma favorito. Cuando encuentres algo nuevo para ti, hazlo lo más rápido posible. Saber c? ¿Cuál es la predicción de la rama? Este post te lo dirá – aprende.
• Explore el Intercambio de pila en un tema que no conoce: todos los días, un día escolar.
• Aprende a comunicarte. Palabra escrita, presentación, resolución de problemas, proyectos pequeños e intensos, equipos grandes, equipos pequeños.
• Documenta todo lo que haces a medida que avanzas. Puede referirse a por qué hizo las cosas y confiar en su solución anterior a problemas similares cuando los enfrente. También ayuda a capturar su proceso de pensamiento y piezas de información clave que puede olvidar. Con frecuencia reviso mi diario durante los últimos días de trabajo.
• Documente su código antes de que lo haya escrito. Use diagramas del sistema, jerarquías de clases, diagramas de flujo para mostrar cómo funcionará su código. Si la gente tiene sugerencias, y lo harán, puede hacer enmiendas con mucha facilidad que cuando ha escrito el código. Este es el otro gran problema que, sorprendentemente, pocas personas hacen, que puede tener los efectos más negativos.
• Se específico. Así que has elaborado tu diagrama para tu nueva cosa. Muéstraselo a todos. Reúne todos los detalles que puedas. Asegúrese de que todos estén de acuerdo con el diagrama, y ​​si no lo cambian. Si alguien pone lápiz en su diagrama, agregue esas adiciones / correcciones al diagrama. Mantener el diagrama actualizado.
• Aprende sobre el sesgo inconsciente y el privilegio masculino. Aprenda sobre MBTI y qué tipo de personalidad es y, lo que es más importante, cómo interactuar mejor con otros tipos de personalidad. Aprende sobre la inteligencia emocional. Todos en el mundo son diferentes para ti, y necesitas saber cómo interactuar con ellos de la manera más eficiente y constructiva.
• Regularmente haz algo por tu equipo. Traer galletas. Enseñar un truco de magia. Cultive un poco de cultura y anime a otros a hacer lo mismo. Solo alabar las contribuciones de otros pueblos. Un equipo cohesivo es difícil de vencer.
• Aprende a trabajar con la gente. Personalmente, realmente disfruté la “sopa de piedra” del programador pragmático.
• Entender y usar el código de otras personas. Si está implementando su propio analizador xml o lector csv o git hook, es muy probable que lo esté haciendo mal.
• Una vez que haya escrito su código, y funcione y pase sus pruebas, vuelva y ordénelo. Vuelva a ejecutar las pruebas. Ahora ponlo en orden un poco más. Cada clase debe tener una sola responsabilidad y cada función debe hacer una cosa. Las funciones deben tener menos de 20 líneas en la mayoría de los casos. Utilice nombres de auto-documentación para funciones y variables. Dedicar tiempo a ordenar su código se pagará 10 veces a usted y al resto de su equipo.
• Involucrarse Tomar responsabilidad Si algo no está bien, arréglalo. Si los plazos se están cumpliendo, sugiera una solución y avise a los demás tan pronto como sea posible. Anybody can do this, even the most junior developers. This requires understanding of the bigger picture of the project, its direction and deadlines – so again – get involved. Save the day!
• Share lessons learned (when appropriate) with your team. Just figured out what happens when throwing an exception from inside a finally block in Java? Compártelo.

Answer 7

One habit I’ve clung to is writing small prototypes when I’m trying to learn new concepts.

For example, I’ll sit down with a book or a web page, and over the course of a few hours, write 30 or 40 programs all of them only a few dozen lines long. Each program intended to demonstrate some simple concept.

This prototyping makes it very easy to try out many concepts in a short period of time. @_jeff_nelson

Answer 8

NOTE DOWN ALL BUGS

Always note down anything that happens that needs to be fixed – because in early stages you’ll encounter many more bugs than you can fix, many of them minor.

You can’t solve them all on the spot – so make sure to note them down, however minor or you’ll forget. Then gradually work through the list, still adding notes about any new bugs you find as you fix the old ones. And document what you did for all the fixes unless really minor, either in the code or in an external log file as appropriate.

EASY WAY TO SAVE ALL CURRENT SETTINGS SO BUGS CAN BE REPRODUCED

Make sure my programs have an option to save all current settings as a .ini file or project even if end user rarely needs this, same as when you exit and restart the program.

– then when testing if I encounter anything anomalous I immediately save it as a project, called “bug ….” whatever it is that went wrong.

I know that there are more sophisticated commercial ways of doing it – but this does fine also – at least for the bugs I’ve encountered, nearly all can be reproduced so long as you can reproduce the program settings for them.

FREQUENT FULL BACKUPS OF ALL THE CODE

Keeping multiple backups of all my code – and doing a full backup of everything every day or two or whenever I have done a significant amount of editing – makes it much easier to roll back to a known previous good configuration of the code and do diffs.

I tired SVN – but it didn’t work for me – the methods I use already were a little simpler, but for many SVN would be a solution but if you do again make sure you have key points each day or every few days where everything was working fine to roll back to.

GET YOUR HANDS DIRTY IF YOU HAVE AN IDEA FOR A CHANGE OF ARCHITECTURE

Not to be scared of changing entire architecture of the program – to try it out. Do a backup first, try out your idea for a new architecture for a day or two – and if it doesn’t work out ,just roll back again. I’ve done that often and you learn a lot more from getting your hands dirty trying out to see what happens if you change the code than just thinking about it.

POSTPONE THAT COOL NEW FEATURE AND WORK ON ROUTINE STUFF AS THE IDEA MATURES, ACCUMULATE OTHER RELATED WISHES

---

But – the other way around – as others say here, give yourself plenty of time to just think things over.

If you want to code something or your users ask you to code it – unless it is really easy and obvious – rather than dive in right away – I add it to a wish list. Then may accumulate several closely related wishes before I start coding it – that way – you have a more multi-dimensional idea of what you want to code, and less likely to need to rewrite the whole thing to accomodate some new desired feature – and often find you can program several wishes at once.

So – if you’ve got the choice of routine stuff or programming some cool new feature, is a great tendency to go for the exciting new feature. But – can sometimes be an idea to just write down the idea for it, and think over it, and accumulate new ideas for cool new features – while you continue to work on the routine stuff and debugging – and then do it when your ideas for it are a bit more mature.

Lots of other things – especially – listening to users, and paying attention to accessibility at all stages of the process – but thought those might be good to share.

See also: Robert Walker’s answer to How do top programmers work, eg, Fabrice Bellard?

Answer 9

Don’t just look for symmetry, write it first. For every allocate, write the free next. For every open, write the close then fill in the middle. For every success condition, frame out the error condition and drop a TODO there before moving on.

Another trick I do is tied to the symmetry. Take the success vs error case. While I’m coding I probably have the success logic in my head, and I want to commit it to code. To make sure that I don’t forget the error side of the branch, rather than just leaving in TODO comment, I often intentionally write something in the code that won’t compile.

I’ve been using “zzzzz” for nearly 30 years for that purpose for a bunch of reasons. For starters, it’s easy to type (bottom left of keyboard), and can’t possibly mean anything except that I meant to fill in code before trying to run. It’s also my signature that I left code incomplete, so if I am sharing code and someone else sees it, they know immediately to point it out to me. So, get your own signature marker, this one’s mine.

Answer 10

This may sound strange, partially because it’s not programming related and can be applied to practically any “brain-intensive” tasks, but when I’m programming I always have a bottle of chilled water and a few of my favourite snacks .

I drink when I’m thirsty , and only get a new bottle or re-fill once I’ve used the toilet. This not only hydrates me, which helps me concentrate, but it also means I get regular, short breaks, which I use to reflect on what I’ve been doing since the last one.

I only eat the snacks, and only one at a time, when I hit an obstacle that I have trouble getting past. If I manage to get past it, I log it in a text file, along with the solution, and treat myself to a snack.

Another habit I’ve gotten into, especially recently, is listening to music using headphones through Windows Media Player, but setting the volume to 1 . This provides a slight amount of background noise, but it’s not enough to be distracting. I listen to a range of music doing this, never sticking to one genre and almost always using “shuffle” for more variety.

All of this sounds like training a pet or small child to do something, but it’s a habit that has helped me through many, many different tasks. It only takes a little discipline for this to be successful, and the rewards are both fantastic and, if I pass an obstacle, tasty!

Answer 11

Little habits that made me a better software engineer (as opposed to bigger habits):

1. Learn context . When you look up an API or a parameter to answer a question on how to use it, read a little more broadly in the docs / header file / class to see what other related functionality is there. It helps you understand a family of behaviors rather than a single thing. Then you can remember it exists next time you need something similar.
2. Learn details , especially those that vary platform to platform. For example, when reading about the random function understand things that could screw you, and remember where you see tricky things. For example, maximum resolution or default behavior (seeded with current time in seconds by default). Knowing the pieces you use a little more deeply can really make a difference.
3. comment remaining work . As you are fleshing something out, leave comments in a reasonable format for the things you know have to get done, eg // TODO: JohnMil : handle asynchronous cases here . Then you can grep for it later.

There’s a million others, but these three are useful.

Answer 12

I cringe a little over the phrase “little habits”. When I think about what has differentiated me as an engineer, I think in terms of specific obsessions.

A few have been covered here, but here are a few more.

Obsess over failure modes

Consider the many ways your product might fail, at all levels. Network stack, storage layer, user interaction, everything. With what frequency will those failures occur? How will they manifest at scale (millions of users)? Work to reduce or eliminate failure modes at all levels. Handle them gracefully and automatically.

Practice radical pragmatism

If you chose Java because you love Java, you made the wrong choice. If you chose Java because the existing code base was Java and required minor extensions, you made the right choice. I’ve written code in languages I did not like because it was the practical thing to do. I’ve design products with less than cutting edge tech because it simplified the customer download and install experience. Y así.

Measure, measure, measure

Theories tend to be academic until grounded in real data. I’ve never regretted measuring something. I wanted to write the feature in 10 days, how many days did it actually take and why? How many people play my game on a daily basis? How long does it take to download & install my app? How many people interact with the Fizzbot widget and change it to a non-default setting?

Consider resources and scheduling

Engineers tend to neglect the impact of resources and scheduling on their work. It’s more of a “management” issue, but if you’re not staffed with the talent needed, nor the execution plan to succeed, you’ve got issues that are hard to overcome with individual technical prowess.

Focus on simplicity

Do everything you can to simplify the experience of the consumer of your products. Usable products are deceptively simple – incredibly hard work has often gone into minimizing points of interaction, automating tasks, handling failure modes, and so on. But when you’ve balanced engineering realities and made pragmatic choices to create a wonderful product, it’s a beautiful thing.

Answer 13

1. I actively maintain a document that I modify whenever I think of an idea for a product. As I think more about how I would build these products, I fill in details related to how I would architect and engineer the solutions to these problems. Constantly trying to refine designs, software design has become far more intuitive.
2. Whenever I have time to build something new, I pick new technologies, programming languages, frameworks to build my solutions with. This keeps me versatile and flexible in that I am forcing myself to experience and learn about different styles of design.
3. Whenever I have a dilemma as to how to proceed in designing a solution, I present the case to some friends and more senior developers who I respect. I work through the problem with them until I am convinced of the pros and cons of each of my options. Even if I do end up making the wrong decision (as has happened frequently in the past) I end up with the experience that enables me to avoid the same mistakes in the future.
4. I spend lots of time writing extremely elegant, well structured, and systematic code rather than a short amount of time writing a mess. The thought process that goes into designing a compact, powerful solution enables far more maintainable design, and makes it far more likely that the solution will be robust.
5. Whenever a new architecture is encounter, I patiently try to understand why the designers made the choices they made. Heck, if I get a chance, I discuss the design choices with the designers. Sometimes, they sucked, but more often, especially if I’m working on a system that has managed to withstand the test of time, the designers were making choices that were careful and meticulous. Even if they are new to you and seem strange, chances are that you are judging prematurely. Being able to appreciate different design methodologies and be flexible enough to apply these methodologies where they are needed rather than resorting to the same design for every system is vital to becoming a good engineer.

Answer 14

Nunca. Detener. Excavación.

If you’re having a problem with a network service. Find its code. Read its code. Understand its code. Understand how it interacts with the things above and below it.

If you find the problem in the network service, fix it. Constrúyelo. Load it. Pruébalo. This will likely cause you to dig into networking a bit.

Since you’re there. Find the code for the network stack. Read its code. Understand its code. Understand how it interacts with the things above and below it.

Find problems in it. Fix problems in it. Constrúyelo. Load it. Pruébalo. This will likely cause you to dig into drivers a bit.

If you’re having a problem with a driver. Find its code. Read its code. Understand its code.

If you find the problem in the driver, fix it. Constrúyelo. Load it. Pruébalo. This will likely cause you to dig into the hardware documentation for the device and in-circuit emulators.

Since you’re there. Find the schematics for the device. Leerlo Understand it. Understand how it interacts with the things around it.

If you find a problem with the schematic, fix it if you can — learn how to solder and cut-and-jumper.

If the problem is in the interface between the device you’re working with and an FPGA. Find the code for the FPGA. Leerlo Understand it. Understand how it interacts with the FPGA I/Os.

If you find the problem in the FPGA, fix it. Constrúyelo. Load it. Pruébalo. This will likely cause you to dig into the hardware debug environment of oscilloscopes, logic analyzers, etc.

Nunca. Detener. Excavación.

---

Over the course of 18+ years I’ve done exactly this. Started at the network management layer of software [CMIP, SNMP, …]. Learned about agents. Learned how they worked with the application software. Learned how the application software gathered the distributed data to provide to the agent. Learned how the gathering worked — over the device-internal network of hardware buses, etc. Learned the protocols used to gather the data. Learned the layers from top-down. Learned the translations that occur on a piece of data as it passes down through the layers to the device drivers. Learned about devices. Learned how devices are controlled. Learned how to write device drivers. Learned how to integrate device drivers. Learned FPGAs. Learned FPGA programming. Learned schematics…

Answer 15

I have a set of notes entitled “Brick walls”. Every time I run into an unexpected problem that takes me an unnecessary amount of energy to solve, I log it in my list, along with the final solution, and suggested resources so I am prepared next time.

My progress is then measured by the amount of brick walls I encounter. If I stop logging to that list frequently, I’m probably not challenging myself. It also serves as a list of potential gaps in my knowledge.

Answer 16

Buena pregunta.

• Keeping track of areas to improve and new tech to learn about (Notepad works very well for lists in general).
• Embracing and trying new things rather than shunning them out of fear. Doing this has two effects: you learn the new things and you get better and faster at learning in general.
• Setting boundaries and not saying yes to everything.
• Mocking up everything. Objects, architectures, UIs etc. Paint works for this. Gives you something to show, to refer to, and clarifies what you’re doing in your own mind rather than just jumping into it.
• Thinking about how you’d implement various things. Do this a lot, and research to find other ways to implement things. Do it enough and you can do it off the cuff in like 5 seconds. You just see the structure, see the UI, etc. It’s fucking cool.
• Using the home keys. ’nuff dijo.
• Trying to come up with useful ways to explain relevant things about individual projects and about coding in general to intelligent people who don’t program. This takes practice, and I’m still working on it, but it’s a very valuable skill.

Answer 17

So many things, but :

* when debugging, use print over a line by line debugger. Kill the program execution right after the problem area with an exit so you don’t have to wait for the whole thing to complete and that your debugging lines are the last things printed.

* comment to mark start and end blocks ( like end of for loop x or function foo ).
* comment the purpose of a program file at the top of it.

* comment about logic or program flow only when what is being done is surprising. Never comment what the code is doing when obvious.

* avoid small functions/procedures/subroutines that are referenced only once.

* a function should be about the size where you can view it without needing
to page up or down. It shouldn’t be too small either.

* cut and paste logic no more than once. if you find
yourself changing that logic more than once, make it into a function.
If the logic is more than a few lines long, make it into a function.

** Process **
* get it working
* get it correct
* make it good

keep in mind:
* premature optimization is the root of all evil. Identify bottlenecks before optimizing.

* making something overly ‘flexible’ tends to make it flexible one way and brittle an other.

Answer 18

1. Don’t over look for inefficient easy solutions, instead provide better code which is understandable to any new person coming into project.
2. Avoid code redundancy.
3. Use OOPS concepts whereever necessary.
4. Follow design patterns
5. Break bigger problems into smaller solutions.
6. Always make sure code checked in to source repository before you leave office every day.
7. Make the habit maintaining code indentation and putting comments that explains the purpose of code you are writing.
8. Understanding the requirements completely before stepping into development.
9. Do thorough unit testing before delivering your code.
10. Always keep buffer(preferably no of hrs*1.25) before you give estimates.
11. Maintaining a self task list for everyday activities/deliverables.

Answer 19

• Always start with ‘what exact problem are we solving, non-technically?’ – articulating the problem is half the battle.
• Understand ‘why are we solving this problem?’ – it sounds weird, but you’ll be amazed to realize that some problems were not problems worth solving due to their low impact.
• Don’t start coding directly – software engineering problems are first solved in the mind, on paper, white boards and brainstorming discussions. Coding is the last mile in the journey. Don’t jump into coding as the first step.
• Chalk out the solution on paper or a board.
• Keep it SIMPLE. Go for simplicity, the thinnest slice every time. It is very tempting to build a generic earth shattering solution, to solve all future problems.
• Run it through key personnel to get their thoughts. It is invaluable and also makes the rest of the process very smooth and predictable. It is also the design discussion.
• Do not reinvent the wheel. Most software problems involve building a figurine specific to your problem definition. But the Lego blocks are already out there. Leverage them. Do not build them again, for the fun of it.
• Do not underestimate the power of testing. Unit testing and a quick manual test. No matter how trivial or confident you are of your code.
• Have your favorite beats and food, no matter what you are doing – music and food makes it fun.
• Do peer reviews and buddy tests
• Try to read up stuff related to but slightly outside your work. Eg If you build RESTful APIs, see whats happening in that world.
• Try to see the forest instead of the trees. Most software problems and everyday things have a pattern, agnostic of technology or language.
• Be very crisp on estimation. Most people get carried away with estimates and feel it is a question of ability if they give non-aggressive estimates. It is not good to over-commit and under-deliver. The other way with a balance works well.
• Participate in hackathons, contests, make external apps, github projects etc. They give you wings.
• At the end of the day, be very friendly and nice with people. This may sound unrelated to software engineering, but being a better person makes you better at any job you do.
• Have lots of fun – it is all a fleeting phase anyways. This job, that job, this company, that company. Enjoy what you do and it’ll reflect in your work.

Always be a student of software. There is so much to learn and enjoy. And so many wonderful folks ready to share their knowledge across the world.

Answer 20

• Getting clear on what I’m trying to do before I do it
• Not being in a rush to document, communicate, or organize whatever I’m trying to do (letting things sit on my mind until they’ve worked themselves out)
• Not thinking of anything as being too difficult
• Not limiting myself to any tools, languages, approaches, best practices, standards, jargon, etc
• Not following a set routine/system/process, but instead doing what’s necessary
• Constantly pushing to make things better, rather than falling into the “now, now, now, we like shipping, just do what’s good enough” trap
• Proper nutrition, supplements, nootropics, Cerebrolysin, etc
• Getting away from weak programmers, close-minded individuals, and anyone else that primarily gets in the way and tries to limit everyone around them
• Ensuring that I work on new, different, and challenging things, rather than repeating the same year over and over again
• Writing scripts that generate code (eventually you may notice there’s a pattern to how you write/design, and a lot of it can be automated to speed things up later on. Just don’t get stuck on repeating whatever pattern you noticed, as that may limit your ability to progress/improve in the future)
• Getting user feedback