Every scientist needs to know a bit about statistics: what correlation means, what a confidence interval is, and so on. Similarly, every scientist ought to know a bit about computing: the question is, what? What it is reasonable to expect every working scientist to know about building and using software? Our list of core skills---the things people ought to know before they tackle anything with "cloud" or "peta" in its name---is:

  • basic programming (loops, conditionals, lists, functions, and file I/O)
  • the shell/basic shell scripting
  • version control
  • how much to test programs
  • basic SQL

There's a lot that isn't in this list: matrix programming (MATLAB, NumPy, and the like), spreadsheets when used well, they're as powerful as most programming languages), task automation tools like Make, and so on.

So: what's on your list? What do you think it's fair to expect every scientist to know these days? And what would you take out of the list above to make room for it? Nobody has enough time to learn everything.

  • 1
    $\begingroup$ Great question! But I'm not clear about one thing: what do you mean by computational scientist? Any scientist who uses computation? Or the MUCH smaller group of people who would consider their professional title to be "computational scientist"? $\endgroup$ Commented Feb 2, 2012 at 15:15
  • 9
    $\begingroup$ Make a list question are not good in the Stack Exchange format. Do we really have to go through this on every site? $\endgroup$ Commented Feb 2, 2012 at 16:53
  • 4
    $\begingroup$ @Dan Community Wiki isn't an excuse for allowing questions that don't belong on the site. I would also want to encourage those who answer to take an example from Jed and at least try and explain why you would need certain skills or don't need others $\endgroup$
    – Ivo Flipse
    Commented Feb 3, 2012 at 8:02
  • 5
    $\begingroup$ @IvoFlipse: This is a question that belongs on the site in some form. Maybe not as currently stated; maybe it needs to be hacked up into smaller questions and reworded, but the issue of poor software engineering in computational science is an extremely important one, particularly since computational science as a discipline is still in its formative stages. This article in Nature indicates why. Greg is doing a great service to the computational science community through his web site. $\endgroup$ Commented Feb 3, 2012 at 19:46
  • 5
    $\begingroup$ I disagree with this question being closed. Please see (and vote on) meta.scicomp.stackexchange.com/questions/179/… $\endgroup$ Commented Feb 14, 2012 at 5:39

7 Answers 7


"Computational Scientist" is somewhat broad because it includes people who doing numerical analysis with paper/LaTeX and proof-of-concept implementations, people writing general purpose libraries, and people developing applications that solve certain classes of problems, and end users that utilize those applications. The skills needed for these groups are different, but there is a great advantage to having some familiarity with the "full stack". I'll describe what I think are the critical parts of this stack, people who work at that level should of course have deeper knowledge.

Domain knowledge (e.g. physics and engineering background)

Everyone should know the basics of the class of problems they are solving. If you work on PDEs, this would mean some general familiarity with a few classes of PDE (e.g. Poisson, elasticity, and incompressible and compressible Navier-Stokes), especially what properties are important to capture "exactly" and what can be up to discretization error (this informs method selection regarding local conservation and symplectic integrators). You should know about some functionals and analysis types of interest to applications (optimization of lift and drag, prediction of failure, parameter inversion, etc).


Everyone should have some general familiarity with classes of methods relevant to their problem domain. This includes basic characteristics of sparse versus dense linear algebra, availability of "fast methods", properties of spatial and temporal discretization techniques and how to evaluate what properties of a physical problem are needed for a discretization technique to be suitable. If you are mostly an end user, this knowledge can be very high level.

Software engineering and libraries

Some familiarity with abstraction techniques and library design is useful for almost everyone in computational science. If you work on proof-of-concept methods, this will improve the organization of your code (making it easier for someone else to "translate" it into a robust implementation). If you work on scientific applications, this will make your software more extensible and make it easier to interface with libraries. Be defensive when developing code, such that errors are detected as early as possible and the error messages are as informative as possible.


Working with software is an important part of computational science. Proficiency with your chosen language, editor support (e.g. tags, static analysis), and debugging tools (debugger, valgrind) greatly improves your development efficiency. If you work in batch environments, you should know how to submit jobs and get interactive sessions. If you work with compiled code, a working knowledge of compilers, linkers, and build tools like Make will save a lot of time. Version control is essential for everyone, even if you work alone. Learn Git or Mercurial and use it for every project. If you develop libraries, you should know the language standards reasonably completely so that you almost always write portable code the first time, otherwise you will be buried in user support requests when your code doesn't build in their funky environment.


