During the past two weeks, I have been working on my final project with Python — a COVID-19 simulation. This post will outline wisdom and progress gained, as well as my plan for In-Depth Night, which is quite simple.

My plan for In-Depth Night.

The culmination of my Python journey has been the COVID-19 simulation, and thus it fits that it will be what I will be demonstrating at a table booth. The simulation is an excellent representation of my learning because everything I’ve learned is there; from classes and exceptions handling to the strategies Bill has taught me. For example, my mentor Bill taught me how I should structure and approach writing a program, how to find resources to learn about what I do not know, and the fact that I should not attempt to memorize concepts and instead focus on understanding them. 

I applied such strategies and managed to learn matplotlib, tkinter, as well as the SIR model from scratch, using resources ranging from Python references and academic papers to video tutorials on Youtube. Regarding my “approach” to writing the program, I first created a plan (that I reviewed with Bill), listing many of the modules and methods I would use, and even created two separate files (for each class) as Bill had suggested. This overall development process that he had introduced to me ultimately made writing the program far easier and more fluid; I did not “drown” within the lines of code as I had previously when writing the two milestone projects.

How does this relate to In-Depth Night? Put simply, although none of this will be directly apparent/obvious to the audience, my progress and learning are ingrained everywhere and it is particularly evident to me. Simply comparing how I wrote the program (all described above) and the code itself to Python projects I had created before this year’s In-Depth allows one to see obvious differences and progress.

The audience will interact with my In-Depth by modifying the parameters/scenarios of the simulation. COVID-19 influences virtually every part of our lives, and it is quite imperative to understand how what we do can affect the outcome. Thus, the simulation is designed to be as informative as possible — in fact, Bill and I’s goal initially was to be able to draw conclusions about the pandemic from it. Naturally, accomplishing this goal makes it educative and worth the viewer’s time.

For example, different variables that the audience can interact with will include common terms we hear when referring to the pandemic, such as social distancing, vaccines, masking wearing, travel restrictions, and general public health guidelines. Ultimately, my goal is to make the simulation as user-friendly and as user-oriented as possible, similar to how professional programmers design applications and operating systems meant for users to interact with. This also involves making an aesthetically pleasing and intuitive user interface (more on making the simulation user-friendly next).

Apart from the program, I will also make my table booth eye-popping by creating a physical information board that has a heading that “advertises” my project.

Wisdom and progress!

As for progress, I worked on the GUI (graphical user interface) and created a plot based on the SIR model. I separated the program into two parts, one for each class; the first plots an animated graph using the SIR model’s rates of change, while the second class creates a GUI that allows the user to set the variables. 

The Simulation class (see the image above) imports the matplotlib, time, as well as random modules. The init method sets up all the variables used in the SIR model, some of which can be modified by the user. The generate method applies the SIR model, and its output is plotted by the animate method using matplotlib’s FuncAnimation, which allows one to repeatedly call generate, producing SIR model values iteration-by-iteration. Note that nothing is called at the end of this program (everything is just defined).

Why? The GraphicalUserInterface class imports tkinter, PIL (used to process images), and plotting, the latter of which is the class described above. The homepage method (see the image above) sets up the basic tkinter window, creating frames (where objects can be then placed inside) and using Label() and Button() to create the introductory message and “Begin Simulation” button. When the user clicks the button, it calls the next method, customize (see image below), which allows the user to modify the variables of the SIR model with Entry(). I also make sure the user’s inputted numbers are within a specified range, and when they click the button, the matplotlib simulation from the other program itself is called. Finally, tkinter uses mainloop() to handle all the events that occur, for example, the clicking of a button object.

Below are images of the GUI and simulation. The first two are the GUI produced by homepage and customize, respectively, while the bottom image is the plot. Blue is the number of infected, orange is the number of removed, while grey is the rest of the population that is still susceptible. Note, however, that this program is far from complete (illustrated next).

From Bill, I learned that whenever I implement the various aspects/features, I should always work towards improving the user experience. For example, Bill stated that the SIR model should be incorporated in such a way so that it is easily understandable and clearly applicable to COVID-19 in real life, which, as described, is the purpose of this program in the first place. This means doing the opposite of what my program prompts the user to do right now (in the screenshots above).

