This lesson is still being designed and assembled (Pre-Alpha version)

Intermediate Research Software Development in Python

This course is aimed at teaching a core set of established best practice software development skills for working as part of a team in a research environment (see detailed learning objectives below) using Python as an example programming language. 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 finished an undergraduate degree and, moving into academic research and needing to write some code, gained basic software development skills either by self-learning or attending, e.g., a novice Software Carpentry course (shell, Python, Git). However, their software development-related projects are now becoming more complex, larger, and involving more researchers and other stakeholders (e.g. users), for example:

Target Audience

This course is for you if:

This course is not for you if:

Prerequisites

To attend this course you should have either previously attended a Software Carpentry workshop within the last year, or 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
  • Optionally, you have experience using Git to push to or pull from a remote repository
  • Optionally, you have experience comparing various versions of tracked files or ignoring specific files

Python

  • You have basic knowledge and experience of programming in Python, for example using: variables, lists, conditional statements, functions and importing and using external libraries.
  • You have previously written at least a basic Python script or an iPython/Jupyter notebook to accomplish a task

Shell

  • You have experience using a command line interface (shell), such as Bash under Linux/Windows 10 or Git Bash under Windows 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

  • know how to set up and use a number of tools and own virtual environment to develop software collaboratively in a team
  • know how to set up a test framework to verify the correct behaviour of code
  • be able to design and write robust software
  • know how to publish and release your software

Schedule

Setup Download the software required for the lesson
Day 1 09:00 1. Setting the Scene What are we going to teach in this workshop?
Have you got all the necessary software installed?
09:30 2. Introduction to Software Design and Development Why is splitting an application into smaller functional units (modules) good when designing software?
What are programming interfaces in software design?
What is Model-View-Controller design architecture?
10:00 3. Integrated Software Development Environments What are Integrated Development Environments (IDEs)?
What are the advantages of using IDEs for software development?
10:30 4. Virtual Environments For Software Development What are virtual environments in software design?
What are the advantages of using virtual environments?
How to set up and manage a Python virtual environment?
How to install and manage Python third party packages?
11:00 5. Break Break
11:30 6. Python Coding Conventions Why should I follow software coding conventions?
Who is setting coding conventions?
What coding conventions exist for Python?
12:00 7. Collaborative Software Development Using Git and GitHub What are git branches and why are they useful?
What are best practices when developing software collaboratively using Git?
13:00 8. Lunch Break
14:00 9. Automatically Testing your 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?
14:30 10. 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?
14:45 11. Break Break
15:05 12. Continuous Integration for Automated Testing How can I apply automated repository testing to scale with development activity?
15:45 13. 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?
16:30 Finish
Day 2 09:00 14. Programming Paradigms How does the structure of a problem affect the structure of our code?
09:15 15. Object Oriented Programming How can we use code to describe the structure of data?
How should the relationships between structures be described?
10:15 16. 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?
11:00 17. Break Break
11:20 18. 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?
What should we do when our requirements change?
13:00 19. Lunch Break
14:00 20. Preparing Software for Reuse What can we do to make our programs reusable by others?
How should we document and license our code?
15:00 21. Break Break
15:20 22. Assessing Software for Suitability and Improvement What makes good code actually good?
What should we look for when selecting software to reuse?
16:00 23. Software Improvement through Feedback How should we handle feedback on our software?
How, and to what extent, should we provide support to our users?
16:30 Finish

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