LaTeX is the de-facto standard for scientific publication and collaboration. Proficiency with LaTeX is important to be able to communicate your results, collaborate on proposals, etc. Scripting the creation of figures is also important for reproducibility and data provenance.

  • 7
    $\begingroup$ I agree with Jed. LaTeX is absolutely necessary! :) $\endgroup$
    – Paul
    Commented Feb 2, 2012 at 19:55
  • 1
    $\begingroup$ I'd change "Physics and Engineering" to subject matter expertise. After all, we're not all physicists or engineers. The spirit of that part of the answer is in the right place, but there's a pretty glaring assumption. $\endgroup$
    – Fomite
    Commented Feb 2, 2012 at 20:12
  • $\begingroup$ Thanks @EpiGrad, I changed it to "domain knowledge" with those as examples. $\endgroup$
    – Jed Brown
    Commented Feb 3, 2012 at 3:40
  • $\begingroup$ Good list. A basic understanding of performance issues should be in there too. I've met too many people who don't understand the simple concept of profiling code. NB: performance should be taken to mean not just speed issues but also memory usage. $\endgroup$ Commented Feb 3, 2012 at 8:33
  • $\begingroup$ Typos: "probelms" and "burried". SE wouldn't let me fix them - too small an edit. $\endgroup$ Commented Feb 3, 2012 at 8:51

My own background is in Computer Science proper, so my opinions may be a bit biased. Having said that, I'd add "basic algorithms and data structures" to the list. What I mean with basics are essentially linear searching and sorting, and data structures such as balanced trees, heaps and or hash tables.

Why? Well, in most computational algorithms, you end up spending an extraordinary amount of time and effort shifting data around and not actually computing anything. Ever implement a Finite-Element code? That's about 90% data organization. The difference between getting this done and getting it done well can be an order of magnitude in computational efficiency.

One minor Computer Science-related point I would also add is a short introduction on how a processor actually works and what it's good at and what it is not. For example:

  • Addition and multiplication are fast, division or transcendental functions are not. I've seen grown men replace a square root operation with something that required three divisions and think they've done something great (division and square root are just as expensive).
  • Level 3 caches are getting bigger every year, yes, but the Level 0 cache, i.e. the really fast one, is still only a few kilobytes.
  • Compilers are not magic. They may unroll small loops or vectorize extremely straight-forward operations, but they won't turn that bubblesort into a quicksort.
  • Calling methods on polymorphic objects with multiple inheritance in your innermost loop may be conceptually sweet, but it will make your CPU want to kill itself.

This is nitty-gritty boring stuff, but it takes just a few minutes to explain, and keeping it in mind will let you write good code from the get-go, or design algorithms that don't rely on nonexistent hardware features.

As to what to remove from the list, I think SQL is a bit much for Computational Scientists. Also, Software testing is important, but it is a science in itself. Unit testing and correct abstract data types are something that should be taught with basic programming, and does not require a two year master's programme.

  • 2
    $\begingroup$ Not boring at all. I'd take a course like that, if it was on offer. :-) $\endgroup$ Commented Feb 3, 2012 at 8:36

I might add to this later, but for starters, I'd take out "shell scripting" and replace it specifically with "Python scripting". Python is much more portable than shell scripting, and more readable than comparable shell and scripting languages. Its large standard library and popularity in the sciences (with the possible exception of biology, which also uses Perl) makes it a great computational lingua franca, not to mention a good first language for learning programming. It is now the first language taught to EECS majors at MIT, and it is popular in the job market, particularly in scientific computing. Its online documentation is extensive, and there are also a number of programming texts based on Python available online.

Using Python, you could teach basic programming constructs, as well as scripting. In addition, Python has excellent support for unit testing, so Python could be used to teach unit testing as well. Python also has an extensive database API (which could replace or augment having to learn SQL), and a couple build utilities that offer Make-like functionality. I personally prefer SCons over Make, because I find Python easier to document and test than shell scripts.

Ultimately, the motivating principle behind my blatant shilling for Python is efficiency. It's a lot easier to streamline your workflow if you can do most of your work in one language or one tool, especially when that tool is an expressive scripting language. Sure, I could do everything in C, but my program would be 5 times as long, and chances are, I don't need the speed. Instead, I can use Python to import data from a text file, plot it, call optimization routines, generate random variates, plot my results, write results to a text file, and unit test my code. If Python is too slow, it's possible to wrap Python around C, C++, or Fortran code that takes care of computationally intensive tasks. Python is, for me, a one-stop shop for most of my scientific computing needs.

