PlanetScale的动态

POST UPDATE ?? PVs are storage units in Kubernetes with a lifecycle independent of individual Pods, providing persistent storage across nodes and cluster crashes. PVCs are requests for storage that bind to available PVs, allowing Pods to use persistent storage. The article demonstrates creating a hostPath PV for development on a single Node cluster, which emulates network-attached storage using a local file or directory. It guides through configuring a Pod to use a PVC for storage, ensuring data persists even if the Pod restarts or is recreated. Learn more: https://lnkd.in/dnH6J355

?? Excited to share Part 2 of my Distributed Cache LLD Design series! ?? ?? In this blog post, I delve deep into the world of consistent hashing, a crucial concept in distributed systems. Here's what you'll find: 1?? Problem-Solving: Learn where consistent hashing shines and how it tackles key challenges in distributed cache systems. 2?? Understanding Consistent Hashing: Get a clear grasp of what consistent hashing is and why it's essential in distributed computing environments. 3?? Algorithm Deep Dive: Explore the inner workings of the consistent hashing algorithm, unraveling its magic step by step. 4?? Basic Implementation: Dive into a basic implementation of consistent hashing, empowering you to integrate it into your distributed cache designs effortlessly. ?? Ready to level up your distributed systems knowledge? Don't miss out on this insightful read! Check out the full blog post now! Link: https://lnkd.in/gAYM4a-t #DistributedSystems #ConsistentHashing #LowLevelDesign #DistributedCache #TechBlogs #AlgorithmDesign ????

Very useful blog on how larger than memory operations are managed in duckdb. group by, sorting, distinct, chunk reading etc.

#150daysofcodechallenge #Day53?LRU Cache : Intuition : 1. Doubly Linked List Structure: It uses a doubly linked list to maintain the order of accessed keys, ensuring efficient removal and insertion operations. 2. LRU Cache Principle: Follows the Least Recently Used (LRU) caching policy, which evicts the least recently used item when the cache reaches its capacity. 3. ListNode Class: Represents each node in the doubly linked list, containing key-value pairs. 4. HashMap: Utilizes a HashMap for quick access to nodes based on their keys, providing constant time complexity for retrieval. 5. Initialization: Initializes the cache with a specified capacity, setting up the dummy head and tail nodes for the linked list. 6. get() Method: Retrieves the value corresponding to a given key. If the key exists, it moves the accessed node to the front of the list (indicating it as the most recently used). 7. put() Method: Inserts a new key-value pair into the cache. If the key already exists, it updates the value and moves the corresponding node to the front. If the cache is full, it removes the least recently used node before inserting the new one. 8. replaceNode() Method: Moves an existing node to the front of the linked list, marking it as the most recently used. 9. addNewNode() Method: Adds a new node to the front of the linked list. Time complexity of this solution code is O(1). Space complexity of this solution code is O(capacity). This journey is going to be long and it will give lot's of learning to me.. #algorithmmastery?#dsa?#dsajourney?#leetcode

One of the new features of Cassandra 5.0: Trie memtable implementation.

Blogged: CAP Theorem In Distributed System https://lnkd.in/diZqDtmu #cap #cap_theorem #software_architecture #microservices

Do you know that JVM Metaspace has dynamic sizing and can grow as needed? To be honest, I didn’t know this until a recent production issue brought it to my attention. Our pods in a Kubernetes cluster were occasionally crashing with an "OutOfMemoryError: Metaspace". After some deep investigation, I discovered that a specific customer use case was causing a significant number of classes to be dynamically loaded at runtime, which eventually filled up the Metaspace. Since the Metaspace limit was set in our Kubernetes manifest, this led to the system running out of memory. Here’s what I learned: ?? Metaspace grows dynamically: It doesn’t have a fixed size and expands as more class metadata is loaded, but if the limit is hit, crashes can happen. ?? Memory limits matter: It's important to carefully configure your JVM settings, especially for environments with heavy class-loading operations. ?? Monitoring is key: Keep an eye on your memory usage and fine-tune resource limits based on real-world data. Huge thanks to my colleagues for helping me understand this better. This experience reminded me of the importance of proactively monitoring and tuning your infrastructure. Have you ever run into JVM memory issues? Let’s exchange insights!

OrbitDB v2.4.1 is now available. This version of OrbitDB addresses a minor library version change in Helia, using Helia’s default Libp2p libraries instead of locking them to a particular version. In particular, gossipsub and circuit-relay-v2. https://orbitdb.org https://lnkd.in/ecWhD6mt https://lnkd.in/edVJbSXD

Just found this amazing series of articles covering working of disk IO and its impact on database internals, check out these articles by Alex Petrov on Medium. https://lnkd.in/dNMdZifs * Flavors of IO: Page Cache, Standard IO, O_DIRECT * More Flavors of IO: mmap, fadvise, AIO * LSM Trees * Access Patterns in LSM Trees * B-Trees and RUM Conjecture Also take a look at his book: https://www.databass.dev/ Thank you, Alex, for sharing your expertise.