Python Open Lab mid-term reflection (Fall 2018)

This semester I am glad to participate in the Python Open Lab of the digital center. Staying with students just reminds of myself. When I learned my first programming language, I had a lot of struggle and made tons of mistakes. As a result, I get much experience and I am really happy to share them with others.

Python is one of the programming languages I ever learned and it is the most concise one. With Python, many complicated things can be simplified. For most students who join our open lab, Python is the first advanced programming language they learn. This is great because Python can help students learn the basic programming skills and data structures without spending much time on irrelevant details. It helps students focus on their task and gives them the confidence to explore the unknown world.

I started with the basic ideas of types and operations in Python and introduced data structures like list, dictionary later. Other topics such as function, conditional statement and FileIO are also taught. I found that the sequence of materials can be organized better. And more examples could be shown for students to have a better understanding of the materials.

During the teaching, I learned a lot too. I began to see things from a different perspective. Although I have knowledge about programming languages, it still takes great efforts to spread the ideas to students and support them. The most important thing I learned is I need to focus on the big picture and skip the specific tricks to help students have a complete view of the materials. This is where I need to improve myself.

Kang

R Open Lab Summary Report – Spring 2018

This was the first semester I worked as a teaching intern at the Digital Center, and I was in charge of running the R workshops. As a great semester reaches its end, I would like to summarize this journey and reflect on it.

A Quick Summary

I conducted 5 workshops besides the starter kit. 4 of them are new topics, and the other one is an intermediate version of the starter kit which provides a deeper exploration on the fundamentals in R. For all the labs, I prepared all the scripts ahead without all the input parameters  because I wanted to fill them in as examples during the labs. I always believe that the first step of learning is imitation. You don’t have to understand the content to be able to imitate, and by imitating again and again, you will be able to observe the pattern and comprehend the nature of it. The usual flow of my labs is:

  1. Introduce the function briefly.
  2. Show the help function output of this function so that students can see what the inputs look like and what the results are.
  3. Enter the input arguments and run it.

I believe this way of demonstrating codes is better than having it written in the script file and running it in a blink of an eye; students are actually seeing me coding, and it becomes easier for them to imitate.

I also started a new teaching practice in the middle of this semester: I started to add practice questions at the end of every lab. The purpose of it is to help fix the codes in memory. No matter how well you understand the new contents, they won’t become part of you skills unless you use it again and again; that’s how we learn: imitate and repeat. I figured that by implementing the functions to a real-world problem, it leaves a mark in student’s memory, and they will be more likely to recall it in the future. I even used the same dataset for several workshops. In that way, they are working with something they are already familiar with, and hopefully, it will help them connect everything we learned.

Challenges and Possible Solutions

Of course there were quite a few challenges. I will list them below and provide possible solutions to them from my perspective.

  • The outcome of the attendants’ amount could be better. Due to lower application popularity   and high difficulty at entry level, less  people choose to learn R. However, I still see a big potential group to which R will be helpful from the positive feedbacks from attendants. The Digital Center could market the open labs(both R and Python) to specific communities which would be interested such as Economics programs and SIPA. If you are reading this post and you want to learn coding in R and Python, remember to check out the open labs this fall!
  • Attendants don’t attend labs regularly. This has been troublesome. I didn’t build the labs consecutively because I didn’t want to review earlier material every time; I think that’s inefficient. But I think that didn’t encourage students to come back, and it forms a negative loop. A solution to that is to post the topics ahead of time. I’m still undecided whether I should have a syllabus for the whole semester due to the nature of high dependence on attendants, but I think for Fall 2018, we should post topics at least 2 weeks ahead, and make sure students know there will be continuous contents.
  • Through all labs of this semester, I found that students who were new to R needed longer time than what I expected to fully understand the syntax and logic. As mentioned above, R has a steep learning curve for beginners. The starter kit is not enough. I should conduct richer materials on the fundamentals, and I will bring more examples to demonstrate. I may also conduct one lab focusing on the swirlpackage since some students thought it was a good tutorial.

All in a nut shell, this experience was exciting and informative. Now I have more understanding of how to teach. To be honest, I don’t really consider myself as an instructor or a teacher. I am just a student who tries to help others with what I know. This internship enlightened me of new ways  to pass on the useful knowledge and to exchange information with others. I am looking forward to continuing my internship at Digital Center and serve the Columbia community and fellow students.

