Self-Paced, Instructor-Assisted Approach to Teaching Python Programming

Abstract

We present a novel self-paced, instructor-assisted approach to teaching Python programming in a college classroom environment. Instead of listening to a lecture and doing homework on their own later, students work actively 100% of the time, using an advanced interactive learning platform combined with real-time individual assistance of their instructor. Instead of lecturing, the instructor walks through the classroom and assists students individually. This makes a huge positive difference for the students, and it also allows the instructor to understand much better how each student performs and where they need help. After numerous years of using this approach, we are convinced that nothing can replace a one-to-one interaction between the student and his/her instructor. Unfortunately, traditional classroom lectures are not consistent with this teaching style. On the contrary, the mostly uni-directional flow of information from the instructor to the class effectively shields the instructor from interacting with the students. We describe various aspects of the self-paced, instructor-assisted method and show that it has a major positive impact on the students. Students find it extremely helpful being able to digest the material at their own pace. They also get a lot more practice compared to the standard lecture $+$ homework model, develop good programming habits, and become skilled and experienced programmers. This method makes students better independent learners, problem solvers, and communicators. Our findings are based on 10+ years of teaching Python programming courses to diverse audiences in this way. Results of a sample student survey and student testimonials are presented.

Appendices

Appendix A: Traditional Instruction Versus Self-Paced Learning By Doing From a Student’s Point of View

My name is Alexander Freyer, and I am studying medical informatics/computer science at the University of Lübeck in Germany. This year, I took a one-semester break from my university study to expand my Python skills with the help of NCLab’s Python Developer career training. I decided to do this because good knowledge of Python is essential for my future success, and I felt that my university was not giving me those skills. I am grateful for this opportunity to discuss how my experience with the NCLab’s self-paced teaching method compares to my university studies.

Earlier this year, I was preparing for my winter exams. Some of the modules I had to study were ‘Introduction into Programming’ with Java as the given language, as well as ‘Medical Image Reprocessing,’ which used Python. In all honesty, I felt completely overwhelmed. I did not understand anything, nor did I know where to start. All I knew about were if-else statements, the while-loop, and how to write the famous ‘hello world’ program. That was it.

Let me explain the cause of my struggles. The class consisted of 90-min lectures or seminars in which the professor or tutor would explain concepts with the help of Powerpoint slides filled with large amounts of code. We were sometimes encouraged to apply the information and program in real-time which was quite helpful. However, once I lost focus, I had no clue how to approach the next line of code. That struggle continued for an entire semester.

Knowing that I needed to do something about it, I googled how to begin coding and which language I should start with. In one YouTube video, an experienced programmer suggested that newbies start with Karel. “Learning a language is like driving a vehicle,” he explained. Once you get your driver’s license, it doesn’t really matter what car you drive. Although the experience may vary slightly, the traffic rules remain the same.

So, I went searching and found the famous book, Karel the Robot: A Gentle Introduction to The Art of Programming, by Pattis [25]. I also came across the short free Karel sampler course [22] from NCLab.

Who is Karel the Robot? Karel is a simple robot that can be programmed to solve mazes using very basic commands such as ‘go’ (move one square forward), ‘left’ (turn 90 degrees left), ‘right’ (turn 90 degrees right), ‘get’ (collect an item from the ground beneath you), and ‘put’ (place an object from your backpack on the ground where you stand). It also has the counting loop ‘repeat’, the conditional loop ‘while’, ‘if-else’ and ‘if-elif-else’ conditions, the keyword ‘def’ to define new commands, it can use functions, variables, recursion, even Python lists, etc.

The Karel language is almost just abbreviated English, but that makes it really efficient for teaching algorithmic thinking, problem solving, and programming logic. This language was designed in the 1980s at Stanford. Back then it was similar to Pascal, but a few years ago Dr. Solin adjusted it and expanded to be similar to Python, because Pascal is no longer a leading programming language today. Dr. Solin’s textbook Learn How to Think With Karel the Robot is freely available online [34].

After completing the sampler course, I regained confidence in my knowledge and skills. But why was this the case?

