Another Extra Credit Opportuninty

[mikeizbicki]

PyCon is the main meat-space gathering of python programmers. Every year, there are presentations about cool python projects and programming techniques, and these presentations are posted to youtube at https://www.youtube.com/c/pyconus. You can get extra credit for watching these videos. (PyCon2023 happened 2 weeks ago... the videos aren't online yet... but they should be online soon.)

To get extra credit:

1. Reply to this issue. For each video you watch, provide the link to the video and write a short 2-3 sentence description of the video.
2. Your extra credit will be calculated as $\lfloor\log_2(1+ \text{number of videos})\rfloor$

[luisgomez214]

Can we watch any of the videos or do they have to be from PyCon2023?

[mikeizbicki]

@luisgomez214 Any video from any year counts.

[FallynB]

Hi! I will attach a review of 15 videos, separated in 3 different comments, for a total of 4 extra credit points.

I have learned the following:

1. Talk: Marlene Mhangami - Leadership and Identity in the Pan-African Python movement
   https://www.youtube.com/watch?v=PQmCADPolOE&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=13

• This video unpacks the experience of a woman who holds many positions of leadership and is an African American. She goes into detail about her experience in the Python Programming community and how it can be idolizing to individuals who do their jobs well. Additionally, there are alternate views of leaders as controlling people. I have found that her overall goal is to bring the community together, improve everyones skills, and strengthen the interpersonal relationships of programmers.

2. Talk - William Morrell: (Professionally) Coding with Others
   https://www.youtube.com/watch?v=IcvxW-EhEV0

• The presenter emphasizes how some people just write code to get their jobs done and how others write code for a genuine higher purpose. His goal is to inform people on the fundamentals of coding so they can practice it enough to understand and eventually create on their own. He highlights the following: documenting code well, having a way to ensure "version control" aka git to track changes, having strong commit messages, correct formatting(linter), and having specific goals and objectives when programming.

3. Talk - Bianca Rosa: Observability driven developmentrs
   https://www.youtube.com/watch?v=lxyrmsxY2KA

• There is a specific order of development that the speaker lectures about. The order is: start, crash, and production. One main thing that she discusses is prevention. A lot of the times developers run into problems when they have snowballed, and there are a lot of errors. She gives tactics on how to resolve this and write code to prevent it from occurring its the first place.

4. Talk - Vic Kumar: Writing Functional Code in Python
   https://www.youtube.com/watch?v=x7sQVLO3JJA

• A clear definition of functional programming is given. Functional programming is the art of writing programs that do not have any side effects. This means writing programs that have clean code and trackable logic. Specificity when one is programming is highlighted, and it seems that he wants people to write code that has clear instructions.

5. Talk - Trey Hunner: Python Oddities Explained
   https://www.youtube.com/watch?v=nWC73Llo170

• This video explains the nuances of how features (lists, tuples, strings, operators, and other built in functions) frequently get misused because people do not fully understand the way that they work. Methods work differently and this is especially important because Python is a dynamic language instead of static ones such as Java. It seems that the speaker is trying to being more awareness on how people should be more intentional with the way that they learn the language so they can use it better overall.

[FallynB]

6. Talk - Calvin Hendryx-Parker: Bootstrapping Your Local Python Environment
   https://www.youtube.com/watch?v=-YEUFGFHWgQ

• The speaker discusses how each version of python is not created equally. Differences can come about as a result of operating machines, packages, and where python is used and installed on ones systems. He also lays some ground rules that ensure that Python is being downloaded in a specific manner.

7. Talk - Benjamin "Zags" Zagorsky: Handling Timezones in Python
   https://www.youtube.com/watch?v=XZlPXLsSU2U

• This video reveals some flaws that could come as a result of needing time zone information in ones code. In past years, there has been no Python support for all time zones. Daylight savings time and inconsistencies depending on location cause bugs. Programmers of varying experience levels can sometimes format time zones incorrectly, so the speaker offers some remedies and "what-not-to-do" advice. He favors the django library.

