Adding some notes about the ctypes module and GIL

Author: crmpicco

advanced-oop.md

@@ -244,6 +244,8 @@ Decorators are a way to modify or enhance the behaviour of functions or methods.
 
 Decorators allow you to create a read-only attribute
 
+The `property` function (`@property` decorator) returns a descriptor object.
+
 ```python
 def require_admin(func):
     def wrapper(user, *args, **kwargs):
@@ -513,6 +515,7 @@ Metaclasses are classes of classes.
 * can replace or modify attributes of classes
 * have the ability to control class creation by modifying or replacing it
 * has similarites to superclasses, but you want to use a metaclass when modifying or enforcing structure at the **class definition level** whereas a superclass is used for sharing logic or data across instances
+* the `__new__` method in a metaclass is a factory that is responsible for creating the actual class object. It runs before `__init__`.
 * they are utilised by frameworks such as [Django](https://www.djangoproject.com/) and [Flask](https://flask.palletsprojects.com/en/stable/)
 ```python
 class ScottishMeta(type):
@@ -565,6 +568,7 @@ Sets:
 * yields values lazily, meaning it produces each value only when requested and resumes execution from where it left off after each `yield`
 * When the generator is exhausted, it raises a `StopIteration` exception to signal that there are no more values to `yield`
 * If a generator function executes a `return` statement, it raises a `StopIteration` exception with the value specified in the `return` statement as its argument
+* `send(value)` - resumes the generator and sends a value that replaces the result of the current `yield` expression
 ```python
 def process_files():
     print("Opening file system")

coding-conventions.md

@@ -49,7 +49,7 @@ microsoft_azure = 3
 
 The restricted line length originates from the early days of computing when terminals were limited to 80 characters per line. This convention is still followed in Python to ensure code readability across different editors and environments.
 
-### Trailing commas
+### [Trailing commas](https://peps.python.org/pep-0008/#when-to-use-trailing-commas)
 Trailing commas are mandatory when making a tuple of one element, even although they appear redundant.
 ```python
 towns = ('Mauchline',)
@@ -159,7 +159,7 @@ def get_user(user_id: UserId):
 To make a class usable with a `with` statement, you need to implement the `__enter__()` and `__exit__()` methods. 
 
 * `__enter__()` - called when the block is entered
-* `__exit__()` - called when the block is exited. Always called even if an exception occurs inside the `with` block. This allows context managers to clean up resources.
+* `__exit__()` - called when the block is exited. Always called even if an exception occurs inside the `with` block. This allows context managers to clean up resources. When an exception is raised inside the `with` block, Python automatically calls `__exit__()`.
 
 ```python
 class APIConnection:

network-programming.md

@@ -74,6 +74,11 @@ print(json_output)
 ## socket
 The `socket` module provides access to the BSD socket interface. It is used to create network connections and communicate over the network.
 
+It has three parts:
+1. Protocol
+2. Local address
+3. Local port
+
 `socket.accept()` - allows a server socket to accept requests from a client socket from another host.
 ```python
 import socket
@@ -125,6 +130,10 @@ service = socket.getservbyport(53, 'udp')
 print(f"Service on UDP port 53: {service}")
 # domain
 ```
+`SOCK_STREAM` - provides a reliable, connection-oriented byte stream. Used for TCP connections.
+
+`SOCK_DGRAM` - provides a connectionless, unreliable **d**ata**gram** service. Used for UDP connections.
+
 Clients - request services from servers. They initiate the connection to the server and send requests for data or services.
 
 Servers - provide services to clients. They listen for incoming connections and respond to client requests.
@@ -241,4 +250,7 @@ The `multiprocessing` module bypasses the Global Interpreter Lock (GIL) by using
 `queue.Queue` is thread-safe, meaning that multiple threads can safely add and remove items from the queue without causing data corruption or inconsistencies. Specifically designed for thread-safe communication. Safe to use across processes. However, the order in which items arrive is not guaranteed because the processes run in parallel.
 
 #### Global Interpreter Lock (GIL)
-The GIL is a mutex/lock used by CPython (the standard implementation of Python) to protect access to Python objects, preventing multiple threads from executing Python bytecodes at once. This means that even in a multithreaded program, only one thread can execute Python code at a time.
+The GIL is a mutex/lock used by CPython (the standard implementation of Python) to protect access to Python objects, simplify memory management, preventing multiple threads from executing Python bytecodes at once. This means that even in a multithreaded program, only one thread can execute Python code at a time.
+
+### ctypes
+`ctypes` serves as a foreign function library, enabling Python to wrap and call functions from compiled C libraries without writing C extension code.