For instance, I finally really understood the concept and purpose of the ‘while’ loop. Sometimes Karel was in front of a wall, and had to do something while the wall was in front of him, such as to look for a corner. Sometimes he had to walk straight to the next wall (while a wall was not in front of him). Or, he needed to place objects from his backpack on the ground until the backpack was empty (= while it was not empty). At another time, he had to turn left until he faced North (= while he did not face North).

In one of the tasks, I even wrote unknowingly the First Maze Algorithm (FMA), which was a great feeling. For illustration, Fig. 1 shows a sample maze where the FMA is used. In this maze, Karel’s objective is to collect all tulips and roses (collectible objects), avoid water (obstacle), and enter the home square (Karel’s destination):

Fig. 1

Sample maze which includes water (obstacle), tulips and roses (collectible objects), and the home square (Karel’s destination)

Fig. 2 presents a program that uses the FMA. This algorithm guides Karel to pass through an arbitrary labyrinth where the path is one square wide, and can only go straight, to the left, or to the right. The program below will guide Karel through the maze from Fig. 1, collecting all tulips and roses, until he enters the home square:

Fig. 2

Program based on the FMA which guides Karel to the home square, collecting all tulips and roses

The sampler course proved to be extremely helpful, therefore I decided to enroll in the full-length Computational Literacy course from NCLab. This was an extraordinary experience. Let me tell you why.

In this course I felt guided. I had a starting point. There weren’t dozens of slides to investigate. The information was delivered in a concise and comprehensive way, and examples for concepts were always provided. We were able to step through the code line by line and see what actually happens. Sometimes, solving tasks required me to think deeply and come up with creative solutions. I remember a task where Karel should find out whether there is a gem in each aisle or not. It took me quite a while before I could come up with an idea. It actually came to me when I was lying in bed. I grabbed my notebook, wrote it down, and tried it out. It worked!

These moments of excitement, clarity, and inspiration never happened in my university’s programming course. There, often I just hoped that some friend would give me the code so that we could get done with the task as quickly as possible. As a result, I did not learn much. Even though the NCLab’s Karel course was challenging at times, I never felt lost. I could review my notes, use the hints, and even reach out to the support team which answered my questions within a few hours.

In my university’s programming course, the professor would tell us the solution, as well as the most common mistakes. But when you have no base, it is hard to understand and to follow. For example, he recommend doing W3Schools tutorials or buying some textbook. However, the information was quite overwhelming for a beginner. Also, it always was about the language itself and the syntax, rather than about the logic of programming. This I found weird because the module was called ‘Introduction to Programming’. How should one think to find the solution of the task? What is actually happening behind the scenes? These questions were answered for me in the NCLab’s Karel course.

In conclusion, the NCLab’s Karel course helped me discover that I really enjoy computer programming. After finishing it, I enrolled into the NCLab’s Python Developer career training. This training was every bit as good as the Karel course. It gave me lots of practice, and made me job-ready. This training is aligned with the PCEP$^{{{\texttt {TM}}}}$ (Certified Entry-Level Python Programmer) exam [29] by the Python Institute. It prepared me for the PCEP exam really well. After finishing it, I passed the exam with a score of 96%, and landed an entry-level Python position at a big company located in Germany.

Because the NCLab’s self-paced teaching method works really well for me, currently I am enrolled in the Advanced Python Developer career training. Here I am learning object-oriented programming, event-driven programming, and various advanced Python and Computer Science concepts. When I finish it, I will be ready to take the next-level PCAP$^{{{\texttt {TM}}}}$ (Certified Associate in Python Programming) exam [28] of the Python Institute.

Appendix B: Python Curriculum in NCLab

NCLab provides two Python career training programs which produce job-ready Python programmers. The Python Developer career training is aligned with the Python Institute’s PCEP certification [29], and the Advanced Python Developer career training is aligned with the Python Institute’s PCAP certification [28]. The former consists of the following self-paced courses and software projects:

• Introduction to Python: This course provides a detailed and comprehensive overview of the Python programming language. Students learn Python by solving programming problems of gradually increasing complexity, using simple calculations, loops, conditions, local and global variables, functions, ternary conditional expressions, and basic exceptions handling. Students also become proficient in working with fundamental Python data structures, including tuples, lists, and dictionaries. Throughout the course, students are developing a good Python coding style and other good coding habits.

• Working with Text in Python: More than 80% of work computers do is processing text. In this course students learn how to process, analyze, and manipulate text strings with Python.

• Plotting and Drawing with Python: Python is known for its powerful graphic capabilities. In this course students learn how to use the powerful Python library Matplotlib for plotting and drawing.

• Software Project 1 (Graphics Editor): Students build their own Graphics Editor based on Matplotlib. The Graphics Editor is able to create shapes such as squares, triangles, rectangles and circles, fill objects with color, move, scale and rotate shapes, and combine them to make complex drawings. In addition to substantial programming practice, this Software Project provides students with a valuable insight into the principles of good software design.

• Working with Files in Python: Most data are stored in files. Therefore, this course teaches students how to open files, read data from them, process the data, and write back to files.

• Software Project 2 (Image Viewer): Students build their own Image Viewer in Python. The Image Viewer is able to read bitmap images from files, store them as 2D Numpy arrays, and visualize them with Matplotlib. In this Software Project students practice working with files, text strings, and the Numpy and Matplotlib libraries.

• Data Visualization with Python: The world we live in is driven by data. Therefore, in this course students learn how to visualize data in the form of simple graphs, bar charts, pie charts, color maps, surface plots, wireframe plots, and contour plots. Students also learn how to visualize data on 2D Cartesian grids and unstructured triangulations.

• Data Analytics Minimum: Most real-life applications of Python are to some extent related to Data Analytics (DA). Therefore, the DA Minimum course teaches students how to use the Pandas library and perform elementary Data Analytics with Python.

• Computer Science Minimum: Every Python developer must know the basics of Computer Science (CS) including the binary, octal, and hexadecimal numeral systems, and bitwise operators. These are also required for the PCEP exam. That’s exactly what students learn in this course.

• Intermediate Topics in Python: This course covers selected intermediate Python concepts including variadic function, anonymous (lambda) functions, built-in functions any(), all(), map(), filter(), reduce(), eval() and exec(), iterables and iterators, and generator functions and generator expressions. Students also gain a deeper insight into mutability, shallow and deep copying, and exceptions handling.

• PCEP Preparation Course: This course includes several PCEP [29] practice exams and prepares students to score high on the PCEP exam. PCEP is an industry-recognized certification from the Python Institute that will add a significant weight to students’ resumes. Students are encouraged to take the PCEP exam before starting to work on their Capstone Project.

• Capstone Project: Students choose one of two options:

  • Option 1: Look up open source projects on Github, find one that they like, and contribute to it by submitting a pull request. Their contribution must be consulted and approved by their instructor in advance.

  • Option 2: Implement their own program in Python and upload it to Github. The topic of the program is chosen by the student, but must be consulted and approved by their instructor in advance. Typically, a more substantial program is required compared to Option 1.

  In both cases students are required to create a free Github user account, and to install a Python IDE on their own computer or laptop.

The Advanced Python Developer career training comprises the following self-paced courses and software projects:

• Software Project 3 (Digital Computer): In this software project students use Python to simulate logic gates, binary adders and multipliers, and implement their own simple model of a digital computer in Python.

• Object-Oriented Programming 1: This course covers the basics of OOP including the history of programming languages, how OOP evolved from procedral programming, the concept of encapsulation, classes, attributes, methods, and instantiation.

• Software Project 4 (Turtle Graphics): In this software project students implement their own version of the Python Turtle Graphics.

• Object-Oriented Programming 2: This course covers inheritance and advanced concepts of OOP such as abstract classes and methods, polymorphism, multiple inheritance, mixin classes, the Diamond Problem, and the Abstract Base Classes (ABC) module.

• Software Project 5 (OOP Upgrade of the Graphics Editor): Students use inheritance, polymorphism, and multiple inheritance to upgrade their Graphics Editor from Software Project 1 to an OOP design.

• Event-Driven Programming: Students learn even-driven programming while implementing the well-known desktop game Othello (Reversi).