8. Talk - Greg Compestine: How to Succeed with Python Across the Enterprise
   https://www.youtube.com/watch?v=1zRv5vAQCKk

• I would recommend this video to anyone who is looking to gain more information on how to set themselves up to succeed programming specifically using python. It could be very enlightening if you are looking for real steps on success. The speaker has compared the languages of C++, JavaScript, and other languages until Python was developed and started to boom.

9. Talks - Fred Phillips: Hooking into the import system
   https://www.youtube.com/watch?v=ziC_DlabFto
   [for reference this is an example of the import systems: import numpy as np]

• The author discussed the import system, import hooks, and features that can be unlocked when imports are used correctly. He solidifies that imposing consist of finding the code and loading it into the interpreter for the user to use. Sometimes there are built in modules and other times there are modules that need to be loaded from elsewhere.

10. Talk - Kelly Schuster - Paredes/Sean Tibor: Learn Python Like a 12 Year Old
    https://www.youtube.com/watch?v=OAYhKUozqf4

• The video wants to have adults develop code better by understanding how the mind of a twelve year olds works. He wants to urge aspiring programmers to increase their neuroplasticity and take a more active role in their learning. An approach of being active in your own learning and having the curiosity to know how to do things better is offered throughout.

[FallynB]

11. Talk: Sam Scott: Why Authorization is Hard
    https://www.youtube.com/watch?v=2BN96ON48U8&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=42

• Despite the title, this video is bout what makes authorization fun (and uniquely challenging). Authorization is what allows a user the right to use certain things within an app. He unpacks common apps and what authorization looks like between them. Data breeches can occur when special attention has not been made.

12. Talk - Meredydd Luff: Building a Python Code Completer
    https://www.youtube.com/watch?v=aRO7DkJrA_c&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=27

• The video is a step - by- step instruction on how to build a code completer in python. Have you ever began to type some code and gotten prompted to press tab so that the completer can fill in the rest for you? The speaker unpacks the importance of it and how it works in a way that is simpler than one may think. (He was able to build one relatively quickly under 10 minutes)

13. Pablo Galindo Salgado: Making Python better one error message at a time
    https://www.youtube.com/watch?v=5eYOQxqqWl8&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=38

• The speaker talks about a subject that is so important in programming and debugging: error messages. The lack of specificity in error messages has caused many frustration because the error message simply says that something is wrong. The programmer has to determine exactly what they are. More information on how Python is developing for the benefit of the user is given.

14. Talk - Jeremiah Paige: Intro to Introspection
    https://www.youtube.com/watch?v=5eYOQxqqWl8&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=38

• The background information that can be found within code can be brought to the surface by a lot of built in functions. The speaker urges the audience to learn more about their own code. His objective is to help other be more familiar with what it takes to retrieve information properly in Python.

15. Talk - Aaron Stephens: Python for Threat Intelligence
    https://www.youtube.com/watch?v=Zf38qncahiU&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=46

• The focus of this video is cyber security and threat detection. His steps for threat intelligence are as follows: collect data, document it, gain a deeper meaning, finding patterns, and assessing. The culmination of these things will allow for programmers to resolve threats and gain more knowledge.

[oklipfel]

Talk - Brandt Bucher: A Perfect Match link
This video taught me what structural pattern matching is, and how to use it via the match function, as is explained in PEP 636. It was really interesting to see how new python code can be accommodating to old python code. Additionally, it was very helpful to see the person who came up with the code explaining it himself, as he was able to go in depth and he has a full understanding of the code and how it works.

Keynote- Peter Wang link
In this talk Peter Wang talked a bit about the pros and cons of python, and I learned a lot in hearing his reasoning. Having code be understandable to the general public but also complicated enough to complete certain tasks is important, as well as how it doesn’t work for front end tasks as much. Seeing him live coding was also incredibly impactful, as we do live coding in class but the way in which he was able to just make the code flow so quickly was impressive and gave me a goal worth striving for in terms of type speed and understanding of each language of code.