Python Open Labs S.2018: How it all went down

Lab Structure and Technicalities:

This semester I returned to running the Python Open Labs with another student intern and upon started, we had some discussions about our ideas for structuring the labs over the next few months. We decided to stay consistent with the formatting of the lab: started the semester with the starter kit (Python fundamentals), and continued to build on those fundamentals every week (see weekly blogs here).

The first change we implemented was switching to Jupyter notebooks as opposed to running the labs on the console itself. For me, this was quite a challenge! I had never used Jupyter notebooks, it seemed like a strange and abstract way to code, one that was definitely built with user experience in mind and something that was unfamiliar to me on all fronts. I spent a few weeks playing around with its functionality – the headings and commenting features as well as common errors that can happen (e.g. running every cell to ensure the code works). Once I got the hang of it though, everything changed! I have tasted and enjoyed the Jupyter notebook kool-aid and there is no going back.

One of the best features of the Jupyter notebooks is the UX of its layout. The simplicity of its layout makes the code that much easier to parse out and build upon. Organizing the code, or in our case, entire lesson in the Jupyter notebooks meant that we could share the lessons with the class at the end. Prior to the lesson, we would come up with the content and create the notebook in full. Then, we would go back and recreate another lesson without the completed cell blocks so that we could use the prompts and live code. At the end of the lesson, we shared the lessons in full with the class to ensure that students could spend time going over and reviewing the examples and problems with the full code (i.e. all answers) readily available.

That being said, we also changed how we shared the lessons with the students. This semester, we maintained a google folder with all the Jupyter notebook lessons and .pdfs and shared it with the students that came. A welcome change considering the amount of paper it took last semester to print and share each lesson! We also received great feedback on the organization and sharing of the Jupyter lessons so that’s definitely something we will keep in mind and hope to continue next semester.

Students:

This semester, the range of programs represented by the students who attended the labs were incredibly diverse. Students from the School of Professional Studies and the School of International and Public affairs were the most consistent, however we did encounter students from Journalism, Economics, and Latin American Studies as well. Although it’s a challenge to encourage students to attend on a regular basis, we were able to see some faces week after week, and sharing the lessons on an accessible drive folder ensured that those who were not able to make it in person but interested in continuing to expand their coding horizons could keep up.

Most enjoyable Lab:

The lab we held on python classes in early April was my favorite lab – partly because I taught the entire session on my own, but mostly because I structured the lesson in a way that focused on fewer and more intense practice problems. Instead of going through quicker and shorter sample problems I thought I would try create problem sets that incorporated functions as well to keep things interesting and to offer students a challenge. The class was well received and you can find the lesson on the DSSC blog if you want to check it out!

Ideas for future labs:

To conclude this post, I will underline two suggestions for future lab lessons:

  1. Plan out lessons before the labs

It would be great, in my opinion, to post a description of each lab before it happens to outline the structure of the lab and the concepts covered. This was the route we took for the R open labs towards the end of the semester and it worked really great – I am excited to try it out for Python as well!

  1. Continue to market to a diverse group of students

Before commencing in the fall, I would like to spend some time strategizing on how to market to different departments. The open labs are such a great way to learn a coding language – they are free (!!!), but more importantly the communal vibe is optimistic and welcoming and a great space to learn.

I have learned so much this year in preparing and leading labs and now that they have wound down for the summer, I feel motivated to continue to market the space and engage students across all departments.

End-of-Semester Reflection (Python Open Labs – Spring 2018)

It’s hard to believe that the end of the semester has arrived and that Python Open Lab sessions for Spring 2018 have come to an end. Instead of writing a sappy post about “the end,” I’d like to share five things I learned while teaching my students Python this semester.

# 1 – Teach with Examples – Different programming languages vary in syntax, but they all share similar concepts such as variable usage, conditionals, and loops. Explaining such concepts to students unfamiliar with programming is certainly helpful, but can probably only get them so far. To show how to use a language to creatively solve problems, examples – especially multiple examples showcasing the same concept – are a must. I would also encourage instructors to create examples that reflect the demographics of their students when given the opportunity (i.e. initialize a list of more diverse names versus solely American names).