• Advanced Topics in Python: This course covers selected advanced Python concepts including advanced applications of recursion to Polish (prefix) notation and binary trees, names and namespaces, packages and modules, decorators, making Python classes callable, working with JSON and XML data, etc.

• PCAP Preparation Course: This course includes several PCAP practice exams and prepares students to score high on the PCAP exam [28].

• Capstone Project: Substantial Python software project based on student’s own choice. Instructor’s approval of the topic, and working in Linux is required.

All of NCLab coursework is ADA compliant [1].

Appendix C: Sample Autograded Python Exercise

Providing instant feedback to students, and validating their understanding of the subject is absolutely crucial in their learning process. Therefore, below we present a sample exercise and show how NCLab performs grading. The exercise is related to recursion:

Write a recursive function permute(L) which for a list L returns a list of all permutations of L (i.e. a list of lists)! Do not use itertools. The Math and Numpy modules also provide functions to calculate permutations, but do not use them either. Do not change the main program. Expected output:

Then follows the expected output of the main program:

[1, 2, 3, 4] [1, 2, 4, 3] [1, 3, 2, 4] [1, 3, 4, 2] [1, 4, 2, 3] [1, 4, 3, 2] [2, 1, 3, 4] [2, 1, 4, 3] [2, 3, 1, 4] [2, 3, 4, 1] [2, 4, 1, 3] [2, 4, 3, 1] [3, 1, 2, 4] [3, 1, 4, 2] [3, 2, 1, 4] [3, 2, 4, 1] [3, 4, 1, 2] [3, 4, 2, 1] [4, 1, 2, 3] [4, 1, 3, 2] [4, 2, 1, 3] [4, 2, 3, 1] [4, 3, 1, 2] [4, 3, 2, 1]

Matching this output successfully is the first test which allows the students to see immediately if their function produces an incorrect result. But even if they match the expected output successfully, additional tests will be performed.

There is a large number of various grading criteria a course designer can choose from. One of them is a list of forbidden keywords. In this particular exercise, the forbidden keywords include “import” which prevents students from importing itertools, math or numpy and using recursion from there.

In the code input cell the students find the main program (which they know they must not change). They also know that the ellipsis “...” is to be replaced with their function permute(L):

Some students will be able to figure out the solution on their own, others will need help. For the latter group, there is always a hint. In this case, it walks them through the algorithm for permutations of a three-item list:

Here is the main idea, illustrated on a 3-item list L $=$ [1, 2, 3]:

• Extract from [1, 2, 3] the first item 1. The remainder of the list is [2, 3]. Obtain all permutations of this shorter list recursively. These are [2, 3] and [3, 2]. In both cases insert the item 1 back at the beginning, obtaining [1, 2, 3] and [1, 3, 2].

• Extract from [1, 2, 3] the second item 2. The remainder of the list is [1, 3]. Obtain all permutations of this shorter list recursively. These are [1, 3] and [3, 1]. In both cases insert the item 2 back at the beginning, obtaining [2, 1, 3] and [2, 3, 1].

• Extract from [1, 2, 3] the third item 3. The remainder of the list is [1, 2]. Obtain all permutations of this shorter list recursively. These are [1, 2] and [2, 1]. In both cases insert the item 3 back at the beginning, obtaining [3, 1, 2] and [3, 2, 1].

The solution to this exercise is as follows. Students will see it in a side-by-side comparison with their own code once their function passes the grader:

The students can run their program as many times as they want without penalties. But when they press Submit, their code is sent to a remote server for grading. Below we show the main parts of the autograding code for this particular exercise.

The grader begins with checking if the name “permute” is defined in the first place:

As a next test, the grader checks if the name “permute” is a callable function (in this code snippet as well as in the following ones, lines are artificially wrapped with the backslash symbol ‘$\setminus$’ to fit the page width):

Then follows the master solution permute_sol_(L) which is used to check the results of the student’s function (the code is the same as above, therefore we won’t repeat it here):

Finally the student’s function is called with several test lists, and the result is compared to the result produced by the master solution permute_sol_(L):