Talk - John Reese: Open Source on Easy Mode link
This talk was helpful in providing information on how a lot of computer systems and packages are set up. His description of thx and not only how it works, but what it does was super in depth and detailed in a way that made me understand it and understand that it is important to help validate projects throughout development.

[luisgomez214]

https://www.youtube.com/watch?v=W-lZttZhsUY

The video is about what refracting is. I was introduced to the concept before but wasn’t fully familiar. Refracting is changing code to look nicer and be more efficient. Doing so allows for people to better understand it. The video goes through examples and explains the thought process that goes along with it. The video explains the benefits of it and gives tips on how to improve our own code writing.

https://www.youtube.com/watch?v=YY7yJHo0M5I

The video, like the previous one I watched, is about how to make code more efficient. This time it focuses on how to improve one’s writing. The video explains loops, list comprehension, errors and gives examples of how to implement the code. The video helped me visualize the topics differently, it was informative hearing why to write code a certain way.

https://www.youtube.com/watch?v=I4nkgJdVZFA

This video focuses on why Python is slower than most other languages. It provides different theories, such as the way you write the code, and gives recommendations on how to make it faster. Such as not using loops. The video talks about JIT visualizers and compilers and suggest that they optimize runtime. Also, the video recommends improving GC which is a place that stores data but simplifies it.

[GusAlbach]

In total below there should be 15 videos watched, for 4 total points. The video links and descriptions are as follows:

1. https://www.youtube.com/watch?v=vPokIvli8yk&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=7&pp=iAQB
   - Within not very much time, this speaker gave a bunch of reasons for the importance of a diversity of a team, particularly thinking about ethics. One of my favorite parts was the workshop method of trying to create a blackmirror episode with your AI in order to discover possible misuse. I’m particularly fond of the restaurant staff scheduling AI, this could help managers learn of any unconscious biases they have when scheduling.

2. https://www.youtube.com/watch?v=bK2iPDu7RDE&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=11&pp=iAQB
   - This one. Combined with several others felt oddly within arm’s reach for someone who’s taken this course to complete. It involved scraping data from a specific twitter account to figure out when this woman needed to move her car to avoid predictable parking tickets (based on when. Street cleaner came through). Scraping the data seemed to be the hardest part, whereas deciding if the car needed to be moved was pretty simple python, just 2 functions.

3. https://www.youtube.com/watch?v=ST33zDM9vOE&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=19&pp=iAQB
   - This video was really useful because I’d heard about dynamic typing vs static typing, and didn’t really know what that meant…Now its a fair bit clearer and the presenter even used the example we used in class “If it looks like a duck…”. My understanding got a little fuzzy but essentially the history of introducing static typing options into python or hybrids between static and dynamic were covered. I also recall seeing some static typing within one of the homeworks, and realize now that it was specifying the type of the output.

4. https://www.youtube.com/watch?v=NjMTf2UWPsw&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=21&pp=iAQB
   - This video focused on applying the principles of an airplane’s black box to python. This involved multiple attempts at creating a database that would act as this blackbox. It was found that a SQL database, a NoSQL database were to slow, but ultimately a NoSQL In-Memory database was the most successful. I also learned some details of what differentiates In-Memory databases from other types.

5. https://www.youtube.com/watch?v=GJUL3glrKvA&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=39&pp=iAQB
   - This episode was quite interesting. I recall learning about different types of joins in some math classes as well as in intro to data science. However Intro to data science never talked about runtimes as we have in CS46. The intersection of discussing runtimes and different join strategies to decrease runtimes was the primary topic of this video however. He essentially broke down the different runtimes in BigO notation, just as we need, however he was using SQL code in python. This was my first time seeing how SQL could be used in python, which was useful.

6. https://www.youtube.com/watch?v=NUk6QN02UxQ&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=40&pp=iAQB
   - This talk broke down the contrast in machine learning between building a better model and ensuring privacy of the data. Most interesting Wass the survey model where a certain percentage of people are told to truthfully answerr a question while the other portion performs a coin flip probability of how they will answer. No individual’s answer can be definitively decided as either method, but the researcher can know on average what the truthful answer was. Federated learning, involving weighing a model based on results from different devices before they’re aggregated, was also discussed.