# 2 – Teach with the Right Tools – The agile method in software development encourages reiteration, and I like to encourage my students to think in a similar manner when writing code. The easiest way to test whether or not your code has worked is to run it and see the output. As an instructor, I live-coded each lesson. I wanted to my students to see me run my code block, examine my output, and fix my errors if need be. Using Jupyter Notebooks really allowed me to do this in a clear manner. I was able to isolate each example within a code block, which was especially helpful. Another IDE would work in regards to teaching a programming language as well, but I would not recommend teaching via a Google doc or a Powerpoint presentation for a non-lecture style session.

# 3 – Incorporate Wait Time – In addition to studying computer science, I also studied (English) education as an undergraduate. I learned a lot about teaching methodologies and one concept that has stuck with me is the idea of wait time. Wait time is the time an instructor waits after asking a question before calling on a student. Sometimes, it can be easy to answer your own question right away if no one has raised their hands, but waiting gives students time to think about their answer. If no hands are raised after some amount of waiting, then you can possibly provide a hint or make the judgement call whether or not to answer your own question.

# 4 – Have a Positive Attitude – If you are not excited about the material you’re teaching or the lessons you’re crafting, it may be a little harder to get your students excited about the subject as well. I like to use varying examples to keep things fresh as well as think back to my earlier days when I started learning about Python for the first time – and how incredibly fulfilling it is now to be able to code on my own with no instruction. When I imagine and see my students feeling the same way, I feel all the more positive. As Jim Henson says, “[students] don’t remember what you try to teach them. They remember what you are,” and I’d like to be remembered as someone who was wildly passionate about computer science education.

# 5 – Ask Students for Feedback – Not every lesson you create is something your students are satisfied with. Ask them what they’d specifically like to see more of or less of. From student feedback, I learned to spend more time coming up with examples for loops and functions and less time reviewing classes. Students also wanted to see more of a workshop-style lesson towards the end and with feedback, I created a data visualization lesson that ended up being quite well-received. Always be sure to ask for your students’ inputs – you are not the only one in control of the class and its structure.

I hope you found these takeaways valuable and can apply them to your own lessons if you are an instructor. I’ve greatly enjoyed serving as one this semester and hope to take on more teaching-related opportunities in my spare time after I graduate this May. Working as a teaching intern at the Digital Social Science Center for Columbia University Libraries has been an incredibly fulfilling experience – I would do it again in a heartbeat. If you are encouraged by my post and love teaching as well, I hope that you apply to be an intern for the upcoming semester!

Navie Narula

Mid-Semester Reflection (Python Open Labs – Spring 2018)

Stuart Walesh, an author and consultant, once said: “The computer is incredibly fast, accurate, and stupid. Man is unbelievably slow, inaccurate, and brilliant. The marriage of the two is a challenge and opportunity beyond imagination.”

Many of us use computers. Sometimes, the time we spend on them consume the majority of our day. Whether or not this is a good or bad thing can be debated in another blog post, but the fact is…technology is an overwhelming part of our diet.

Taking my first computer science class as an undergraduate made it apparent to me that learning about how code and algorithms work was a really important thing, especially if I wanted to solve problems on my own. I declared my major in computer science and focused on  learning more about how code could be used to analyze large amounts of text more efficiently. I have not regretted it since, and am beyond happy to see a good number of students show up to the Python Open Labs to learn more about how to write code to perhaps automate their own tasks.

The people who show up to our class are diverse in terms of major – coming from backgrounds ranging from education to international affairs to pure math/analytics. It’s been really nice to see people actively show up to our labs with a desire to learn how to code and truly curious about how to solve problems. It’s proven to me again and again that anyone can learn how to code, and it’s been wildly encouraging to see people who think they cannot do it actually do it!

This is my first semester helping to lead the Python Open Labs. I find that lessons introducing a new programming language or new programming concepts are best taught in a step-by-step manner. Jupyter Notebooks have allowed me to accomplish this very well, allowing for space to write comments in markdown and running code in cell blocks. The students in class love this medium as well, and at the end of the lesson, they can easily look back over the notebook and remember what we learned about.

I’ve really enjoyed helping out with the labs so far and answering so many questions from the students who show up. Anyone is welcome to stop by the Python Open Labs – even if you have never written a line of code before in your life. I look forward to learning more from my students as the semester goes on.

Navie Narula

Computationally Detecting Similar Books in Project Gutenberg

