## Bubblesort

Bubble sort is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items and swaps them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.

Time complexity:

Average case : n2

Worst case : n2

Best case : n

## FizzBuzz

What is the Fizz-Buzz test?

It’s a programming interview question designed to filter out candidates who can’t program.

Problem statement : Write a program that prints the numbers from 1 to 100. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”.

Out of curiousity, I decided to solve this problem.

My first attempt :

for ix in range(1,101):
if ix%3 == 0 and ix%5 == 0:
print("FizzBuzz")
elif ix%5 == 0:
print("Buzz")
elif ix%3 == 0:
print("Fizz")
else:
print(ix)

## concurrent.futures in Python 3

The concurrent.futures module provides a common high level interface for asynchronously executing callables using pools of threads or processes.

The concurrent.futures.Executor is a class to execute function calls asynchronously. The important methods are submit(function, args), which calls the specified function passing in the given arguments, and map(function, iterables) which calls the specified function asynchronously passing in each iterable as an argument for a separate function call. This should not be used directly, but is used through its subclasses ThreadPoolExecutor and ProcessPoolExecutor.

Let’s jump into an example. The purpose of the following program is to find the sum of all prime numbers until the given number. There are two functions to demonstrate how to use a pool of threads and how to use a pool of processes. sum_primes_thread(nums) uses threads and sum_primes_process(nums) uses processes. Notice that the only difference between the two functions is that one uses ThreadPoolExecutor while the other uses ProcessPoolExecutor.

## Multiprocessing and multithreading in Python 3

To begin with, let us clear up some terminlogy:

• Concurrency is when two or more tasks can start, run, and complete in overlapping time periods. It doesn’t necessarily mean they’ll ever both be running at the same instant. Eg. multitasking on a single-core machine.

• Parallelism is when two or more tasks are executed simultaneously.

• A thread is a sequence of instructions within a process. It can be thought of as a lightweight process. Threads share the same memory space.

• A process is an instance of a program running in a computer which can contain one or more threads. A process has its independant memory space.

The CPython implementation has a Global Interpreter Lock (GIL) which allows only one thread to be active in the interpreter at once. This means that threads cannot be used for parallel execution of Python code. While parallel CPU computation is not possible, parallel IO operations are possible using threads. This is because performing IO operations releases the GIL. To learn more about the GIL refer here.

## Analyzing programming language statistics of 100,000 Github repositories

The first step is to gather data about 100,000 repositories using the Github api. I used scrapy for this.

A high level overview of how I did this:

1. Start from the id of my scrape_github repo https://api.github.com/repositories?since=76761293&access_token=MY_TOKEN

2. Save only the id, name and languages_url for each repo. The languages_url is the api endpoint which contains the programming language statistics of the current repo.