Gain insights into Python's scalability, concurrency, and distribution. Learn about CPU scaling, event loops, queue-based distribution, and building REST APIs to optimize and deploy high-performance applications.

python.tar.gz

Chapter2

Chapter7

Chapter5

Chapter6

Chapter3

Chapter7-without-etcd

Chapter8-with-etcd

Chapter9

Chapter9-gabbi

Chapter10-heroku

Chapter10-aws_eb

Chapter11_Tox_integration

Chapter11_Tox_integration-pifpaf

Chapter11_pifpaf_fixtures

Chapter12_caching

Chapter13_Performance

Chapter13_Performace_KCacheGrind

Chapter5-rq-dashboard

Chapter5-celery-flower

Chapter10-gcloud

Chapter2-zsh

Chapter13_Performace_KCacheGrind-copy

Chapter11_Tox_integration-pifpaf-postgresql

Celery-Project1_Sol

Celery-Project1_Sol2

Python, in all of its greatness, is often dismissed when needing to write performant and distributed applications. It’s considered to be slow and not suited for the task. In this course, you will find that with the right implementation of Python, you can write applications that scale horizontally, perform well, and are distributed. 

To kick things off, you’ll learn about CPU scaling, concurrency, and event loops, all of which are crucial for implementing a distributed system. After that, you’ll move on to queue-based distribution, lock management, and group memberships, which are fundamental concepts for maintaining availability and consistency in distributed applications.

In the last half, you’ll learn how to build a REST API, how to deploy your app to a PaaS, and how to optimize your application's performance.

By the end of this course, you’ll be more productive with Python, you’ll be able to write faster applications that are distributed, and you’ll have a great new skill that is highly coveted.

The Hacker's Guide to Scaling Python

Local caching has the advantage of being (very) fast, as it does not require access to a remote cache over the network. Usually, caching works by storing cached data under
a key that identifies it. This technique makes the Python dictionary the most obvious data structure for implementing a caching mechanism.

cache = {}
cache['key'] = 'value'
cache = {}

def compute_length_or_read_in_cache(s):
  try:
    return cache[s]
  except KeyError:
    cache[s] = len(s)
    return cache[s]

print("Foobar: ", compute_length_or_read_in_cache("foobar"))
print('Cache: ', cache)

print("Babaz: ", compute_length_or_read_in_cache("babaz"))
print('Cache: ', cache)

Obviously, such a simple cache has a few drawbacks. First, its size is unbound,
which means it can grow to a substantial size that can fill up the entire system memory. That would result in the death of either the process, or even the whole operating system in a worst-case scenario.

Therefore, a policy must be implemented to expire some items out of any cache, in order to be sure that the data store does not grow out of control. There are a few algorithms that can be found that are pretty simple to implement such as the following:

- Least recently used (LRU) removes the least recently used item first. This means
the last access time for each item must also be stored.
- Least Frequently Used (LFU) removes the least frequently used items first. This means the number of accesses of each item must be stored.
- Time-to-live (TTL) based removes any entry that is older than a certain period of time. This has the benefit of automatically invalidating the cache after a certain
amount of time, whereas the LRU and LFU policies are only access-based.

Methods like LRU and LFU make more sense for memoization (see [Memoization](https://www.educative.io/courses/hackers-guide-scaling-python/memoization)). Other methods, such as TTL, are more commonly used for a locally stored copy of remote data.

# `cachetools`
The [cachetools](https://pypi.org/project/cachetools/) Python package provides implementations of all those algorithms, and it is pretty easy to use as shown in the following example. There should be no need to implement this kind of cache yourself.


Local Caching

Scaling

CPU Scaling

Event Loops

Functional Programming

Queue-Based Distribution

Designing for Failure

Create a Web Crawler

Project Walkthrough

Lock Management

Group Membership

REST Interfaces

Deploying on PaaS

Testing Distributed Systems

Caching

Performance

Conclusion

Local Caching

A simple