As one of the first digital libraries, Project Gutenberg has lived through a few generations of computers, digitization techniques, and textual infrastructures. It’s not surprising, then, that the corpus is fairly messy. Early transcriptions of some electronic texts, hand-keyed using only uppercase letters, were succeeded by better transcriptions, but without replacing the early versions. As such, working with the corpus as a whole means working with a soup of duplicates. To make matters worse, some early versions of text were broken into many parts, presumably as a means to mitigate historical bandwidth limitations. Complete versions were then later created, but without removing the original parts. I needed a way to deduplicate Project Gutenberg books.

To do this, I used a suggestion from Ben Schmidt and vectorized each text, using the new Python-based natural language processing suite SpaCy. SpaCy creates document vectors by averaging word vectors from its model containing about 1.1M 300-dimensional vectors. These document vectors can then be compared using cosine similarity to determine the semantic similarities of the documents. It turns out that this is a fairly good way to identify duplicates, but has some interesting side-effects.

Here, for instance, are high-ranking similarities (99.99% vector similarity or above) for the first 100 works in Project Gutenberg. The numbers are the Project Gutenberg book IDs (see, for instance, this index of the first 768 works).

1.  The King James Version of (10) -similar to- The Bible, King James Ver (30)
2.  Alice's Adventures in Won (11) -similar to- Through the Looking-Glass (12)
3.  Through the Looking-Glass (12) -similar to- Alice's Adventures in Won (11)
4.  The 1990 CIA World Factbo (14) -similar to- The 1992 CIA World Factbo (48)
5.  Paradise Lost             (20) -similar to- Paradise Lost             (26)
6.  O Pioneers!               (24) -similar to- The Song of the Lark      (44)
7.  O Pioneers!               (24) -similar to- Alexander's Bridge        (91)
8.  Paradise Lost             (26) -similar to- Paradise Lost             (20)
9.  The 1990 United States Ce (29) -similar to- The 1990 United States Ce (37)
10. The Bible, King James Ver (30) -similar to- The King James Version of (10)
11. The 1990 United States Ce (37) -similar to- The 1990 United States Ce (29)
12. The Strange Case of Dr. J (42) -similar to- The Strange Case of Dr. J (43)
13. The Strange Case of Dr. J (43) -similar to- The Strange Case of Dr. J (42)
14. The Song of the Lark      (44) -similar to- O Pioneers!               (24)
15. The Song of the Lark      (44) -similar to- Alexander's Bridge        (91)
16. Anne of Green Gables      (45) -similar to- Anne of Avonlea           (47)
17. Anne of Green Gables      (45) -similar to- Anne of the Island        (50)
18. Anne of Avonlea           (47) -similar to- Anne of Green Gables      (45)
19. Anne of Avonlea           (47) -similar to- Anne of the Island        (50)
20. The 1992 CIA World Factbo (48) -similar to- The 1990 CIA World Factbo (14)
21. The 1992 CIA World Factbo (48) -similar to- The 1993 CIA World Factbo (84)
22. Anne of the Island        (50) -similar to- Anne of Green Gables      (45)
23. Anne of the Island        (50) -similar to- Anne of Avonlea           (47)
24. A Princess of Mars        (60) -similar to- The Gods of Mars          (62)
25. A Princess of Mars        (60) -similar to- Warlord of Mars           (65)
26. The Gods of Mars          (62) -similar to- A Princess of Mars        (60)
27. The Gods of Mars          (62) -similar to- Warlord of Mars           (65)
28. Warlord of Mars           (65) -similar to- A Princess of Mars        (60)
29. Warlord of Mars           (65) -similar to- The Gods of Mars          (62)
30. Adventures of Huckleberry (73) -similar to- Tom Sawyer Abroad         (88)
31. Tarzan of the Apes        (75) -similar to- The Return of Tarzan      (78)
32. The Return of Tarzan      (78) -similar to- Tarzan of the Apes        (75)
33. The Beasts of Tarzan      (82) -similar to- Tarzan and the Jewels of  (89)
34. The 1993 CIA World Factbo (84) -similar to- The 1992 CIA World Factbo (48)
35. Tom Sawyer Abroad         (88) -similar to- Adventures of Huckleberry (73)
36. Tarzan and the Jewels of  (89) -similar to- The Beasts of Tarzan      (82)
37. Alexander's Bridge        (91) -similar to- O Pioneers!               (24)
38. Alexander's Bridge        (91) -similar to- The Song of the Lark      (44)