Python isn't exactly MATLAB yet; SciPy and NumPy still have a ways to go in terms of functionality, but in terms of general utility, I use Python for a wider variety of tasks than MATLAB.

  • 7
    $\begingroup$ I can't help but completely disagree with this. Python is a headache for systems maintainers since it's a bit of a moving target. Computational scientists should have a basic understanding of bash or csh for the most rudimentary gluing of stuff together and running of jobs on the systems they're likely to use. Python is great, and I support you advocating for computational folks to learn it, but not at the expense of some rudimentary shell. $\endgroup$
    – Bill Barth
    Commented Feb 2, 2012 at 19:18
  • 9
    $\begingroup$ @BillBarth: I think every computational scientist has to learn basic bash or csh for very, very basic scripts. The reason I advocate using Python for shell scripting beyond those basic tasks is because I inherited a thousand-ish line bash script that essentially runs a program. It passes files back and forth as semaphores, repeatedly invokes PBS, and there's no way to test that at all. Shell scripting is great for small tasks, but not for large tasks, and this duct-tape-and-bubblegum nightmare has cost me a couple years of my thesis, which is why I'm insistent. $\endgroup$ Commented Feb 2, 2012 at 19:26
  • 2
    $\begingroup$ Like I said, I don't disagree that "learn python" might be appropriate for the list. I just don't want to do it at the expense of "shell scripting". Both are important, and no one's going to let you run ipython as your shell, so shell scripting is hugely important. $\endgroup$
    – Bill Barth
    Commented Feb 2, 2012 at 21:35
  • 3
    $\begingroup$ @BillBarth: Nowhere am I suggesting that Python replace the shell. I am only suggesting that Python replace bash for scripting; I believe that if you learn basic bash, you know enough to write scripts without control structures, so there's no need to go in-depth into "bash scripting". As soon as you want to include a control structure, you should switch to a different language, because programming in bash is a headache for software and library maintainers. $\endgroup$ Commented Feb 2, 2012 at 22:26
  • 1
    $\begingroup$ +1. Python has been my main programming language for some time. It isn't perfect, but it'll do till someone invents the perfect programming language. $\endgroup$ Commented Feb 3, 2012 at 8:43

Floating point math. Most science deals with real world values, and real world values are often represented as floating point in the computer world. There are many potential gotchas with floats that can wreak havoc on the meaningfulness of results.

The favorite reference for this topic seems to be "What Every Computer Scientist Should Know About Floating Point Arithmetic (1991)" by David Goldberg http://citeseerx.ist.psu.edu/viewdoc/summary?doi=

  • 1
    $\begingroup$ This document has been mentioned so many times on online forums. But it is a very long and dense article, and I'm not sure how many people have actually been able to take away something useful from this. $\endgroup$
    – johngreen
    Commented May 13, 2017 at 7:56

A computational scientist must have sufficient familiarity in computer science, mathematics, and an application field in science/engineering. I would include skills in each of the following areas:


  1. Numerical Analysis
  2. Linear Algebra
  3. Ordinary, Partial, and/or Stochastic Differential Equations
  4. Optimization
  5. Statistics and/or Probability
  6. Inverse Theory

Computer Science:

  1. Algorithms
  2. Data Structures
  3. Parallel Programming (MPI,OpenMP,CUDA, etc.)
  4. Scientific Visualization
  5. Computer Architecture
  6. Using a Linux Environment

Science / Engineering - depends on the application that you want to specialize in. In my particular case (engineering), I would add things like continuum mechanics, heat transfer, fluid dynamics, finite element method, etc. I would say that the more familiarity you have with multiple fields of science, the more versatile you are as a computational scientist.

  • $\begingroup$ Can you elaborate on "Inverse Theory"? $\endgroup$ Commented Feb 3, 2012 at 8:37
  • 1
    $\begingroup$ @FaheemMitha: Traditionally, we set the parameters of a model first (e.g. a partial differential equation), then observe the behavior of the system. An "inverse problem" is doing the reverse. We start with the observations of the output of the system, and try to determine the parameters of the model that produce these observations. Inverse theory describes methods for accomplishing this task. $\endgroup$
    – Paul
    Commented Feb 3, 2012 at 14:48
  • $\begingroup$ Thanks for the explanation. Do you have a good link/reference for this topic? $\endgroup$ Commented Feb 3, 2012 at 16:00
  • 2
    $\begingroup$ en.wikipedia.org/wiki/Inverse_problem is a good place to start. space.fmi.fi/graduateschool/Lectures07/HK_inversion.pdf has a nice overview too. But for a more indepth understanding I would recommend a book like amazon.com/Parameter-Estimation-Inverse-Problems-Second/dp/… $\endgroup$
    – Paul
    Commented Feb 3, 2012 at 16:30

Great question followed by fascinating answers! I would like to butt in with just one small addition. As far as I have experienced (myself and vicariously), an All-in-One tool is usually really good to know. Such a tool could be MATLAB, Octave or even Python (with libraries). Whenever you have a problem across your "comfort zone", a good idea (as far as I know and think) would be to try your hand at an All-in-One tool. You can try writing your own codes later. The beauty of such packages is that the programming doesn't interfere with the understanding of what you are doing.

Take an example of Computer Graphics. Writing a code for translation, rotation or scaling of a figure is 10 lines of code in MATLAB (tops) but it can run for pages in C. I'm not saying C is not good. All I am saying is that if you don't have a good reason to write codes in C, MATLAB would be a simpler, better and a more intuitive way out.

Some may disagree and state that C-like programming is a great way of building intuition. Maybe it is. But when you don't have to deal with a problem for more than a few times, it is hardly warranted to sit and write your own codes in a language like C.


Common sense and gut feeling... The latter comes only with time and after having "survived" a couple of shameful experiences in the big bad world.

  • 3
    $\begingroup$ I don't know if "gut feeling" is really a skill. It's more just an instinctive reaction to previous experience. $\endgroup$
    – naught101
    Commented Mar 30, 2012 at 12:36

Not the answer you're looking for? Browse other questions tagged or ask your own question.