For example, when asking for user input (to modify the coefficients/rates of change, instead of simply asking, “What value would you like the infection rate to be?,” which no one knows how to translate into the pandemic real life, I should use terms such as social distancing, mask-wearing, number of contacts, etc. Another idea Bill and I came up with was to create various presets to represent common scenarios.

In turn, since this requires modifying the equations within the SIR model, Bill believes that the best way to do this is by looking at scientific papers on the topic and observing how they either set values for the rates of change (based on a certain aspect of COVID-19 in real life) or modify/add to the system of equations entirely (to incorporate more variables apart from simply the infection/removed rates). 

Additionally, to improve the user experience, I also need to make the GUI more polished — currently, I believe that it is in its infancy and requires many improvements (obvious from looking at the images above). To accomplish this, I will base my GUI on commonly used applications such as Google Chrome and Microsoft Teams (or macOS/Windows).

That concludes this post! I would like to thank my mentor Bill once more — his help has been absolutely invaluable to me and I cannot imagine working on this project without his dedication and kindness!

Welcome to my fifth post on learning Python! I have had one meeting with my mentor Bill since the last post, I completed the course, and I created a plan for my COVID-19 simulation which Bill and I then reviewed. Today’s progress and “wisdom” reports will be merged in Question 7 because it is difficult to discuss one without referring to the other.

1. What kinds of learning opportunities does your mentor provide to expose you to new learning?

My mentor exposes me to new learning opportunities by guiding and pointing me in the right direction. He never directly tells me what to do; instead, Bill demonstrates his processes, the websites he uses, or simply even plants the seed of an idea and lets me follow through. In short, he acts as the facilitator while I work autonomously.

For example, this occurred with the COVID-19 simulation — Bill took initiative by shifting the conversation to the final project and offering possible ideas. Both he and I were particularly interested in pursuing something related to the real world, instead of following the trend of designing a video game or app. Bill then showed me a couple of resources (regarding the SIR model) to give me ideas, but left it open-ended, allowing me to approach the project in any direction I would like.

Later, when working on the plan for the simulation, I often found myself modelling my learning approach after what I had learned from Bill. For example, I used videos, academic papers, as well as Python language references, none of which I have used before when researching Python specifically. I would start with either a paper or a Python reference, but if the topic was too complicated, I took advantage of videos for visual aid (they were particularly helpful when learning about the SIR model and Matplotlib; more on this later).

2. What kinds of learning opportunities exist to reinforce new learning?

The primary learning opportunity that reinforces my learning is the COVID-19 simulation project I am currently doing. My goal is to apply as many concepts as possible that I have learned from the course and ultimately cement my knowledge.

For example, one of the most significant milestones in my learning so far has been learning how to use classes. My learning — watching the videos in the course — was reinforced first through basic exercises, then a challenge (both provided by the course), and finally the milestone project (Blackjack), where using classes was required. I needed to fully exploit the capabilities of classes (at least as far as I had learned) to create the Blackjack game; it was not only practice but also helped me to identify any weak points in my knowledge. Now, the COVID-19 Simulation will cement my familiarity with classes — I will be using two to handle the two main components: Graphing the simulation and having an interactive GUI. Thus, learning opportunities that reinforce new learning come naturally when practicing/applying concepts in programming, for it is full of trial and error.

3. What kinds of opportunities exist that might accelerate learning?

Similarly, how Bill and I have decided to approach my learning Python places emphasis on autonomy; I can choose to learn/work as quickly as I would like, as long as I am certain that I fully grasp what I am learning/applying.

For example, the course, its milestone projects, and the final project I am working on are all self-directed and I can choose to complete them faster than planned, either if I have the time or I am particularly “in the zone.” This will be especially evident as I begin the project; since there is even less structure than before (no videos to watch, no exercises to do), I may suddenly have a lot of free time one day and decide to work on the simulation for several hours, “skipping” right ahead. This has already occurred several times, most notably when I worked on Milestone Projects 1 and 2 (Tic-Tac-Toe and Blackjack, respectively). In both cases, I managed to finish writing the program (albeit with a couple of bugs that were fixed later) in only 1-2 days because I was so sucked in and focused that time passed in a blur.

4. When you get together what do you talk about?

When Bill and I get together, we get directly to work, making the best use of our time. The topics we discuss are always centred around the questions I have, in response to which Bill always provides excellent answers (ranging from pieces of advice to technical explanations), as I have described in previous posts.

For instance, during the meeting we had most recently, I walked through my plan for the simulation, showing him websites I had curated as resources and what my vision for the final product would be like. Throughout, Bill offered suggestions and advice (more details later). Beforehand, I had requested for Bill to ask and answer in this fashion, and he agreed; my reason for this is that I knew that the format of the meeting would be different from previous ones, where I would be presenting more than usual (rather than just asking a series of questions). This was the first phase of our meeting. The second phase was concerned with additional questions that I had prepared, during which Bill also provided more general advice. Finally, in the end, Bill congratulated me on my progress, and I thanked him for his amazing help! My experience on this journey so far has been unparalleled thanks to Bill’s advice and dedication — I would not have learned (and enjoyed learning) as much as I have without him.

5. What is going particularly well in your mentoring relationship right now?

Currently, our ability to adapt has been thriving in my mentoring relationship with Bill. Whenever an obstacle or change crops up, we have always managed to take it in stride and adapt.

Apart from taking advantage of what we have access to on Zoom (and finding workarounds to the challenges we have with meeting remotely, described in previous posts), the example given above of Bill and I adjusting the format of our meeting also demonstrates our ability to adapt. I was surprised in particular by how seamlessly Bill filled the role of constructively criticizing my work, exactly like how I had asked him to (he did it better than I even hoped for). Moreover, I was also able to provide clear explanations and answers when describing my plan for the simulation, and we were so immersed in our discussion that time, again, flew by. Additionally, regarding time, Bill and I had to reschedule our meeting due to unanticipated scheduling conflicts — we solved them quickly through email.

6. What are you learning about one another?

I am learning more about Bill’s personality, the work he does, and the passion he has for it. First, he is exceptionally positive, uplifting, and always focused on what he does. During every meeting, Bill has been very encouraging and always cherishes my progress. Whenever we discuss a topic, he is always absolutely concentrated, paying attention to every detail and making sure he has assisted me in every way he can. Bill also makes sure he fully understands whatever he teaches me. I can see how all this translates to major parts of his life such as work, family, fitness, etc. — in each area, I am certain that Bill is constantly doing his absolute best, persisting when challenges arise, helping others, leading, and also maintaining a balance between work and life.

Second, by offering his experience and advice, I have learned about the overall development process (described in the previous post) he utilizes in his software engineering/systems architect job at Teradici. I can begin to see small portions of his thought processes, for example, what he focuses on when structuring a program and how he adapts/learns new concepts (both outlined in #7). Importantly, his dedication to teaching me and the enthusiasm that I observe each meeting demonstrates his passion for technology and software. Put simply, without Bill’s passion, working in his job, much less taking the time to mentor someone, would not be possible.

7. Wisdom and progress.

The first portion of my plan for the COVID-19 simulation illustrates the SIR model and how I can apply it. SIR stands for susceptible, infected, and removed, which represent the total population that can be infected, the number of infected, and those who have either recovered or died, respectively. Note that on becoming removed, the model assumes that one can no longer become infected. The expressions of this system of differential equations (seen on the right), in turn, represent the three rates of change for the number of susceptible, infected, and removed over time.

The number of susceptible over time, for example, is calculated by subtracting a constant, multiplied by the current number of susceptible, and then multiplied by the current number of infected. Essentially, this rate of change subtracts the portion of the susceptible population that has become infected. Each variable is a rational number > 0 and < 1, and the constant a represents the infection rate. In contrast, the number of infected over time is calculated by adding the reverse of the susceptible rate of change (imagine it as moving a portion of the population from one “bucket” to another), while subtracting those that have recovered/died with a constant (the recovery/death rate) multiplied by the current infected population. Finally, the “removed” bucket is the simply last portion of the second expression but reversed. We can generate “simulation” data by repeatedly adding/subtracting the three rates of change to preset S, I, and R, values. My goal for the final product is to produce SIR model-based charts that move in real-time/are animated.

After outlining my understanding of the SIR model to Bill, he gave me the green light. I also proposed a couple of other ideas, for example, adding another “immunity” constant to counteract a, acting as vaccines. Or, to make the data more realistic (in reality, the lines are not smooth curves), I could randomize the values of constants based on a range of 20% (e.g., 40-60% infection rate). Bill reacted by agreeing that these are excellent ideas, and also offered some additional suggestions: The user should be able to modify the variables, not only at the beginning, but also while the simulation is running, and I can add even more “factors” — for example, public health measures, increased infectivity — to make the simulation more accurate. Second, instead of randomizing the constants in an arbitrary range, I can instead use data we have from the pandemic right now to estimate one. For example, I can look at the average number of people — I will try to find a range — that a single person can infect, or find how long it takes for different people to recover from the virus.

Altogether, my vision for the simulation is for it to greet the user with a GUI, and, in a “Lemonade Stand”-like fashion (the game on CoolMathGames, as observed on the right), the user should be able to modify the different variables present in the three equations. Then, the user can run a simulation, which will output animated data updating second by second (similar to stock charts). Importantly, to represent changes — such as in public health measures, different COVID-19 variants, social distancing, and levels of mask-wearing (I will incorporate as many of these as possible into the model) — the user should also be able to modify the variables and constants while the data is updating to make it more similar to real life. To accomplish all of this, I will create two main classes — one to handle the graphing, and another to handle the GUI and user interactions (I have already discussed the specifics of this plan — what modules I will use, the methods I will create and what each will do, etc. — with Bill).

Ultimately, I have two main takeaways from this process of writing a plan and researching. First, Bill heavily emphasized the importance of understanding what exactly the purpose of the program you create is. During our meeting, whenever I suggested an idea, he would question me about how the added feature would improve utility to the user. For example, the idea of being able to update variables while the simulation is running adds realism and allows the user to see what happens in different circumstances. In contrast, adding a scatter plot graph (to visually represent the population) would be far from as useful because it only provides aesthetic value.

Second, I learned from Bill how he researches concepts he knows comparatively little about. When I wrote my plan for the simulation, key modules I needed to be familiar with were Matplotlib and Tkinter, a graph visualization module and Python’s GUI interface, respectively. While previously I knew absolutely nothing about either module, by looking through Python references and videos (neither of which I used heretofore when learning Python), I now know enough about each of the two to apply them to the simulation. Furthermore, following Bill’s practice of creating a plan in the first place has helped me to keep track of every aspect of my program and turned the final stage to simply implementing everything into written code.

Thank you for reading my fifth post. I look forward to working on the simulation and sharing my progress in May!

Welcome to my fourth post! During March, I managed to complete several large and important sections of the course — I will be able to finish the rest of it by the end of this week. This post will primarily include answers to reflection questions, additional wisdom I’ve gained from my mentor, as well as the routine progress report in the form of a log entry.

1. What has been your most difficult mentoring challenge so far? Why?

My most difficult mentoring challenge with my mentor, Bill, is something I did not expect, and in fact, dismissed in Post #3. These are the logistical challenges — meeting through Zoom. Although meeting online has its benefits — it is convenient, efficient, etc. — the two meetings I’ve had in March have shown otherwise. 

To start with, we have had some technical issues, with both of us receiving various, “Your internet connection is unstable,” messages. Zoom has crashed several times over the two meetings. Additionally, the audio quality is shaky, often breaking up, and background noise can frequently be heard coming from both ends.

Though this is less of a problem from Zoom itself, another issue I’ve had is not being able to see my mentor’s face since the device he uses (or the place he is at) does not have a camera. For the first few meetings, Bill seemed to have managed to find a solution, but it seems that he has not been able to more recently. Not being able to see a face is worse when I am speaking, for I get less visual/real-time feedback, hindering the experience.

All in all, however, the meeting experience has been quite good — I have managed to communicate all my questions and Bill has been able to answer them. 

2. What is working well? Why?

Beginning with my part, I have continued to come prepared to each meeting with a plan and the questions I have for Bill. The former meeting had more questions regarding the content I was learning, while the one we conducted this Wednesday involved high-level overviews of the process and more job-related questions (more on this later). Bill, as always, provided excellent, clear answers with large amounts of detail. Indeed, even when he did not know a specific concept I asked him about (Python is not his primary language), Bill simply went straight to the documentation, digested the information, and explained it to me — he can always understand better than I do with his vast experience.

When presenting my progress, I easily shared my screen and walked through the concepts I covered since the last meeting — Bill would occasionally comment and offer advice. He was very encouraging, cherishing my learning (even congratulating me for my progress at the end of the second meeting) while simultaneously demonstrating his enthusiasm and passion for what he does. As I’ve reported before, we have continued the practice of me laying out my plan for what I would like to achieve before the next meeting, and again, the sense of accountability has served to motivate me.

Bill’s method of teaching also works like magic. Slowly but surely, he has given me the tools to create the COVID-19 simulation; currently, I know enough about Python, the process, what to focus on (described later), and what to do when I don’t know about something to feel prepared to go through the entire process once and for all. There are several ways Bill has done this: First, he has taken care to answer each one of my questions, and for many, he has elaborated more in specific directions based on what he believes will be useful to me. Second, he has emphasized certain ideas that are crucial to understanding when developing a program from start to end. Finally, when describing complicated topics, he makes sure I understand by giving examples and often illustrating them with images.

3. What can be working better? How do you make sure this happens?

Something I feel can be working better is related to screen sharing and taking advantage of media. In a previous post, I described Bill’s use of the screen sharing feature, which made understanding the concepts he described much easier. While I still do share my screen every meeting, he has not needed to do so — it almost feels like a missed opportunity and would certainly heighten the quality of our meetings. Indeed, I can recall several times where I simply stared at the blank screen (without his face either, although there is nothing we can do about that) while listening to Bill talk.

The roots of the issue, I believe, are my questions. Recently, they have been less about problems I don’t understand, and although sometimes illustrations may be helpful, they are not necessary. As a result, asking more questions such as, “How can I accomplish this using Python?” and, “Can you illustrate this concept to me? I don’t understand it,” instead of, “What is a strategy you found useful when first coding?” will more likely result in Bill sharing his screen. I should simply ask less of the former, especially since the next month will focus all on the COVID-19 simulation. 

Another principle I should follow is the idea that “Ask and you shall receive.” The reality is that oftentimes many of our problems can be solved if we just ask — after all, we have nothing to lose and everything to gain; if you do not get the answer you want, you only end up in the same place you were before asking. Thus, whenever I feel that my questions would be best illustrated by Bill sharing his screen, showing diagrams, videos, or even drawing something on a digital whiteboard, I can ask with a high probability of him saying “Yes.” This can also apply whenever I need something from Bill — I must not be afraid to ask. 

4. Wisdom/answers from Bill!

When completing a Blackjack project for the course (see progress report), I was very disorganized — I could hardly keep track of all the classes and methods I created. Naturally, I posed a question about how I can be more organized to Bill. He suggested that whenever I create a program, I should divide it into different sections (e.g., main classes, functions grouped by purpose, etc.) with each in a separate file. Not only does this make it easier to make sure each segment is working as expected, but it is also easier for collaboration when working with others. We can then also take advantage of modules and packages (described in the progress updates from Post #3) and then simply import each when the time comes, bringing it together into one main file. 

In the next meeting, Bill also re-emphasized the importance of understanding the concepts and tools you have access to well and knowing when to use them (for example, in the case of advanced modules and packages — described in the progress report), stating that the programming language and the coding itself is just a small part of the implementation, which is only a stage of the overall development process of solving a problem. Indeed, you can quite quickly learn new programming languages after learning your first, and many problems will require several to carry out different areas. But what is the process exactly? Put simply, when I begin the simulation, I should make sure to understand the problem (Bill explains that the requirements of programs he creates are often very complex and can change), develop a clear solution, and then finally use Python to implement it. When working on the solution, I should start by coming up with a high-level overview of my solution — what classes I will create, what each does, the major formulas I will use, how I will fulfill my requirements, etc. — and then move on to the specifics — exactly what methods will I have inside each class, the modules will I use, how I will bring everything together, etc. This can also all be applied if/when I get my first job in this field!

During the first meeting, Bill also helped me to understand concepts — for example, decorators, errors and exceptions, etc. — that I was somewhat confused about. For the former, Bill explained that decorators are simply a way to modify an existing function by passing it in as a parameter to another function, which has another wrapper function inside that actually makes the modifications (details and illustrations in the progress update). The wrapper is returned, then assigned to the original function, thus modifying how it works. Python can make the entire process simpler using the “@“ keyword. Decorators are most often used as a way to easily modify/customize “templates” from other sources. 

For the latter, Bill explained the importance of making sure that a single error does not resulting in the entire program crashing. Often, several “general” try/except statements are placed just in case to try to catch unknown issues. Exceptions handling can also play a part in complicated logic where they can be used instead of if/else statements because they have the ability to “catch” scenarios anywhere/anytime, even outside of the local scope/file, where instead if/else loops must have the “requirement” caught immediately. Regarding bugs in programs, Bill states that a complicated program will almost always have bugs (it is very difficult to catch all possible bugs), but as long as there are not any major bugs, it meets the requirements of the solution (given to you at the start of the development process), and it is sufficiently tested for user usage, it is fine. The development process in question commonly involves following the Agile philosophy. 

Finally, my goal for our next meeting, as according to plan, is to have understood and outlined my requirements for what the COVID-19 simulation should include and created the solution itself. Bill has been an outstanding mentor who has again proven invaluable on my journey! Once this project is over, I will find a way to show my appreciation. The progress report is attached below.

(In-Depth Log)

In the past two weeks, I have made significant progress in my Python course and had my second meeting with my mentor, Bill. This post will analyze some aspects of our learner-mentor relationship and also provide a detailed progress update with wisdom I have gained from Bill. Note that I explain all of the concepts I discuss in the progress update/log attached at the bottom of the post.

1. What went particularly well during your mentoring sessions?

First, I have noticed how comfortable and relaxed the environment of our meeting sessions is. Not only do I feel calm and open – ready to freely share my thoughts and questions without trepidation – but I find myself becoming more passionate and enthusiastic about the topics we are discussing, especially as they become increasingly complex. Furthermore, Bill’s explanations (described in section four) are extraordinarily enlightening and easy to understand, which serves to further my interest.

After only two meetings, we have fallen into a type of routine. As perfectionistic and controlling as I am, I come prepared for each meeting with a simple meeting plan made of questions I have. I start by sharing my screen and outlining what I have accomplished. Then, I ask my questions, and amazingly, Bill always provides detailed, informative, and engaging answers.

How? To start with, after describing a concept, Bill would frequently ask if I understood. Depending on my answer (sometimes, he would do the following regardless), he would further illustrate his points and explanations through examples. This leads to his method of describing concepts: A frequent use of visual aids, whether they were diagrams, videos, webpages, a text document, or even a whiteboard – a huge help. Finally, Bill related concepts to what I have already learned and took great care in knowing every detail. In one instance, he brought up polymorphism (details in question four), a topic that I had not even mentioned, but which he noticed was on my screen (for only a few seconds) when I projected it.

2. What learning challenges emerged?

Thanks to the flow of our meetings, I have had very few learning challenges in the past couple of weeks. The time management issue that I described in my first post has largely been solved, a direct result of the solution I put forth – time blocking. I have consistently been able to achieve at least 30 minutes of Python per day, a feat made much easier by the aforementioned passion and increased interest in the topics I am now covering.

A practice I naturally fell into to hold myself accountable was to list out my goals to be completed by our next meeting – which I laid out at the end of the session. Whenever I feel unmotivated, lazy, or tired, I automatically remember the promises I have made to Bill, as well as the shame I would feel on missing the valuable advice I gain from each session. Indeed, what would be the point of meeting and wasting Bill’s precious time if I make no progress whatsoever from our last encounter?

3. What logical challenges affected your communication?

The ideal scenario would be to meet Bill in person since virtually everything – speaking, demonstrating, etc. – is easier. However, this is impossible considering the pandemic situation.

Even so, communication has been exceedingly easy and unchallenging. With Zoom as our meeting platform, we have not experienced any audio, video, or technical complications whatsoever! Bill and I have been able to share our screens, and even recording the session has been impeccable as well. Lag and background noise are virtually nonexistent. At one point, I had a question regarding debugging in Visual Studio Code (described next), the platform Bill recommended I use day-to-day with Python. He simply asked me to share my screen, open a program (I opened a Tic-Tac-Toe game – details in my log entries/progress updates), and gave clear instructions, which I followed. In a couple of minutes, my question was answered.

In short, in terms of logistics, my meetings with Bill were nothing but flawless.

4. Wisdom and progress.

Having covered object-oriented programming (OOP), I had a major question: When exactly do we use OOP? And why use it over functions? Apart from the obvious – classes (used to create objects) offer more structure, making it easier to have a high-level view of the different “roles” in a program – Bill offered two thought-provoking arguments. Firstly, almost all programs involve users, ranging from applications and websites to operating systems. Classes allow for “encapsulation,” building an extra layer of security and privacy. Put simply, the idea is to bundle everything related to an action/data into a single unit, so that everything else is hidden and restricted when that unit is called. An analogy is a finance company – different departments handle what they are responsible for and are not allowed to directly access data from another. Especially when it comes to sensitive information, allowing information to be retrieved anywhere is not a smart idea. In Python, there are specific modifiers (symbols) used to determine the encapsulation of data.

Another reason is polymorphism and inheritance, which Bill visually represented on a whiteboard. The concept is simple: A base class can be created (essentially a template), and new classes can inherit the attributes and methods of the base class. Then, the contents of these attributes/methods can be modified, but they can still be called under the samename. For example, a base “Shape” class might have a “calcArea” method (known as a virtual method), which new classes “Rectangle” and “Circle” derive/inherit from it. You can modify (override) the formula under calcArea (namely  and  for circles and rectangles respectively) but when you ultimately call “calcArea()” for an instance of a Rectangle or Circle object, you use the same method name even while returning two entirely different results.

In response to another question of mine, Bill outlined the OOP design approach, which will be helpful when I begin my COVID-19 simulation. He pulled out a
diagram on the web (shown on the right) known as a “use case diagram,” which depicts the different roles and responsibilities programs have. It can be thought of as a restaurant (the system) and its clients/people (“actors”), and how they interact with each other. Depending on the program, the different actions labelled in the diagram are either functions or classes. As a piece of advice, Bill suggests when starting to try to quantify and outline how many actions, actors, roles and concepts are needed in the program.

For the COVID-19 SIR model simulation itself, Bill and I discussed my plan. Since our last meeting, I had researched resources I can use, and settled on Matplotlib as the graph visualization library of choice. As per a simulation on YouTube and similar ones online, Bill recommended that use multiple graphs – for example, a classic trend graph along with a scatter plot to represent the population, like in the video above. However, he also made sure to emphasize the importance of starting simple; if I want to make the program more complicated, I can do so afterwards if time allows and I am having fun!

Finally, Bill helped to settle a nagging question I have had ever since starting with Visual Studio Code. After sharing my screen and opening a program, Bill told me where to click – it turns out that all I needed to do was add breakpoints beside the line numbers. Then, when I run the debug option the program will run only up to the breakpoint and stop, where I can then see all the variables I have and step through the code, line by line. It is genuinely wonderful how Bill helped to solve a confusing problem in just a couple of minutes.

That concludes this third post on my journey with Python. For a detailed progress update, see the attached below, where there are two new log entries!

(In-Depth Log) P.S. Now with a Table of Contents and even more images!

Since my last post, I have had my first meeting with my mentor, Mr. Bill Zhang. Our discussion extended for an astounding hour, where Bill offered plenty of advice, wisdom, resources, and ideas.

1. My mentor’s expertise, experiences, and facilitation strategies.

The first programming language Bill learned was BASIC, which he learned in High School. He earned a Master of Science focused on Computer Science & Engineering at the University of Texas at Arlington and has since used many different programming languages at different positions such as Java, XML, SQL, C++, and Python, over a period of over 20 years.

Bill states that in his experience, after learning a few programming languages, adopting a new one only requires learning the basic syntax, new features, and unique/specific features of the language, as the core concepts and basic features used by all programming languages are very similar, if not the same. For example, for Python (which is not Bill’s main language), he looks at Python references and documentation for information. Thus, learning a new language after one’s first language is about finding what is specific about it.

When it comes to learning one’s first language itself, Bill explains that it is very important to build a solid foundation that can be carried over later. He says that I should take my time and go through the course I am using carefully. After all, to learn more than one language, you need solid fundamental knowledge of the core concepts. Similarly, as I have even discovered, having holes in one’s knowledge is far worse than spending time and learning a concept well, which will pay dividends in the future.

In terms of facilitation strategies, several approaches Bill took stood out to me. After I outlined my progress so far by sharing my screen, he first answered some burning questions I had (described next), then offered ideas and possible routes I could take with my project. He used his experience to show what he has done in scenarios where he became the learner. When Bill had an idea, he would suggest ways for me to implement it and provide resources that will help me to do so. These are facilitation strategies that I will use to assist me in my development as a mentor.

2. Wisdom gained and progress.

By far the most lingering piece of wisdom that Bill has passed on to me is to approach programming (in any language, really) using a top-down, instead of bottom-up methodology. He explained that every programmer has a problem, a design, and implementation details. Put another way, whether by flowcharts or even a simple brainstorm, developing an overview of what major parts the program will have, first, is crucial. Then, and only then, must the finer details – how you will accomplish what you want to do using the chosen programming language – be specified. This piece of advice was enlightening, since, in past incidents where I’ve written programs, I often felt lost starting with the details without an overview/plan.

This connects to the age-old question of, “Should I try to memorize?” To this, Bill reaffirmed that memorizing is not important. Instead, it is more practical to obtain a base understanding of everything, and then focus on how you will find a solution. Once a plan has been accumulated, what exactly will be used to implement the solution (syntax, methods, classes, etc.) will come naturally. Bill reiterated that, especially for one’s first programming language, learning the basics well is more important than memorizing – though the syntax changes between languages, the core concepts never do.

Naturally, Bill shared some of the resources he uses when looking for how to implement something he does not know how to do. These are the official Python 3 documentation and W3Schools references. Additionally, Bill has kindly recommended Visual Studio Code, a complete programming environment by Microsoft, which has now fully replaced all the other tools I was using. Next, he suggested an idea for what I could attempt to do for my final project after completing the course. With COVID-19 prevalent in the world, Bill believes (now I, too) that it would be both instructive and useful to write a program that simulates the spread of the coronavirus, using both animations and a graphical user interface. Specifically, the simulation would most likely be based on the SIR (susceptible-infectious-removed) model of COVID-19 transmission. The program will ideally help to answer questions regarding the effectiveness of restrictions, vaccinations (herd immunity), and what it would take to completely eradicate the virus. Although SIR modelling does use equations that I have never encountered, Bill and I both think it will be feasible, albeit challenging, to say the least. To assist me in my venture, he shared a page about making GUI’s with Tkinter, a video about a similar SIR simulation, and a paper about the SIR model.

Finally, an update on my progress overall. I am well on my way to finishing half of the course by the halfway point (end of February), having just started object-oriented programming (OOP)! This week, I covered methods and functions, which I will be updating in my log. Thus far, I have recorded only one log entry (though it is lengthy), since most has been simply review. As I finish OOP – which will be the first section where everything is completely new for me – I will 100% be recording weekly logs. I have attached my first log entry below, for a detailed progress update. Next week, I will also be having my second meeting with Bill!

(In-Depth Log)

In-depth Studies are one of the most valuable experiences of the TALONS program. It is a unique chance to pursue any passion, find a mentor, and show our learning over a period of five months. It is the perfect opportunity to build a skill useful in the future.

My vision, rationale, resources, and plan.

I have learned Python in the past, specifically in Grade 8, but I feel that the concepts I learned neither built solid foundations nor have stuck with me. Last time, I used an online book, which, although detailed, did not provide enough practice and covered too much at once. I also did not put the needed effort into practicing/memorizing what I had learned.

My plan for this project is very simple: I will use a 22-hour online video course on Udemy that teaches both concepts I have already learned in Python, and more importantly, new, more advanced topics such as object-oriented programming. Throughout, I will do my best to make sure what I learn is ingrained into my mind, using the resources provided by the course (practice problems, assignments, projects), and at the end, by creating a program – whether a game, script, algorithm, etc. – that demonstrates everything I will have learned. This will be the “product” of my journey. Throughout, I will keep track of my progress with weekly logs (along with these blog posts), and I am aiming to work on Python for at least thirty minutes a day. In this fashion, I will finish the course by the end of March and proceed to spend the last two months on the program.

My rationale for continuing to pursue programming is centred around the fact that I have always had a deep interest in technology, and a career in this field is a very great possibility. Understanding just how computers, operating systems, and apps work has always puzzled me, and thus I hope being able to code will answer this question. Furthermore, learning Python specifically opens up areas such as machine learning and software development.

Current challenges and my mentor.

Given we are nearing the end of January, I have already made significant progress in the online course. It has taught me many new concepts, even in areas that are not new to me. For example, the course introduced the Anaconda Navigator, Jupyter Notebooks, and Sublime Text, all of which are Python environments that I have never been exposed to before, as I have only used the old-fashioned IDLE editor that comes default with Python. Similarly, when covering “basics” that I had already previously learned, I came across gaps in my knowledge – e.g., lists, indexing, slicing – that I now fully understand, thanks to the course.

However, a major challenge I have already faced is time management. Although thirty minutes is not a long period of time, procrastination, “other” homework, and simply fatigue make it difficult to consistently work on Python every day. To combat this, I embraced time blocking – scheduling every minute of my day into “blocks.” After returning from school, I simply incorporate my assignments, routines, and learning Python into my schedule. It has significantly increased my productivity, and over this semester turnaround week I have managed to make up for those days I have missed.

My mentor for this project is Bill Zhang, a family friend and colleague who is a senior software engineer and systems architect at Teradici, a company recently acquired by HP that develops remote desktop, PCoIP technology. He has very kindly accepted the role of assisting me along this journey. As a software engineer, Bill will without a doubt be invaluable to me with his experience and passion for technology. I will be having biweekly meetings with him starting in February, where I will be asking Bill about issues and problems I am having, concepts I don’t understand, advice, guidance, and more!

I am very excited to continue learning Python for my In-depth Study! I will bring you updates in my next post.