The first pair here is of duplicates: both are King James Versions of the Bible. The same is true of lines 5 and 8, and lines 12-13: they’re just duplicates. All the other works are members of a novelistic series. Lines 2 and 3 are Alice in Wonderland and its sequel. Lines 6 and 7 are Willa Cather novels of the Great Plains trilogy. Lines 16-19, and 22-23 identify the Anne of Green Gables novels. Lines 24-29 are a cluster of Edgar Rice Burroughs of the Mars series, and there is also another cluster of Burroughs novels, the Tarzan series, at 31-33. Line 35 shows Mark Twain novels of the Tom Sawyer and Huck Finn world. The algorithm even identifies the two 90s CIA World Factbooks as part of a series.

When I lower the cutoff similarity score, I can get even more interesting pairs. Less-recognizable series, like Paradise Lost and Paradise Regained, have similarity scores of around 97%. At that level, completely unrelated novels with the same settings, or written in around the same time period (Victorian novels, for instance), begin to cluster together.

The chart below shows a PCA-reduced 2D vector space approximating the similarity between books 1-20. There are interesting clusters here: the American Constitution and Bill of Rights cluster together, along with the Declaration of Independence, the Federalist Papers, and Abraham Lincoln’s first inaugural address. Lincoln’s second address, however, clusters rather with his Gettysburg Address, and John F. Kennedy’s inaugural address.

PCA of PG Books 1-20

PCA of PG Books 1-20

Non-fiction seems to be clustered at the bottom of the chart, whereas fiction is at the top. Quasi-fictional works, like the Book of Mormon and the Bible, are in between. Similarly, Moby Dick, a work of fiction that nonetheless contains long encyclopedic passages of non-fiction, lies in the same area. The most fantastical works, which are also the three children’s books, Peter Pan and the two Carroll novels, cluster together in the upper left.

As always, the code used to create all of this is on GitHub. I welcome your comments and suggestions below!

>>> myPythonOpenLab = (“A Holistic Approach to Python”)

Overview of the Fall 2017 Python Open Labs

Python Open Labs reconvened in September with three new DSSC interns. Unlike my colleagues studying Computer Science and Computer Engineering, I am a Human Rights Masters Student at SIPA/ISHR. While we come from different backgrounds and levels of expertise in Python, this semester has been both productive and challenging as we worked to leverage our abilities and share our experiences in Python in an accessible and comprehensible format.

Teaching Style:

Our approach to the workshops was simple: teaching in a lecture-style format week after week– a slow progression to build on concepts introduced the previous session. We collectively agreed that Python is a coding language that is relatively easy to grasp given that the correct tools are available. Moreover, given its relevance to a variety of academic disciplines and careers, we strove elicit a positive reception from students attending these sessions. The latter point was quickly reciprocated by learners, who responded really well to the linear format of the labs. We welcomed students from a wide variety of schools, including Teacher’s College, SIPA, Urban Planning, and Journalism.

There was always too much material (or too much ambition — call it what you may), and we tried our best to manage time, but often found that sessions ran over their allotted time and continued on to the following week. Our pseudo lectures always included practicing concepts (eg. classes, dictionaries, loops etc.) a few times over the course of the 2 hours to see how students interpreted and applied them. We felt inspired by the variety of solutions that students shared! It has been incredibly rewarding to watch students become more confident in their abilities to write code and utilize their fluency of Python applications to solve a given exercise or problem as we delved deeper into the language.

Challenges:

As a student disengaged from Python in my day to day studies, I found myself trying to push my fellow interns to simplify material and slow down! This has definitely been one of our most obvious challenges as moving through material too quickly has caused confusion and an influx of questions via email post-lab. It has been difficult at times to gauge exactly how students are responding to a specific concept such as list methods (a particularly complex lesson), as we receive little to no participatory feedback from students in the lab. I hope to challenge this next semester by pausing more often for feedback and for creating a space where active dialogue between interns and students allows us to work in sync.

Looking Beyond:

Between the three interns, we have had great fun amalgamating our skills, strengths, and weaknesses in and around the lab to optimize students’ experiences. In doing so, we have learned more than we imagined about our own approaches to the language as well as teaching habits. Next semester, though my teammates will be graduating and moving on from Columbia, I am very much looking forward to continuing the labs in the aforementioned format.