7. https://www.youtube.com/watch?v=9c0ksQKizts&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=49&pp=iAQB
   - This talk focused on the onboarding process, particularly as it applies in tech. According to the speaker, onboarding requires a heavy dose of empathy, the creation of early on relationships with the onboardee, and the writing down of all knowledge relative to your team. The next step involved creating a FAQ about your team, as knowledge within the team may not be known around the company. Overall this felt very much like a classic HR talk, and the section about buying office goods for a remote worker matches pretty closely to the number of ridiculous things Google seemed to buy for my friend who interned there.

8. https://www.youtube.com/watch?v=2R1HELARjUk&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=50&pp=iAQB
   - Pytest, particularly parameterized testing in pytest was the critical part. Parameterizeration was shown in many ways, but was particularly useful for demonstrating more info within each test case. The downfalls of multiple failures of non-parametrization was shown (you just don’t really know perhaps which tests are failing or it is difficult to tell why). The demonstration of parametrization that grouped tests together by type was especially convincing of the power of parameterization.

9. https://www.youtube.com/watch?v=G7SIcvWrAKs&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=55&pp=iAQB
   - Grabbing my attention was this talk which focused on probability distributions and how python interacted with them. Implementing pdfs as number generators didn’t seem particularly complex in this video. The speaker used a library that had a class for each common probability distribution, and was able to pretty easy generate values by passing parameters into a given pdf. He then explored joint-likelihood functions, which involved multiplying the likelihood functions of multiple points together in an attempt to maximize the joint likelihood.

10. https://www.youtube.com/watch?v=WcbnJA2ah6U&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=5
    - This talk focused on the company structure of most companies, and the paradigm of data engineers, scientists and analysts. What interactions between these groups is optimal, how much flexibility they ought to offer one another. He then pivoted to offering Apache Airflow as a method to moderate this flexibility. My not-particularly-professional summary would claim this is similar to say slack or discord, but it allows the pipelines being run or code to integrate into apache airflow itself. Interestingly I realized I don’t know which services tech companies currently use to run company inner workings (GitHub, slack, a mix?) so I’m not precisely sure what to compare apache airflow to.

11. https://www.youtube.com/watch?v=NNWiL6DFCcg&list=PL2Uw4_HvXqvbpFquYIE57BEAqkQWk-iFg&index=93&pp=iAQB
    - This one spoke with “Aiko AI” a small startup being interviewed for the 2020 Pycon. I found this one interesting because publicly, AI has bloomed within the last year. This company focused on using AI to optimize emailing. This included creating AI to shorten emails to be more brief, and to organize based on how useful they would be to the email owner. This essentially seemed like what gmail already does, but perhaps better.

12. https://www.youtube.com/watch?v=8wgR4oroeR0&list=PL2Uw4_HvXqvYk1Y5P8kryoyd83L_0Uk5K&index=52&pp=iAQB
    - This video focused on the use of python celery as a task manager to speed up the process of querying data. Browsers seem to limit the connection a domain can have at once, which limits the ability o carry out tasks. Celery is a version of a task queue, which simply doesn’t feel very distinct from the basic queue or priority queue we’ve used in class. I also learned what a data cache was, and how it was used to store already completed queries to ensure they weren’t queried for again.

13. https://www.youtube.com/watch?v=eVdHmaE3tSM&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=26&pp=iAQB
    - I learned what distributed web scrapping is…Essentially something similar to the lambda server to complete requests to scrape data from a website url that is on a queue of websites to be scraped. The presenter mentioned completing 25,000 queues at a time, and the difficulty of dealing with long wait times, being detected as a bot, and being sure that the nodes (that essentially are the distributed scrapers) are only communicating with your controlling computer, and not introducing useless or malicious ware.

