In this ever-changing world of software development it's extremely important to keep up with current technologies, methods and trends. It can easily get out of hand though – simply there's not enough time for anyone to learn all new stuff, work and live a normal life simultaneously. Selection is thus the key, being smartly selective about new things to learn so we will not miss important stuff but also keep 'junk' or unimportant trends out.
I created this small and ever-incomplete list of things I feel we all should pay attention to and practice. Some items could have considered 'old' (read: more than a few months old) but still not grasped enough yet.
Without further ado I present the list:
1. Learn and use a modern scripting language
it can be Ruby, Python, Groovy or TheNextBigShot coming along, it does not really matter. What matters is having a quick and easy tool for anything at hand so we will not have to fire up our java IDE for a simple script. Also (most of) these languages encourage good attitudes and methods, changing our attitude towards programming and program design. Embraceing these "wow, look how elegant and simple that is!" solutions also become expectations with time (because we'll get used to the ease and convenience), so we will be striving for elegance and quality – helping impoving all of our further designs and codes.
2. Learn thogoughly and embrace the philosophy of a modern version control system
Be it Git or Mercurial, but start using them. Right now. Embrace the paradigm shift that wave birth to these tools. If not at work then try any of these on a personal project. These tools fit better to a natural cycle of development than our old tools svn or cvs. Being distributed does not mean they can not be used as a central company repo solution. They both encourage the concept of cheap local branching, keeping you safe by being able to revert any time (as traditional VCSes) and also keeping the central main repo clean of nitty-gritty details. Be familiar with NoSQL solutions like MongoDB, CouchDB.
These beasts can be real life-saver when traditional relational DBs reach their limits at scaling and performance. Both MongoDB and CouchDB are what's called a 'document-oriented database' which means that instead of rigid schemas the structure of each row is taken into account – they do not even have to have the same fields, etc. The concept of 'row' becomes the concept of 'document'. JSON-like data structures, dynamic queries, efficient storage of binary data (like videos, images), mapreduce support account for their robust and easy use-cases.
3. Learn a functional language – or more than one.
It's about the paradigm shift and philosophy again. The more things you see and use the more complete you repertoire will become. Object-oriented / imperative design is not the only one out there. Take a look at Erlang for starters, it's easy to learn and with it you can dip your toe in the water, but for more serious stuff Haskell or OCaml is a must (I vote for Haskell though). I'd say learning a functional language is not an option anymore – it's a must.
Some problems can be solved in an insanely easy manner with a functional approach and for example Haskell can easily implement any mathematical definition or problem you'd be having a problem describing in any imperative language. Also GHC (The Glasgow Haskell Compiler) is a state of the art optimizing compiler, one of the best compiler available now. Of course Haskell is not only for scientists, many good libraries are coming out written in haskell. Also see Real world Haskell for a nice intro. Erlang is well known for its fault tolerance, concurrency paradigms, hot-swappable code and optional networking support. Having such a tool at hand is always a bonus.
4. Study agile methods and concepts.
Agile management is not only for managers. There's a need for the whole team to have a good understanding about their own development and management process. Agile helps to standardize management and daily programmer work, enabling a small, controllable devel / release / testing cycle and also encouraging good communication all across the team (actually agile just can not work without good communication!). Just look at the Agile manifesto. Some important derivatives and parts of agile methods:
– TDD – Test Driven Development
– Iteration-based development – deliver less but more frequently in well-defined short bursts
– BDD – Behavior Driven Development
– XP – Extreme Programming
– CI – Continuous Integration
– Scrum