Taking your learning further

This has just been a brief introduction to programming and Python. Remember, our aim with this course is to introduce you to the exciting world of programming and motivate the applications and what’s possible! Software is running the world, do you want to be part of the community that builds software? Was it exciting for you (even if it was a little challenging)? If so, that’s great – that’s what we wanted!

If you are excited and ready to dive in to new material, there are multiple things that you can learn next. Here are the topics I think would be excellent next steps to further your learning:

Object-oriented programming

This is a very important concept. It is fundamental to Python, and it would be a great next step. Object-oriented programming (OOP for short), represents the world as objects that interact with each other. For example, the robot project you worked on was an object. That object has a state (data associated with it) and methods (kinds of functions) that operate on that state. It’s a much more natural way to represent the world in a program! It would be good to learn about the basic idea of OOP, what encapsulation, inheritance, polymorphism, and abstraction are (the four pillars of OOP).

Data structures

This is an important concept that will help you learn more about algorithms. Data structures like arrays (or lists as they are called in Python) are important for algorithm design and programming. There are more to data structures than just arrays, but arrays are the most straightforward. Python has a very powerful dictionary data structure that underpins most of Python’s features, for example. It would be great if you learn about data structures (in a general way) and more specifically to Python: lists, tuples, sets and dictionaries.

Algorithm design

Learning how to solve problems will naturally bring you to the algorithm design world! It is a fascinating world but a challenging one. Learning different algorithms and how to create your own will be one of the most challenging things you will learn in programming. But it is fascinating and rewarding. I always get excited when I learn about a brilliant algorithm that solves a problem – for example, the solution I showed you for the L-shape puzzle is an example of great algorithm design! Learn about search and sorting algorithms first, but then expand and learn about other algorithms as you see fit.

Algorithm analysis

So you can design algorithms, but how efficient is your algorithm? Learning how to evaluate the efficiency of an algorithm will help you become a better computer scientist and programmer. There can be two or more algorithms that both work quickly enough with 100 inputs and produce the same result, yet one may be much more efficient both in terms of space and running time. This efficiency will usually shine when you start having large inputs, in the order of hundred of thousands, millions or billions of input points. This is known as the time and space complexity of an algorithm, and describes how well an algorithm scales as the input to the algorithm grows.

Consider the problem of searching through a list of items (numbers, strings, etc.) to find an item. An algorithm, with linear time complexity, will pass through all elements and check if the item we are looking for is in the list. The time it takes to complete, therefore, will grow linearly with the size of the input. If we have (100{,}000) items, in the worst case, it will perform (100{,}000) checks (the item we are looking for appears at the end of the list, so we pass through everything). Can we do better? Well there is an algorithm called Binary Search, which, under the condition that your list of items is sorted, will be able to search through for an item in (log_{2}(n)) time. This means that for (100{,}000) items, in the worst case, it will perform(log_{2}(100{,}000) approx 17) checks (compare (17) with (100{,}000) !!!!). Now scale the list from (100{,}000) to (100{,}000{,}000). Binary search will be able to search through and find an item (if one exist) after (log_{2}(100{,}000{,}000) approx 27) checks in the worst case, compared to (100) millions of checks it will take for the other algorithm with linear time complexity in the worst case.

Huge savings! Imagine how important it is for Google, for example, to have such efficient algorithms that can search quickly through billions of records (hint: look how fast Google returns results in a split second).

Learn another programming language

Finally, it would be good to throw a challenge to yourself once you get more familiar with Python and learn a new programming language. Pick a language that either will teach you something completely new or, better, a language that will let you build something you really want or get you into an industry you want. Do you want to build web applications? Perhaps learn Javascript and React. Do you want to build iOS apps? Learn Swift (although you will need a Mac computer). Do you want to build Android apps? Learn Kotlin. You should make an informed choice about what you want to learn! If you want to get into the mobile app development space, learning Kotlin or Swift will be 2-in-1.

Watch our YouTube live stream event

Watch Rafael Papallas (the author of this course) and colleague Amy Brereton answer questions about getting started in a career in tech.

 Edtech Inspirators: A career in coding with Click Start 

Keep the learning journey alive!

Join more courses on the Click Start programme. From coding to data and web development, and professional skills in areas like decision-making, problem solving and communication, make your CV stand out.

If you’ve loved your time learning with the University of Leeds, why not dive into more exciting online courses offered by us? There’s always something new to discover!

Your feedback is valuable

If you have enjoyed the course, help other learners find it, by rating it on Class Central.