14. https://www.youtube.com/watch?v=t2EUocx3vGQ&list=PL2Uw4_HvXqvYeXy8ab7iRHjA-9HiYhRQl&index=57&pp=iAQB
    - This one lured watchers in by promising a video about dungeons and dragons. This somewhat worked on me, but the main presentation was about graph theory. Similar to the other videos, this one started pretty basic introducing the different types of graphs and their utilities. This lead to a rexplanation of breadth first search and Djikstra’s algorithm. The algorithm further discussed prime’s algorithm to create the minimum spanning tree.

15. https://www.youtube.com/watch?v=pvaIi0l1GME&list=PL2Uw4_HvXqvYk1Y5P8kryoyd83L_0Uk5K&index=9
    - I learned that a notebook was not just a fancy part of the name of Jupiter notebook, but in fact, a different way of incorporating code and rich text files in one place. This talk focused on this companies efforts to implement a notebook system on GitHub. The video further mentioned the inspiration they took from paper mill in order to create their product, and the open-source nature of their product.

[NHendelman]

Video- William Morrell: (Professionally) Coding with Others
https://www.youtube.com/watch?v=IcvxW-EhEV0

Morrell talks about the key elements of coding with others: having a READme and License file for any code that may become public, tracking changes over time with a resource like git, various commit messages and their respective functions, the benefits of using pull requests in general, and the importance of dependency management. The video was great as a high level overview/reminder of why doing more work at the start (of giving context for changes through pull requests or using tools like poetry for dependency management) does a lot to relieve headaches later on. I think it encapsulated many useful experiences from CS46 (like using git and familiarizing myself with License/READme files) but also mentioned elements that I can do to improve my programming skills (writing useful commit messages).

[nliyanage]

i watched 7 videos for a total of 3 points -
1 – professionally coding with others - https://www.youtube.com/watch?v=IcvxW-EhEV0&ab_channel=PyConUS
The presenter talks about how to create professional-quality code, even if you’re not employed in a coding profession. They discuss how to format and present your code properly. Examples of things that they talk about include documentation, version control, code quality tools, pull requests, and dependency management.

2 – localize your open source documentation - https://www.youtube.com/watch?v=0k9UkMrMBYM&ab_channel=PyConUS
The presenter talks about localization, which they define as localization being similar to translation to fit certain needs and/or contexts. They state that localization has many benefits, including that localizing can lead to more contributors.

3 – who said wrangling geospatial data at scale was easy - https://www.youtube.com/watch?v=wYtoePM83HE&ab_channel=PyConUS
This presentation gives an overview of some libraries that are used in geospatial data analysis and the ways in which those libraries and other techniques function. They say that when scaling data, it is important to choose a data format that lends itself to fast io. Raster formats are often known as faster in the geospatial world. Vector data format is slower to process, but is more accurate and has many data points. The presenter also discusses the benefits and pitfalls of various libraries such as NumPy.

4 – speed up data access with pyarrow - https://www.youtube.com/watch?v=akfsWPsvmrM&ab_channel=PyConUS
The presenter begins their presentation by emphasizing the value of data, but that accessibility of the data impacts how valuable it is and how much information can be extracted. They say that a flaw in current software is that there is more focus on functions than data, and that data is not often treated with specificity. One problem that they identify is the problem of serialization & deserialization process. A solution that they identify is a method called “Data is the new API.” They go on to discuss Apache Arrow and illustrate some examples.

5 – let’s talk about jwt - https://www.youtube.com/watch?v=JyvJYkbzBNc&ab_channel=PyConUS
This presentation is about JWT, or JSON Web Tokens. The presenter begins by providing a background on JOSE and the way in which it represents information. JWT’s are unique identifiers that contain information; the presentation walks through the various parts of a JWT such as the header, payload, reserved claims, public claims, private claims and the signature. The presentation details the specificities of JWTs, as well as the ways in which to format each portion of a JWT and what to include/not include.

6 – dungeons and dragons and graphs - https://www.youtube.com/watch?v=t2EUocx3vGQ&ab_channel=PyConUS
This presentation discusses the way in which graphs and algorithms relate to the game of Dungeons and Dragons. The presentation begins by discussing various definitions for graphs, as well as relationships that graphs are particularly good at representing. They then discuss the ways in which a graph could be used to represent a path between interactions that a D&D character could have when entering a tavern. They review some pseudocode for depth first search, and then discuss some other concepts such as breadth first search and spanning trees. The finish with an overview of some tips for how to debug when graph algorithms fail.

