Scientific computing

Computational science, also known as scientific computing or scientific computation (SC), is a rapidly growing multidisciplinary field that uses advanced computing capabilities to understand and solve complex problems. It is an area of science which spans many disciplines, but at its core it involves the development of models and simulations to understand natural systems.


 * Algorithms (numerical and non-numerical): mathematical models, computational models, and computer simulations developed to solve science (e.g., biological, physical, and social), engineering, and humanities problems
 * Computer and information science that develops and optimizes the advanced system hardware, software, networking, and data management components needed to solve computationally demanding problems
 * The computing infrastructure that supports both the science and engineering problem solving and the developmental computer and information science

Best Practices
The purpose of this resource is to describe best practices in the field of scientific computing. Computing has become an essential scientific tool in research, yet techniques in this discipline are often not taught.

Summary of Best Practices (reproduced from Wilson et al 2014)


 * 1) Write programs for people, not computers.
 * 2) A program should not require its readers to hold more than a handful of facts in memory at once.
 * 3) Make names consistent, distinctive, and meaningful.
 * 4) Make code style and formatting consistent.
 * 5) Let the computer do the work.
 * 6) Make the computer repeat tasks.
 * 7) Save recent commands in a file for re-use.
 * 8) Use a build tool to automate workflows.
 * 9) Make incremental changes.
 * 10) Work in small steps with frequent feedback and course correction.
 * 11) Use a version control system.
 * 12) Put everything that has been created manually in version control.
 * 13) Don't repeat yourself (or others).
 * 14) Every piece of data must have a single authoritative representation in the system.
 * 15) Modularize code rather than copying and pasting.
 * 16) Re-use code instead of rewriting it.
 * 17) Plan for mistakes.
 * 18) Add assertions to programs to check their operation.
 * 19) Use an off-the-shelf unit testing library.
 * 20) Turn bugs into test cases.
 * 21) Use a symbolic debugger.
 * 22) Optimize software only after it works correctly.
 * 23) Use a profiler to identify bottlenecks.
 * 24) Write code in the highest-level language possible.
 * 25) Document design and purpose, not mechanics.
 * 26) Document interfaces and reasons, not implementations.
 * 27) Refactor code in preference to explaining how it works.
 * 28) Embed the documentation for a piece of software in that software.
 * 29) Collaborate.
 * 30) Use pre-merge code reviews.
 * 31) Use pair programming when bringing someone new up to speed and when tackling particularly tricky problems.
 * 32) Use an issue tracking tool.