One of the ways I hope to further enhance the workshop format is to focus on team, or group learning by way of small projects or discussions to accompany the lessons. Collaborative learning not only promotes learning by bringing people of different skill levels together, it also replicates the type of environment (think career) in which one would participate as a professional with coding expertise.

I also hope replace the weekly handouts I would create for lessons with an electronic format. I hope to share lesson structures and practice problems in a blog post or a Jupyter notebook to alleviate the environmental impact of printing paper.

Already looking forward to the Spring semester! All questions, comments, and feedback are strongly encouraged.

Please visit the DSSC blog for Fall 2017 Python Open Lab weekly summaries and materials.

R Open Lab: Looking Back and Moving Forward

In the past academic year, I worked as a teaching intern with the Digital Social Science Center and Digital Science Center, hosting R open labs and workshops. Most of the people at R Open Lab are using R for their research projects; therefore in the past semester, I tried out several different teaching practices in search of the best way to enable the participants to harness the power of R as a research tool.


New Teaching Practices

  1. Peer learning: It was the first method I tried out and it seemed to be the most helpful one. By talking with people with similar research interests and learning from each other’s experiences, many participants expanded their professional networks and found a better way to apply R to their research. Exchanging learning experiences with people from different academic backgrounds helped the participants to gain a broader understanding of the functionality of R. However, creating a stimulating environment for peer learning but not making the participants feel pressured can be challenging.
  2. Group discussion: I tried to encourage group discussion by throwing open-ended questions at the participants during the instructions. The problem with this method is that more often than not, the discussions were very shallow, probably because the questions were not interesting enough. Looking forward, it might worth trying to prepare a thought-provoking question for each R Open Lab session and make group discussion as a standalone part.

Challenges and Solutions

Based upon my experience with both workshops and open labs, and the feedback from the attendees, the challenges facing the R Open Labs and possible ways to improve them are as follows:

  1. Due to lack of a clear syllabus for the whole semester and its self-paced nature, most participants are not motivated to attend R Open Labs regularly. To help participants have a better idea of the progress of open labs, we can try to post topics for each session a month in advance on the workshop list. We can also maintain a GitHub repository and upload materials used for instruction after each session so that other interested individuals could easily access them.
  2. Although the Swirl package is an immensely helpful starter kit, most people new to coding and statistics still struggle with very basic R operations. Furthermore, the huge gap between basic operations and being able to fully implement a research project can be frustrating and overwhelming. Therefore, instead of Swirl, we could provide participants with some sample code and links to GitHub repositories, so that they could use them as a starting point for their own projects and learn best practices of building a project with R
  3. Some questions are frequently asked by the participants, so we can probably provide participants with a list of FAQs and the general answers to maximize efficiency.

To conclude, this internship motivated me to think deeper about teaching and better understand people’s needs. It was an incredibly challenging and rewarding experience. As data analysis becomes increasingly important in a multitude of research areas ranging from biology to history, R is becoming an essential research tool. I hope by continuing to make improvements to the contents and structure of R Open Lab, it could serve as a platform to introduce R as a useful digital tool and promoting collaboration between scholars interested in R.

 

Python Open Labs – Spring 2017

Hi

This post details my experience as a Digital Science Center Teaching Intern for the Spring ‘17 semester, wherein I hosted the weekly Python Open Labs to teach programming with python. This internship is my first full fledged teaching experience where I got complete freedom to choose the topics that I introduced during Python Open Labs and the way I conducted  weekly sessions and a couple of workshops on python through the semester. My internship this semester was in continuation of the year long Digital Science Centers Teaching Internship that I secured in Fall 2016. A detailed post about my last semester’s experience can be found on this link: Muggles Speak English. Pythonistas Speak Python

This semester I continued introducing new topics in Python, building on top of the basics of programming that were covered in the open labs held in Fall 2016 semester. The broad range of topics included object oriented programming, web scraping, file and data handling etc which included applying the basic concepts of programming from past sessions in a cohesive manner to solve relatively complex problems. In particular, I had two motives for the sessions this semester: 1) To be as inclusive as possible and hence I tried to keep the open labs generic, catering to the needs of attendees from various Columbia Schools such as Law, Journalism, Medical, SIPA etc rather than restricting ourselves to a particular domain like data science or scientific programming. 2) To introduce Python as a helping tool that would make the day to research, academic and professional tasks easier for the attendees, a majority of whom had little or no prior programming experience. I ensured that everyone who attended these labs had something to take away that would facilitate their encounters with programming.

