What core skills should every computational scientist have? [closed]

Question

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.

Answer 1

"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).

Mathematics

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.

Tools

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

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.

Answer 2

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.

Answer 3

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.

Answer 4

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=10.1.1.22.6768

Answer 5

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:

Mathematics:

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.

Answer 6

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.

Answer 7

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.