{"id":28166413,"url":"https://github.com/hevalhazalkurt/dev-notes","last_synced_at":"2026-03-02T22:46:26.170Z","repository":{"id":289844838,"uuid":"972577959","full_name":"hevalhazalkurt/dev-notes","owner":"hevalhazalkurt","description":"A bunch of my dev notes, blog posts, and things I've learned while building stuff. Questions, thoughts, and comments are always welcome,  let’s chat!","archived":false,"fork":false,"pushed_at":"2025-09-08T12:03:53.000Z","size":218,"stargazers_count":2,"open_issues_count":0,"forks_count":0,"subscribers_count":2,"default_branch":"main","last_synced_at":"2025-09-08T14:15:49.208Z","etag":null,"topics":["blog","experience","learning","programming","python","writing"],"latest_commit_sha":null,"homepage":"https://hevalhazalkurt.com/","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hevalhazalkurt.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-04-25T09:59:11.000Z","updated_at":"2025-09-08T12:03:57.000Z","dependencies_parsed_at":"2025-05-13T18:34:48.462Z","dependency_job_id":"1701ef0a-753f-43dc-b517-cd0570be0683","html_url":"https://github.com/hevalhazalkurt/dev-notes","commit_stats":null,"previous_names":["hevalhazalkurt/dev-notes"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/hevalhazalkurt/dev-notes","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevalhazalkurt%2Fdev-notes","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevalhazalkurt%2Fdev-notes/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevalhazalkurt%2Fdev-notes/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevalhazalkurt%2Fdev-notes/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hevalhazalkurt","download_url":"https://codeload.github.com/hevalhazalkurt/dev-notes/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevalhazalkurt%2Fdev-notes/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":275220386,"owners_count":25426060,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-09-15T02:00:09.272Z","response_time":75,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["blog","experience","learning","programming","python","writing"],"created_at":"2025-05-15T13:12:14.083Z","updated_at":"2026-03-02T22:46:21.131Z","avatar_url":"https://github.com/hevalhazalkurt.png","language":null,"readme":"# Dev-Notes\nYou can check [my personal blog](https://hevalhazalkurt.com/) for a better reading experience.\n\n\u003cbr\u003e\n\n\n## Python \n\n| Article | Tags | \n|--|--|\n| [Shallow vs Deep Copies in Python, What You Think You Know (but Might Not)](notes/0001_Shallow_vs_Deep_Copies_in_Python_What_You_Think_You_Know_but_Might_Not.md) | `copy`, `shallow copy`, `deep copy` |\n| [Trash Talk: Understanding Python’s Garbage Collector](notes/0002_Trash_Talk_Understanding_Pythons_Garbage_Collector.md) | `gc module`, `memory`, `performance`|\n| [The Power of `yield from` in Python Generators](notes/0003_The_Power_of_yield_from_in_Python_Generators.md) | `generators`, `yield from`, `fastapi`|\n| [How Async/Await Evolved from Generator-Based Coroutines](notes/0004_How_Async_Await_Evolved_from_Generator_Based_Coroutines.md) | `generators`, `async` , `asyncio` |\n| [How Order Changes Behavior in Chained Decorators](notes/0005_How_Order_Changes_Behavior_in_Chained_Decorators.md) | `generators`, `async`, `decorators`, `order`, `auth`, `logging`, `retry` |\n| [Creating Declarative APIs with Class Decorators in Python](notes/0006_Creating_Declarative_APIs_with_Class_Decorators_in_Python.md) | `class`, `class decorators`, `declarative api`, `decorators`, `metaclass` |\n| [Keys to Mastering Python Method Decorators](notes/0007_Keys_to_Mastering_Python_Method_Decorators.md) | `class`, `method decorators`, `classmethod`, `staticmethod`, `property`, `factory methods`, `registry` |\n| [The Danger of Overusing `is` Instead of `==` in Python](notes/0008_The_Danger_of_Overusing_is_Instead_of_==_in_Python.md) | `equality`, `comparison` |\n| [Behind the Underscores EP01: Understanding Python’s Special Methods Conceptually](notes/0009_Behind_the_Underscores_EP01_Understanding_Pythons_Special_Methods_Conceptually.md) | `class`, `oop`, `special methods`, `dunder methods`|\n| [Behind the Underscores EP02: Object Initialization and Construction Methods (`__new__`, `__init__`, `__del__`)](notes/0010_Behind_the_Underscores_EP02_Object_Initialization_and_Construction_Methods_new_init_del.md) | `class`, `oop`, `special methods`, `dunder methods`, `initialization`, `construction`|\n| [Behind the Underscores EP03: String Representation Methods (`__str__`, `__repr__`, `__format__`)](notes/0011_Behind_the_Underscores_EP03_String_Representation_Methods_str_repr_format.md) | `class`, `oop`, `special methods`, `dunder methods`, `string`, `representation`|\n| [Behind the Underscores EP04: Arithmetic Methods (`__add__`, `__sub__`, `__mul__`)](notes/0012_Behind_the_Underscores_EP04_Arithmetic_Methods_add_sub_mul.md) | `class`, `oop`, `special methods`, `dunder methods`, `math` |\n| [Behind the Underscores EP05: Comparison Methods (`__eq__`, `__lt__`, `__gt__`)](notes/0013_Behind_the_Underscores_EP05_Comparison_Methods_eq_lt_gt.md) | `class`, `oop`, `special methods`, `dunder methods`, `comparison` |\n| [Behind the Underscores EP06: Bitwise Methods (`__and__`, `__or__`, `__xor__`)](notes/0014_Behind_the_Underscores_EP06_Bitwise_Methods_and_or_xor.md) | `class`, `oop`, `special methods`, `dunder methods`, `bitwise`|\n| [Behind the Underscores EP07: Container protocol (`__getitem__`, `__setitem__`, `__delitem__`)](notes/0015_Behind_the_Underscores_EP07_Container_protocol_getitem_setitem_delitem.md) | `class`, `oop`, `special methods`, `dunder methods`, `container`|\n| [Behind the Underscores EP08: Length and iteration Methods (`__len__`, `__iter__`, `__next__`, `__contains__`)](notes/0016_Behind_the_Underscores_EP08_Length_and_iteration_Methods_len_iter_next_contains.md) | `class`, `oop`, `special methods`, `dunder methods`, `iteration`, `length`|\n| [Behind the Underscores EP09: Attribute Access (`__getattr__`, `__getattribute__`, `__setattr__`, `__delattr__`)](notes/0017_Behind_the_Underscores_EP09_Attribute_Access_getattr_getattribute_setattr_delattr.md) | `class`, `oop`, `special methods`, `dunder methods`, `attribute access`|\n| [Behind the Underscores EP10: Context Management (`__enter__`, `__exit__`)](notes/0018_Behind_the_Underscores_EP10_Context_Management_enter_exit.md) | `class`, `oop`, `special methods`, `dunder methods`, `context management`|\n| [Behind the Underscores EP11: Callable Objects: `__call__`](notes/0019_Behind_the_Underscores_EP11_Callable_Objects_call.md) | `class`, `oop`, `special methods`, `dunder methods`, `callable`|\n| [Behind the Underscores EP12: Descriptor Protocol (`__get__`, `__set__`, `__delete__`)](notes/0020_Behind_the_Underscores_EP12_Descriptor_Protocol_get_set_delete.md) | `class`, `oop`, `special methods`, `dunder methods`, `descriptor protocol`|\n| [Behind the Underscores EP13: Metaprogramming Methods (`__class__`, `__bases__`, `__mro__`, `__instancecheck__`)](notes/0021_Behind_the_Underscores_EP13_Metaprogramming_Methods_class_bases_mro_instancecheck.md) | `class`, `oop`, `special methods`, `dunder methods`, `metaprogramming` |\n| [Understanding Async Context Managers in Python](notes/0022_Understanding_Async_Context_Managers_in_Python.md) | `async`, `context manager`, `asyncio`, `connection pool`, `contextlib`, `fastapi`|\n| [How the GIL Affects Real Python Workloads](notes/0023_How_the_GIL_Affects_Real_Python_Workloads.md) | `gil`, `performance`, `asyncio`, `threading`, `multiprocessing`, `fastapi`|\n| [Slotted classes with `__slots__` in Python](notes/0024_Slotted_classes_with_slots_in_Python.md) | `class`, `oop`, `special methods`, `dunder methods`, `memory`, `performance`, `dataclasses` |\n| [The Art of Scope Management in Modular Python Design](notes/0025_The_Art_of_Scope_Management_in_Modular_Python_Design.md) | `scope`, `sqlalchemy`, `fastapi`, `dependency injection`|\n| [Designing Retryable Asynchronous APIs Using functools.partial and Custom Decorators](notes/0026_Designing_Retryable_Asynchronous_APIs_Using_functools_partial_and_Custom_Decorators.md) | `rest api`, `async`, `fastapi`, `functools`, `decorators`, `retry`, `partial` |\n| [Dataclasses vs Pydantic vs TypedDict vs NamedTuple in Python](notes/0027_Dataclasses_vs_Pydantic_vs_TypedDict_vs_NamedTuple_in_Python.md) | `class`, `data model`, `dataclass`, `pydantic`, `typeddict`, `namedtuple`, `fastapi`|\n| [Why Composition Beats Inheritance in Large-Scale Python Systems](notes/0028_Why_Composition_Beats_Inheritance_in_Large_Scale_Python_Systems.md) | `class`, `inheritance`, `composition`, `fastapi`, `payment`|\n| [Encapsulation and Domain-Driven Design in Python Projects](notes/0029_Encapsulation_and_Domain_Driven_Design_in_Python_Projects.md) | `class`, `encapsulation`, `domain driven design (ddd)`, `order`|\n| [Instance vs Class vs Static Methods in Python](notes/0030_Instance_vs_Class_vs_Static_Methods_in_Python.md) | `class`, `instance`, `instance method`, `classmethod`, `staticmethod`, `function`|\n| [Combining Abstract Classes with Factory and Strategy Patterns in Python](notes/0031_Combining_Abstract_Classes_with_Factory_and_Strategy_Patterns_in_Python.md) | `class`, `abstract class`, `abc`, `abstractmethod`, `payment`, `notification`, `factory class`|\n| [Architecting a Multithreaded Log Monitor in Python](notes/0032_Architecting_a_Multithreaded_Log_Monitor_in_Python.md) | `threading`, `gil`, `memory`, `performance`, `queue`, `logging`|\n| [Advanced Shared State Management in Python Multiprocessing](notes/0033_Advanced_Shared_State_Management_in_Python_Multiprocessing.md) | `multiprocessing`, `shared states`, `context manager`, `shared memory`|\n| [Mastering Task Lifecycle in Python’s asyncio](notes/0034_Mastering_Task_Lifecycle_in_Pythons_asyncio.md) | `asyncio`, `task`, `taskgroup`, `fastapi`|\n\n\n\n\u003cbr\u003e\n\n## Database \u0026 ORM\n\n| Article | Tags | \n|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|\n| [Designing Robust Transaction Management with Nested Transactions and Savepoints in SQLAlchemy](notes/0035_Designing_Robust_Transaction_Management_with_Nested_Transactions_and_Savepoints_in_SQLAlchemy.md) | `sqlalchemy`, `transaction`, `savepoint`, `nested`, `commit`, `rollback`, `retry` |\n| [Optimistic vs. Pessimistic Locking in ORMs](notes/0036_Optimistic_vs_Pessimistic_Locking_in_ORMs.md)| `locking`, `sqlalchemy`, `row-level`, `table-level`, `advisory-level` |\n| [Designing Reusable and Scalable ORM Models with Declarative Base and Mixins](notes/0037_Designing_Reusable_and_Scalable_ORM_Models_with_Declarative_Base_and_Mixins.md) | `sqlalchemy`, `declarative base`, `mixin`, `declared_attr`, `registry`, `soft delete`, `uuid`, `timestamp`, `audit` |\n| [How to Defeat the N+1 Problem with joinedload, selectinload, and subqueryload](notes/0038_How_to_Defeat_the_N1_Problem_with_joinedload_selectinload_and_subqueryload.md)| `sql`, `sqlalchemy`, `relationships`, `n+1`, `performance`, `query`, `lazy loading`, `joinedload`, `selectinload`, `subqueryload`, `bookstore` |\n| [Handling Data in Alembic Migrations When Schema Changes Aren’t Enough](notes/0039_Handling_Data_in_Alembic_Migrations_When_Schema_Changes_Arent_Enough.md) | `sql`, `migration`, `alembic`, `data model`, `schema`, `enum`, `denormalization` |\n| [Building Secure and Scalable Multitenant Systems Basics for B2B SaaS](notes/0040_Building_Secure_and_Scalable_Multitenant_Systems_Basics_for_B2B_SaaS.md) | `sql`, `sqlalchemy`, `multitenant`, `saas`, `data schema`, `data model`, `event listener`, `user roles` |\n| [Database Schema Design Patterns for Building Scalable E-commerce Applications](notes/0041_Database_Schema_Design_Patterns_for_Building_Scalable_Ecommerce_Applications.md) | `sqlalchemy`, `relationships`, `data schema`, `one-to-many`, `many-to-many`, `normalize`, `denormalize`, `polymorphic`, `e-commerce` |\n| [The Art of Not Losing Your Data (or Your Mind) with Isolation Levels](notes/0042_The_Art_of_Not_Losing_Your_Data_or_Your_Mind_with_Isolation_Levels.md) | `sql`, `sqlalchemy`, `isolation`, `acid`, `serializable`, `phantom read` |\n| [Explicit vs Implicit Transaction Management in ORMs](notes/0043_Explicit_vs_Implicit_Transaction_Management_in_ORMs.md) | `sqlalchemy`, `transaction`, `session`, `async`, `acid`, `context manager`, `fastapi`, `savepoint`, `nested`, `retry`, `event listener` |\n| [The Ultimate Guide to Full Text Search and Filter Implementation with PostgreSQL and SQLAlchemy](notes/0044_The_Ultimate_Guide_to_Full_Text_Search_and_Filter_Implementation_with_PostgreSQL_and_SQLAlchemy.md) | `postgresql`, `sqlalchemy`, `full text search`, `filter`, `sql function`, `TSVector`, `TSQuery`, `__table_args__`, `film` |\n| [Connection Pooling Deep Dive with SQLAlchemy](notes/0045_Connection_Pooling_Deep_Dive_with_SQLAlchemy.md) | `sqlalchemy`, `connection pool`, `fastapi`, `QueuePool`, `event listener`, `prometheus_client`, `gunicorn`, `asyncpg` |\n| [Managing Bidirectional Relationships in SQLAlchemy with backref and back_populates](notes/0046_Managing_Bidirectional_Relationships_in_SQLAlchemy_with_backref_and_back_populates.md) | `sqlalchemy`, `relationships`, `backref`, `back_populates`, `blog` |\n| [When to Choose NoSQL Over SQL](notes/0047_When_to_Choose_NoSQL_Over_SQL.md) | `sql`, `nosql` |\n| [Designing Scalable Order Systems with SQLAlchemy Hybrid \u0026 Column Properties](notes/0048_Designing_Scalable_Order_Systems_with_SQLAlchemy_Hybrid_Column_Properties.md) | `sqlalchemy`, `column property`, `hybrid property`, `expression`, `hybrid method`, `relationships`, `e-commerce`, `order` |\n| [Queries Taking Forever? Partitioning Might Be Your Answer](notes/0049_Queries_Taking_Forever_Partitioning_Might_Be_Your_Answer.md) | `postgresql`, `sqlalchemy`, `partitioning`, `e-commerce` |\n| [A Pythonic Approach to Scaling PostgreSQL From Monolith to Shards](notes/0050_a_pythonic_approach_to_scaling_postgresql_from_monolith_to_shards.md)| `postgresql`, `sqlalchemy`, `sharding` |\n| [Putting Your Backend on Autopilot with SQLAlchemy Events](notes/0051_putting_your_backend_on_autopilot_with_sqlalchemy_events.md) | `postgresql`, `sqlalchemy`, `events`, `user` |\n\n\u003cbr\u003e\n\n## Design Patterns and Architecture\n\n| Article | Tags | \n|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|\n| [One Menu, Two Baristas: Handling SQL \u0026 NoSQL with the Repository Pattern](notes/0052_One_Menu_Two_Baristas_Handling_SQL_NoSQL_with_the_Repository_Pattern.md) | `repository pattern`, `design pattern`, `architecture`, `postgresql`, `sqlalchemy`, `mongodb`, `sql`, `nosql` |\n| [Webhooks: “Don't Call Us, We'll Call You”](notes/0054_Webhooks_Dont_Call_Us_We_ll_Call_You.md) | `webhooks`, `fastapi`, `api`, `event`, `design pattern` |\n\n\n## Frameworks \n\n| Article | Tags |\n|-----------------------------------------------------------------------------|------------------------------------|\n| [FastAPI Middleware vs. Dependencies, A Guide to Choosing the Right Tool](notes/0053_FastAPI_Middleware_vs_Dependencies_A_Guide_to_Choosing_the_Right_Tool.md) | `fastapi`, `depends`, `middleware` |","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhevalhazalkurt%2Fdev-notes","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhevalhazalkurt%2Fdev-notes","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhevalhazalkurt%2Fdev-notes/lists"}