This lesson is being piloted (Beta version)

Intermediate Research Software Development in Python

This course aims to teach a core set of established, intermediate-level software development skills and best practices for working as part of a team in a research environment using Python as an example programming language (see detailed learning objectives below). The core set of skills we teach is not a comprehensive set of all-encompassing skills, but a selective set of tried-and-tested collaborative development skills that forms a firm foundation for continuing on your learning journey.

A typical learner for this course may be someone who is working in academic research and, needing to write some code, has gained basic software development skills either by self-learning or attending, e.g., a novice Software Carpentry Python course. They have been applying those skills in their domain of work by writing code for some time, e.g. half a year or more. However, their software development-related projects are now becoming larger and are involving more researchers and other stakeholders (e.g. users), for example:

They now need intermediate software engineering skills to help them design more robust software code that goes beyond a few thrown-together proof-of-concept scripts, taking into consideration the lifecycle of software, writing software for stakeholders, team ethic and applying a process to understanding, designing, building, releasing, and maintaining software.

Target Audience

This course is for you if:

This course is not for you if:

Prerequisites

To attend this course you should meet the following criteria. You can also test your prerequisite knowledge by taking this short quiz.

Git

  • You are familiar with the concept of version control
  • You have experience configuring Git for the first time and creating a local repository
  • You have experience using Git to create and clone a repository and add/commit changes to it and to push to/pull from a remote repository
  • Optionally, you have experience comparing various versions of tracked files or ignoring specific files

Python

  • You have a basic knowledge of programming in Python (using variables, lists, conditional statements, functions and importing external libraries)
  • You have previously written Python scripts or iPython/Jupyter notebooks to accomplish tasks in your domain of work

Shell

  • You have experience using a command line interface, such as Bash, to navigate a UNIX-style file system and run commands with arguments
  • Optionally, you have experience redirecting inputs and outputs from a command

Learning Objectives for the Workshop

  • Set up and use a suitable development environment together with popular source code management infrastructure to develop software collaboratively
  • Use a test framework to automate the verification of correct behaviour of code, and employ parameterisation and continuous integration to scale and further automate your testing
  • Design robust, extensible software through the application of suitable programming paradigms and design techniques
  • Use a critical, reflective mindset to prepare and release your software for reuse by others
  • Manage software improvement from feedback through agile techniques

Schedule

Setup Download software required for the course
00:00 Setting the Scene For the Workshop What are we teaching in this course?
Why did we pick specific topics to cover?
Section 1 00:00 Section 1: Setting Up Environment For Collaborative Code Development What tools are needed to collaborate on code development effectively?
00:10 Introduction to a Software Project What is a design architecture of a software project?
Why is splitting code into smaller functional units (modules) good when designing software?
00:40 Virtual Environments For Software Development What are virtual environments in software development and why you should use them?
How can we manage Python virtual environments and external (third-party) libraries?
01:10 Integrated Software Development Environments What are Integrated Development Environments (IDEs)?
What are the advantages of using IDEs for software development?
01:50 Collaborative Software Development Using Git and GitHub What are Git branches and why are they useful for code development?
What are some best practices when developing software collaboratively using Git?
02:35 Python Coding Conventions Why should you follow software coding conventions?
Who is setting coding conventions?
What coding conventions exist for Python?
03:15 Section end
Section 2 00:00 Section 2: Ensuring Correctness of Software at Scale What should we do to ensure our code is correct?
00:05 Automatically Testing Software Does the code we develop work the way it should do?
Can we (and others) verify these assertions for themselves?
To what extent are we confident of the accuracy of results that appear in publications?
00:55 Scaling Up Unit Testing How do we scale up the number of tests we want to run?
How can we know how much of our code is being tested?
01:10 Continuous Integration for Automated Testing How can I apply automated repository testing to scale with development activity?
01:55 Diagnosing Issues and Improving Robustness Once we know our program has errors, how can we locate them in the code?
How can we make our programs more resilient to failure?
02:45 Section end
Section 3 00:00 Section 3: Software Architecture and Design How can we use common patterns and paradigms to improve the sustainability of our software?
00:05 Programming Paradigms How does the structure of a problem affect the structure of our code?
00:20 Object Oriented Programming How can we use code to describe the structure of data?
How should the relationships between structures be described?
01:10 Functional Programming What is a function really?
How can we be sure our code does the same thing every time?
What is the difference between data and code?
What do we need to do differently when working with Big Data?
01:50 Software Design Where do we start when beginning a new software project?
How do people use software?
How can we make sure the components of our software are reusable?
How do we add components to an MVC application?
02:25 Persistence How can we store and transfer structured data?
How can we make it easier to substitute new components into our software?
03:15 Section end
Section 4 00:00 Section 4: Improving and Managing Software Over its Lifetime What should we do to enable software reuse, encourage external feedback, and act on it?
00:05 Preparing Software for Reuse What can we do to make our programs reusable by others?
How should we document and license our code?
01:00 Assessing Software for Suitability and Improvement What makes good code actually good?
What should we look for when selecting software to reuse?
01:45 Software Improvement Through Feedback How should we handle feedback on our software?
How, and to what extent, should we provide support to our users?
02:35 Section end
00:00 Wrap-up Looking back at what was covered and how different pieces fit together
Where are some advanced topics and further reading available?
00:15 Finish

The actual schedule may vary slightly depending on the topics and exercises chosen by the instructor.