In the first half of this semester I included some advanced topics in python such as object oriented programming, file I/O and some data structures. This was in continuation of the basics of programming with python that had already been covered during the open labs sessions from previous semester. At this point of open labs the main challenge I faced was to ensure that people attending the labs were able to grasp the concepts very well and tie the multiple concepts together as we moved towards more complex applications and problem solving. This required extended practice problems and discussions during the two hour long weekly open labs. This approach towards teaching meant less number of slides and more examples to give a better perspective to everyone, which also helped me get better at explaining concepts to others and be involved in detailed discussions.

The second half of semester was concentrated towards covering on-demand topics from the people who attended Python Open Labs. As a result we got to cover a good number of python libraries and topics like BeautifulSoup for web scraping, csv module for csv file handling, lxml parser for XML parsing and the requests module for handling web requests. These are some of the topics that I had initially thought to be too complex to be introduced in the open labs, but it turned out to be a pleasant experience that many of the attendees specifically asked for these topics which related with their academic and professional works and they were able to better relate with these topics combined together with the basics of programming. It ensured that they were able to practically apply the programming concepts that were covered throughout the open labs to their advantage and also gave me an opportunity to learn many new things about Python as a programming language.

To conclude this post I must mention that the past one year as a teaching intern with the Digital Science Center, Columbia University Libraries was a wonderful enriching experience that gave me a good insight into teaching a self-designed open course, an opportunity to interact with many people from various backgrounds and to brush up my skills on python. I am thankful to Columbia Libraries for providing this great opportunity for students.

Muggles Speak English. Pythonistas Speak Python.

Python is one of the fastest growing programming languages, owing to its simplicity of syntax, varied applications ranging from simplistic tasks such as Hello World program to crunching huge amounts of data for multi-million dollar companies or numerous research and academic works. As more and more fields integrate computer science into their regular work flow, the importance and need of programming knowledge is set to grow, especially Python.

In Fall 2016 semester, I had an awesome opportunity to host weekly open labs for sharing my knowledge of Python programming language with everyone from Columbia University, under the Digital Centers Internship Program with Columbia Libraries. This was quite a humbling experience for me as a teaching intern where I enjoyed the freedom and challenge to create my own course content, to closely interact with lots of people and introduce them to the niches of programming through Python.

As a Digital Center Teaching Intern, the most prominent takeaway was my first teaching experience, as I learned along the way how to grasp things myself in a crystal clear way and explain them simplistically to others. Initially I designed the open labs based on the Python course taught by Dr. Charles Severance on Coursera and gradually learned how to create my own new content to explain the concepts in a better way. Throughout the semester long internship I concentrated on introducing the basic concepts of programming and computation challenges through Python, not limiting the scope to just Python.

During this teaching internship in Fall 2016, the biggest challenge was to make teaching inclusive for all the attendees, most of whom had no or very little programming experience. The attendees of Python Open Labs were from various schools within Columbia, including Journalism, CUMC, SIPA and Columbia Law which posed a challenge to keep the content simple and basic yet informative enough to enable to take on any kind of programming task that might come along their way. Hence, I concentrated on introducing basics like conditional statements, string processing, file handling, loop statements, breaking solutions into small individual tasks, defining functions and organising code into packages and modules. This is where I enjoyed the most as I got to choose and design my own course as a first time teaching experience, right from scratch while trying to understand the same task or problem from the various different perspectives of attendees in open labs.

Python Open Labs this semester also included an experimental component of introducing a powerful and popular open source library to participants in each session, such as csv library for reading comma separated large sized files for data processing, however given the inexperience with prior programming for most of the audience of open labs, this turned out to be a difficult task, making me more aware of the knowledge gap that exists for people who want to use programming but are unable to do so due to lack of basics which most of the open sourced libraries assume at the user’s end. Therefore, I put this on hold for the rest of the semester and continued with the basics of programming through Python.

As the semester comes to close, so far we have had 10 open lab sessions in this semester wherein I covered programming topics ranging from simple tasks like printing or simple arithmetic to more complex ones like processing large input data from text files. In the next semester I will be continuing with the teaching internship and plan to once again try to introduce the open source libraries for various tasks such as data processing, analysis and a simplistic web development framework etc which truly unleash the power of Python as a modern programming language which is capable of accomplishing maximum work in minimal effort.