7 – improving app performance with snapshots - https://www.youtube.com/watch?v=0cNBVt8UvI8&ab_channel=PyConUS
The presenter discusses issues that many apps face with performance and some potential solutions. They discuss the issue of databases negatively impacting performance. Solutions to this that were discussed included database scaling (vertical and horizontal) and query tuning. They also discuss the ORM problem, which is a problem that they experienced when their company was growing quickly. They discuss multiple strategies for improving queries to resolve problems such as the ORM problem.

[finnless]

1. Talk: Eric J. Ma - A careful walk through probability distributions, using Python
   In this talk, the presenter explained the concept of probability distribution functions by describing them as python objects. I found this way of explaining the concept very intuitive and helpful. The presenter used the streamlit framework to be able to then interactively render the distribution objects in the browser. I think this paradigm of teaching statistics and other mathematical concepts has a lot of potential. I want to integrate the interactive components into an AI stem tutor I’m working on.

2. Talk - Josh Weissbock: Distributed Web Scraping in Python
   This talk was about how to do distributed web scraping effectively. The presenter proposed avoiding bot detection by adding random headers to requests, which I’m not sure I agree is a good approach in every case. Some sites change the content served based on headers like language, viewport, mobile site, etc. I appreciated the distributed mental model he shared with several scraper nodes and a single command and control node to keep track of progress and results. This is a helpful paradigm. I also had never heard of the backoff module which allows the easy use of function decorators to wrap a function and have it rerun until a condition is met, like downloading a webpage. I plan to use these learning for a webscraper project I am working on.

3. Talk: Anthony Shaw - Why is Python slow?
   This video was really cool and helped me understand how python works under the hood. I learned that when code is run it is first parsed into an Abstract Syntax Tree which is defined by the syntactic rules of python. After this step, the compiler then traverses the tree and creates a Control Flow Graph which represents all possible paths that could be traversed during the programs execution. Next the assembler traverses the control flow graphs and converts it into sequential statements as byte code that can be interpreted by the cpu. I learned these steps are cached and the resulting compiled code is what is stored in the pycache folder. I also appreciated the numba shoutout, since I have used it before to speed up code. numba is a JIT compiler for numpy.

Total Points: +2

[buffeinstein]

+2 points

1. Tutorials - Juhi, Dana: Intro to Hugging Face: Fine-tuning BERT for NLP tasks

The lecture introduced the Hugging Face's Transformers library, which provides a collection of pre-trained models for NLPs. These models are open source and cover a wide range of tasks, making it easier for developers to leverage existing models for their projects. The lecture emphasized how to explore and choose appropriate models for specific tasks within the library.

2. Tutorials - Lisa Carpenter: How to create beautiful interactive GUIs and web apps

I've learned about Streamlit, which is a powerful tool for rapidly creating interactive web applications for data visualization, model deployment, and more. It doesn't require front-end development skills and is well-suited for data scientists and analysts. It allows the coder to create various widgets such as buttons, text inputs, and data frames that allow users to interact with the app's content. Streamlit's session state feature helps maintain data across user interactions and app pages. It provides a persistent storage mechanism that keeps track of variables even as the app is reloaded or navigated between different pages.

3. Talks - Paul Ganssle: Working with Time Zones: Everything You Wish You Didn't Need to Know

In Python 3.6 and later, the zoneinfo module was introduced, which provides a more robust and accurate way to handle time zones. This module offers better support for handling ambiguous and imaginary times and provides consistent behavior for different time zone semantics. Migrating from the older pytz library to the newer zoneinfo module might be necessary due to limitations in pytz, such as the potential lack of transitions beyond 2038 or the need for faster time zone operations. The zoneinfo module aims to provide better performance, more accurate handling of transitions, and improved support for future time zone changes.