Table of Contents
- Getting Started
This page serves as a learning guide for the important skills of a quantitative developer. It is primarily inspired by the QuantStart Self-Study Plan for Becoming a Quantitative Developer. The skills are divided in four rough and overlapping categories:
- Programming: The ability to solve a problem in a specific programming language.
- Editor / IDE: The ability to get the most out of your editor or IDE, which makes a large difference to productivity.
- Version Control: Good version control practices. No more “Save As”.
- Software Development: Knowledge of how to engineer good, maintainable software as well as how to manage software-based projects.
The intention is to build a solid foundation in each of these areas and then specialize as needed. Our goals are three-fold:
- Become productive as quickly as possible. This is to justify the investment both to ourselves and our employers as necessary.
- To learn together. The learning process works best with other people. We are all going to use the same tools and commit to the same deadlines so that we can discuss the problems that arise and help each other out.
- Develop skills that are relevant to our further career development. As much as possible, we want to learn skills that are future proof and not only specific to our current role and environment.
In light of these goals, I cautiously make the following recommendations: For programming languages, we will learn Python and C++. As an editor, we will use Visual Studio Code. In terms of version control, we will learn the ubiquitous Git and host our personal learning projects on GitHub. I don't know much about software development at this stage, so we'll stick to the recommendations made in the self-study guide above.
This guide assumes that you're using Windows. You'll need to install the following software:
- Visual Studio Community Edition (For C++ development only, and you'll need admin rights)
- Visual Studio Code
- Git for Windows
- The default options should all be fine.
- Miniconda for Python 3.x (We'll use this to manage our Python environments)
Once all the necessary software is installed, we'll need to set up some things. The first thing to do is go create a personal GitHub account so that you can start practicing your version control as we work through the exercises. Then we can start setting up our development environments.
Getting Started with Visual Studio Code and Python
To get started, we will work through the official Getting Started with Python in VS Code tutorial, but first note the following:
- VS Code extensions can be installed by clicking on the
Extensionsbutton on the left-hand side of the VS Code window and then searching for the appropriate extension and clicking
- I recommend you create a single folder for all your python code, with your projects as subfolders. For example,
C:\dev\python\hellofor the ‘‘hello’’ project in the tutorial.
- When the official tutorial says ‘‘At the command prompt or terminal’', we will use our Anaconda prompt, which was installed along with Miniconda. I recommend you pin the Anaconda prompt to your start menu, or add it as a desktop icon.
- When the tutorial discusses selecting the Python interpreter, you should select the one containing
('base':conda). This is because we are using Conda as our Python package and environment manager.
- On your first try, consider skipping the section on debugging, and rather move on to the example below. Although configuring the debugger is very useful, and we will use it later, it can be intimidating.
- DON'T follow the instructions in the Install and use packages section of the tutorial! We won't be mixing virtual environments with our Conda environments. See below instead.
Packages and Environments with Conda
Following on from the tutorial, create a new file called
standardplot.py and copy and paste the following code:
import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 20, 100) # Create a list of evenly-spaced numbers over the range plt.plot(x, np.sin(x)) # Plot the sine of each x point plt.show() # Display the plot
This code won't run, because the
matplotlib package is not installed in the current environment, known as
base. So we're going to create a new environment for our program, activate it (switch context to it) and then install
matplotlib. Then we can select the new environment as our Python interpreter and run the above code.
In the Anaconda prompt (the one you used to start VS Code, NOT the integrated terminal inside VS Code), create a new environment called
tutorial using the Conda command:
conda create --name tutorial
(If you get a
bad handshake error, check out this link.)
Then switch to the environment, by activating it:
Now we'll use Conda as a package manager to install the
matplotlib package in our new
tutorial environment (along with all its dependencies):
conda install matplotlib
Once this is completed, restart VS Code. Use the command palette to select a Python interpreter (as we did in the start of the tutorial), but now select the interpreter associated with your new environment,
tutorial. You'll now be able to run the new file and use the
For a handy reference to the Conda commands, see the official cheat sheet. To learn more about using Conda as the Python environment and package manager in VS Code, see Using Python environments in VS Code.
The idea is to use reference material that comes recommended by experienced developers (thanks Reddit and StackOverflow) and is established enough that a consensus has been reached on the quality. We want to be idiomatic from the start: let's learn the language as if we didn't know any other.
- “Programming: Principles and Practice Using C++” by Stroustrup.
- “Accelerated C++: Practical Programming by Example” by Koenig and Moo.
- “Effective C++” by Meyers.
- The Official Python Tutorial.
- “Effective Python: 59 Specific Ways to Write Better Python” by Slatkin.
- “Python Cookbook: Recipes for Mastering Python 3” by Beazly and Jones.
- “Fluent Python: Clear, Concise and Effective Programming” by Ramahlo.
I have not yet found a project- or outcome-based VS Code tutorial and this is ideally what we would've like to do first. Perhaps we should make one.
- “Code Complete: A Practical Handbook of Software Construction” by McConnel.
- “Clean Code: A Handbook of Agile Software Craftsmanship” by Martin.