Not long ago, writing code was seen as the pinnacle of technical mastery. Engineers poured over algorithms, wrestled with bugs, and took pride in the elegance of their solutions. Today, AI systems like GitHub Copilot can write, debug, and optimize code faster than most humans ever could. The future of software engineering seems increasingly automated. But this shift raises a deeper question: if machines do the building, what becomes of human ingenuity?

A Brief History of Invention

From Edison’s light bulb to Turing’s computing machine, the story of progress has been driven by human inventors who combined persistence, imagination, and technical skill. Patents rewarded originality. Recognition flowed to those who dared to push boundaries. Human effort wasn’t just about the output — it was about the journey: years of trial, error, and eventual insight.

The AI Shift

Enter the era of AI copilots, agents, and autonomous systems. With a single prompt, AI can generate a website, architect a database, or even suggest entirely new algorithms. The barriers to creation are collapsing. This democratizes innovation, but it also blurs the definition of invention. If an AI builds a system from your idea, who is the true creator — the human with the vision, the AI with the execution, or the company that owns the AI model?

It is predicted that 95% of programming code will be AI-generated by 2030, fundamentally shifting developers from coders to orchestrators of AI systems.

The Legal & Ethical Gap

Current patent law assumes humans invent. But what happens when AI drafts a novel molecule, or codes a non-obvious solution? Courts worldwide have ruled that AI can’t be listed as an inventor. Yet, this feels like a temporary patch, not a lasting answer.Future law may need to evolve toward recognizing human-AI collaboration — protecting the vision and judgment of the human while acknowledging the machine’s contribution. Then there’s ethics. AI solutions often inherit biases buried in their training data. That makes human oversight not optional, but essential.

The New Human Frontier

If AI automates execution, human excellence shifts upward — from hands-on building to strategic orchestration. The future innovator is less a “builder” and more a director, curator, and strategist.

1. Framing Problems: Deciding what’s worth solving matters more than solving it. A human must define the goal — “create a more efficient way to manage a city’s traffic flow” — before AI can generate solutions.

2. Taste & Judgment: An AI can generate a thousand design options, but only a human has the vision and aesthetic sensibility to select the best one.

3.Ethical Curation: Just because AI can generate something, doesn’t mean it should be deployed. Humans remain the moral compass, especially in sensitive fields like medicine or finance.

4. Interdisciplinary Integration: Connecting AI outputs across law, business, and society requires a holistic perspective machines lack.

This shift may displace some traditional coding jobs, but it will also create new, higher-level roles — focused on guiding, managing, and integrating AI into the fabric of innovation.

The Future of Recognition

Look at chess: AI now plays better than any human. But we still celebrate grandmasters for their creativity, courage, and psychological insight. Similarly, in software and invention, recognition may evolve from who coded it to who guided it well.

Human ingenuity won’t vanish — it will simply move from execution to orchestration.

Paris — Along the Seine to the Eiffel Tower

There’s nothing quite like running in Paris. My 10K started near the Latin Quarter and wound its way along the Seine. Each kilometer felt like a postcard — Notre Dame, the Louvre, Place de la Concorde, and finally, the Eiffel Tower waiting like a finish-line trophy.

Why it’s beautiful: The Seine is your running companion, and every bridge is a new perspective of the city. Finishing under the Eiffel Tower? It doesn’t get more iconic than that.

Rome — From the Colosseum to Trastevere

Rome is an open-air museum, and running here is like racing through history. My 10K route began near the Colosseum, passed Circus Maximus, and crossed the Tiber River into the vibrant Trastevere district. Every step had ancient ruins, cobblestone streets, and fountains as backdrops.

Why it’s beautiful: Few runs let you warm up with the Colosseum at sunrise and cool down in Trastevere’s lively piazzas. The mix of ancient and modern energy is unmatched.

Athens — Through the Heart of Ancient Civilization

Munich — The Ammersee Lakefront Escape

Instead of city streets, Munich surprised me with a lakeside gem: Ammersee. My 10K run hugged the shoreline starting from Herrsching, with the water glistening on one side and Bavarian forests on the other. The route was calm, scenic, and refreshing.

Why it’s beautiful: Running by Ammersee feels like meditation in motion — clear blue waters, sailboats drifting in the distance, and alpine air filling your lungs. It’s a perfect balance of endurance and tranquility.

Final Thoughts

Running 10K in each city gave me more than just fitness; it gave me a deep connection with the places I visited. Paris gave me elegance, Rome gave me history, Athens gave me legacy, and Munich gave me serenity. If you’re a running enthusiast and love travel, lace up your shoes — you’ll never see a city the same way again.

1. Introduction:

In TFT, items are akin to the special equipment or superpowers that elevate your favorite superheroes. While a champion possesses inherent strength, equipping them with a magical staff, a robust shield, or a speed-boosting gauntlet unlocks their full potential. These items serve as crucial gear, making your champions stronger, faster, more resilient, or enabling them to unleash their extraordinary abilities more frequently. The strategic significance of items cannot be overstated: selecting and applying the correct items to the right champions is a pivotal factor in securing victory, allowing your team to outperform opponents in combat.

2. The Building Blocks: Basic Item Components and Their Powers

Every formidable item in TFT originates from fundamental building blocks, much like how intricate LEGO creations begin with individual bricks. There are nine primary basic items that form the foundation of all advanced gear, along with a distinct new addition in Set 13: the Frying Pan. Players typically acquire these components by defeating neutral monsters or by selecting them from the shared carousel rounds. Understanding the core function of each basic item is the first step toward mastering itemization.

• B.F. Sword: This gleaming sword enhances a champion’s raw attack power, making their basic attacks hit with greater force. It is an ideal component for champions who rely on physical damage output.
• Chain Vest: A sturdy piece of armor, the Chain Vest provides physical defense, making champions more resistant to incoming physical attacks. It acts as a protective barrier, similar to a knight’s shield.
• Giant’s Belt: This substantial belt significantly increases a champion’s maximum health, allowing them to endure combat for longer durations. It effectively grants them additional survivability.
• Needlessly Large Rod: A mystical staff, the Needlessly Large Rod boosts the power of a champion’s spells and abilities, making their magical attacks or healing effects much more potent. It functions as a conduit for amplified magical energy.
• Negatron Cloak: This shadowy cloak grants magic resistance, reducing the damage taken from enemy spells and magical abilities. It provides a crucial defense against magic-focused compositions.
• Recurve Bow: A swift and agile bow, the Recurve Bow increases a champion’s attack speed, enabling them to launch attacks or abilities more rapidly. It is highly beneficial for champions who benefit from frequent offensive actions.
• Sparring Gloves: These versatile gloves offer a chance for champions to land critical strikes (attacks that deal extra damage) or to dodge incoming attacks. They introduce an element of precision and evasion to combat.
• Spatula: A truly unique and mysterious item, the Spatula provides no direct stats on its own. However, its true power lies in its ability to combine with any other basic item to grant a champion a new “trait,” effectively allowing them to join a new team synergy. It serves as a wildcard, capable of fundamentally altering team compositions.
• Tear of the Goddess: This luminous tear accelerates a champion’s mana regeneration, allowing them to cast their impactful abilities more frequently. It acts as a constant source of magical energy replenishment.
• Frying Pan (New!): Introduced in Set 13, the Frying Pan is more than just a cooking utensil. It provides champions with increased resilience against “critical hits” — those exceptionally strong attacks — and can even reflect a portion of the blocked damage back to the attacker. This makes it a powerful defensive tool against high-damage threats. A notable feature of the Frying Pan is its ability to be reforged into a Spatula, offering players increased flexibility in their item choices.

The Frying Pan’s unique properties demonstrate a deeper layer of strategic flexibility within Set 13’s item system. Its primary defensive effect against critical strikes means that if opponents are prioritizing critical strike items, players can directly counter this strategy by building Frying Pans. Furthermore, its capacity to be reforged into a Spatula provides an adaptive pathway; if a player finds themselves needing a specific trait emblem for their composition, the Frying Pan can be converted to facilitate that need. This design choice means that item choices are not merely about accumulating raw power, but about dynamically responding to the evolving game state and opponent strategies, offering players more tools to adjust their approach.

Table 1: Your Basic Item Toolbox

3. Crafting Awesome Gear: Combined Items and Their Magic

When two basic items are combined, they transform into a powerful “combined item,” representing the ultimate gear for your champions. These advanced items provide significant boosts and unique effects, tailored to specific champion roles.

Items for Attackers (AD Carries): Make Them Hit Super Hard!

These items are designed to maximize the physical damage output of champions who primarily rely on their basic attacks and attack-scaling abilities.

• Infinity Edge: Formed by a B.F. Sword and Sparring Gloves, this item ensures that the champion’s attacks always land as critical strikes, delivering maximum damage. It is a cornerstone item for champions focused on consistent, high-impact auto-attacks.
• Deathblade: Created by combining two B.F. Swords, the Deathblade provides a substantial increase to a champion’s raw attack damage. This item is particularly effective on champions like Draven, whose abilities scale directly with their attack damage.
• Guinsoo’s Rageblade: The combination of a Needlessly Large Rod and a Recurve Bow, this item grants stacking attack speed with every attack, allowing the champion to attack progressively faster throughout combat. It is invaluable for hyper-carries who benefit from sustained, rapid attacks.
• Giant Slayer: Crafted from a B.F. Sword and a Recurve Bow, this item causes the champion to deal additional damage to enemies with high maximum health. It is one of the few items that offers multiplicative scaling, making it exceptionally potent against durable frontline units.
• Last Whisper: Combining Sparring Gloves and a Recurve Bow, this item allows a champion’s physical damage to reduce the target’s armor. This effect makes enemies easier to damage, especially those with significant defensive stats, and pairs well with Infinity Edge against armored teams.
• Runaan’s Hurricane: Made from a Negatron Cloak and a Recurve Bow, this item causes the champion’s basic attacks to fire an additional projectile at a nearby enemy. This effectively allows the champion to damage multiple targets simultaneously, providing multiplicative scaling for auto-attack focused champions.

Items for Spellcasters (AP Carries): Make Their Spells Powerful!

These items are tailored to enhance the magical damage and ability casting frequency of champions who rely on their spells.

• Blue Buff: Created by combining two Tears of the Goddess, this item is a potent mana-generating tool. It is primarily used on champions with low mana costs, enabling them to cast their abilities continuously and rapidly.
• Spear of Shojin: The result of combining a B.F. Sword and a Tear of the Goddess, this item restores mana to the champion with each attack. It is highly effective for champions who benefit from frequent ability casts and also have a reasonable attack speed.
• Jeweled Gauntlet: Crafted from Sparring Gloves and a Needlessly Large Rod, this item allows a champion’s spells to critically strike, significantly increasing their burst damage potential. It is a very powerful item for magic damage carries seeking multiplicative scaling.
• Rabadon’s Deathcap: Formed by combining two Needlessly Large Rods, this item provides a substantial boost to a champion’s ability power, making their spells hit much harder. It is a core item for spellcasters aiming for raw damage amplification.
• Archangel’s Staff: The combination of a Tear of the Goddess and a Needlessly Large Rod, this item causes a champion’s ability power to increase progressively throughout combat. This makes their spells grow stronger as the fight progresses, benefiting champions who can sustain long engagements.
• Morellonomicon: Made from a Giant’s Belt and a Needlessly Large Rod, this item applies a burn effect and reduces healing received by enemies hit by the champion’s spells. It is highly effective against compositions with significant healing and is particularly strong on champions with area-of-effect abilities.

Items for Tanks (Frontliners): Make Them Super Tough!

These items are designed to maximize the durability and survivability of champions positioned on the frontline to absorb damage.

• Warmog’s Armor: Created by combining two Giant’s Belts, this item provides an immense boost to a champion’s maximum health, making them exceptionally difficult to defeat. It is a solid choice for increasing the survivability of any unit, whether a dedicated tank or a crucial unit that needs to remain alive.
• Bramble Vest: Formed by combining two Chain Vests, this item reduces damage taken from critical strikes and passively deals magic damage to adjacent enemies when struck by an attack. It is excellent for tanks, particularly against physical damage compositions.
• Dragon’s Claw: The result of combining two Negatron Cloaks, this item provides substantial magic resistance, significantly reducing incoming magic damage. It is ideal for frontliners facing magic-heavy enemy teams.
• Gargoyle Stoneplate: Crafted from a Negatron Cloak and a Chain Vest, this item grants increasing armor and magic resistance for each enemy targeting the holder. It is exceptionally powerful on solo frontline units, making them incredibly durable when focused.
• Steadfast Heart: Combining Sparring Gloves and a Chain Vest, this item provides universal damage reduction, making the champion more durable against all forms of incoming damage. It is a strong and flexible defensive option.

Handy Utility Items: For Special Situations!

These items offer unique effects that can turn the tide of battle or provide crucial strategic advantages.

• Edge of Night: Made from a B.F. Sword and a Chain Vest, this item allows the champion to briefly become untargetable and shed negative effects upon reaching low health, gaining bonus attack speed afterward. It is valuable for champions who might be targeted by assassins or frontline carries needing an escape.
• Hextech Gunblade: The combination of a B.F. Sword and a Needlessly Large Rod, this item grants omnivamp, healing the champion for a percentage of all damage they deal, whether from attacks or spells. It benefits both spell-reliant units and most damage dealers.
• Ionic Spark: Crafted from a Needlessly Large Rod and a Negatron Cloak, this item reduces the magic resistance of nearby enemies and zaps them with magic damage when they cast abilities. It is a great utility item for frontliners, benefiting all magic damage compositions.
• Thief’s Gloves: Created by combining two Sparring Gloves, this item equips the champion with two random completed items each round. While its outcome is based on chance, it generally provides decent items and can be particularly strong on high-cost champions.
• Tactician’s Crown: The ultimate team-size item, formed by combining two Spatulas, this item allows a player to field one additional champion on their board, providing a significant power boost to the team.

The diverse range of combined items, including highly specialized effects like Guardbreaker (designed to counter shielded units), Giant Slayer (effective against high-health targets), Last Whisper (reduces enemy armor), and Ionic Spark (shreds magic resistance), highlights a critical aspect of Set 13 itemization. This is not merely about accumulating raw statistical power; it is about understanding and leveraging specific interactions. This means that achieving success in TFT Set 13 requires players to select items that directly counter their opponents’ strategies or perfectly complement their own team’s strengths. For instance, if multiple opponents are building compositions reliant on shields, Guardbreaker’s value increases dramatically. This strategic depth encourages players to actively observe their opponents’ boards and adapt their item choices accordingly, transforming itemization into a dynamic layer of strategic decision-making beyond simple power boosts.

4. Smart Shopping: How to Pick the Best Items for Your Team

When equipping champions in TFT, it is important to remember that simply stacking large amounts of the same statistic does not always yield the best results. For example, providing a champion with an excessive amount of attack power without balancing it with attack speed will not make them proportionally stronger. This concept is often referred to as “diminishing returns,” where adding more of the same type of power becomes less impactful beyond a certain point. Optimal itemization involves a balanced approach, combining different types of statistical boosts to create a more potent champion. For instance, a champion equipped with both additional attack power and increased attack speed will generally perform far better than one with only a massive amount of attack power.

Tips for Different Champions:

Understanding the primary role of each champion type is crucial for effective itemization.

1. Attackers (AD Carries): These champions excel at dealing sustained physical damage through their basic attacks. They benefit greatly from items that boost their raw attack damage, such as Infinity Edge or Deathblade. To maximize their output, items that increase attack speed, like Guinsoo’s Rageblade or Red Buff, are also vital. Furthermore, items that amplify the impact of each hit, such as Giant Slayer (for high-health targets) or Last Whisper (to bypass armor), are highly desirable. Spear of Shojin to accelerate her ability casts, which in turn reduces enemy armor and magic resistance, and Last Whisper to ensure her attacks penetrate defenses. In contrast, Jinx, known for her rapid attacks, finds Guinsoo’s Rageblade exceptionally effective for its stacking attack speed.

2. Spellcasters (AP Carries): These champions unleash powerful magical abilities to deal damage or provide utility. Their itemization prioritizes mana generation to enable frequent spell casts, with items like Blue Buff or Spear of Shojin. To enhance the impact of their spells, Rabadon’s Deathcap or Archangel’s Staff provide significant ability power boosts. For spellcasters whose abilities can critically strike, Jeweled Gauntlet is essential to amplify their burst damage. Spear of Shojin and Jeweled Gauntlet to cast her powerful monkey ability quickly and ensure it deals substantial damage.

3. Tanks (Frontliners): These champions are designed to absorb incoming damage, protecting the rest of the team. Their item builds focus on maximizing their survivability. Items that provide substantial health, such as Warmog’s Armor, are fundamental. Defensive items like Bramble Vest (for physical damage reduction and retaliation) and Dragon’s Claw (for magic damage reduction) are crucial for mitigating specific damage types. Sett, for instance, is an excellent tank who becomes incredibly resilient when equipped with. Warmog’s Armor, Bramble Vest, and Dragon’s Claw, allowing him to sustain through prolonged engagements.

Early Game vs. Late Game Items: When to Build What!

Itemization also involves a crucial temporal aspect. In the early stages of a game, players often prioritize “tempo items” that provide immediate power to win fights and preserve health, which can translate into more gold later. Sunfire Cape, with its area-of-effect burn, is an excellent example of an early-game item that can help secure win streaks. As the game progresses, the focus shifts to fully equipping primary carries and tanks. It is highly advantageous to secure three completed items on your main damage dealer and main tank as quickly as possible. If item components are scarce, special “Item Augments” can provide additional components or even completed items, accelerating the itemization process.

The dynamic nature of itemization in TFT Set 13 means players must constantly weigh immediate strength against long-term scaling. This requires adapting item choices not only to the champions on the board but also to the current stage of the game and the player’s economic standing. This creates a complex and rewarding decision-making loop where strategic foresight and adaptability are paramount for success.

5. The Mysterious Frying Pan!

The Frying Pan, while a basic item component, warrants special attention due to its unique strategic implications:

• Crit Counter: Its primary function is to reduce the damage taken from “critical hits” and even reflect a portion of that damage back to the attacker. This makes it an invaluable defensive tool when facing compositions that heavily rely on critical strike damage, offering a direct counterplay option.
• Emblem Creator: Beyond its defensive utility, the Frying Pan is also unique in its ability to combine with other basic items to forge “Emblems” for various traits, such as Bruiser, Sorcerer, or Sentinel. These Emblems are powerful because they grant a champion a new trait, which can be crucial for reaching higher, more potent trait breakpoints within a team composition.

6. Conclusion: Go Forth and Gear Up!

The journey through Teamfight Tactics Set 13’s item system reveals that items are far more than mere statistical boosts; they are the superpowers that define a champion’s role and dictate a team’s strategic direction. Understanding the fundamental properties of each basic component is the first step, as these form the building blocks for all advanced gear. The subsequent mastery of combining these components into powerful items, tailored to the specific needs of attackers, spellcasters, and tanks, is crucial for optimizing team performance.

A key takeaway from Set 13’s itemization philosophy is the importance of balanced stat distribution. Over-investing in a single stat can lead to diminishing returns, whereas a diversified approach, combining various offensive or defensive attributes, unlocks a champion’s full potential. Furthermore, the strategic value of counter-items cannot be overstated, as they provide critical tools to adapt to and overcome opponent strategies. The game also encourages dynamic itemization, where players must weigh the immediate benefits of “tempo items” against the long-term scaling potential of core item builds, adjusting their approach based on the evolving game state and economic conditions.

Ultimately, success in TFT Set 13 hinges on a comprehensive understanding of its item system. This includes not only knowing what each item does but also grasping the deeper implications of item synergies, counter-play, and strategic flexibility. The best way to internalize these concepts is through active engagement and experimentation. Players are encouraged to embrace the dynamic nature of itemization, try different combinations, and observe their effects. Every game presents a new opportunity to refine item strategies, paving the way to becoming a true TFT master.

Introduction: The AGI Dream: Promise vs. Reality

The idea of Artificial General Intelligence (AGI) — machines that can think, learn, and adapt like humans across many different tasks — is incredibly exciting. It promises to change our world in ways we can barely imagine. However, reaching AGI isn’t just a software challenge; it comes with some very real, physical hurdles, especially concerning the massive amounts of computing power and energy it would need. As the saying goes, “Compute & Energy Chips” are hotter than rockets; AGI could gulp terawatt-hours without breakthroughs.” This isn’t just a minor technical issue; it’s a fundamental roadblock that we need to understand and address.

Even today’s advanced AI models consume huge amounts of electricity and generate a lot of heat, pushing our current technology to its limits. AGI, which would be constantly learning and adapting, is expected to need far, far more. This raises big questions about whether we can actually sustain such a future. This article will explore these compute and energy challenges, explain what they mean for AGI, and look at some of the clever solutions scientists are working on.

What is Artificial General Intelligence?

AGI is a theoretical concept about creating AI that has human-like intelligence. This means it could teach itself new things and perform tasks it wasn’t specifically programmed for. Unlike the AI we use today, which is very good at specific jobs (like recognizing faces or translating languages), an AGI system would be able to solve complex problems in many different areas, much like a human. It’s about replicating human thinking abilities, including being able to control itself, understand itself, and learn new skills in new situations.

How AGI Differs from Current AI (Like ChatGPT)

Today’s most impressive AI, including the large language models (LLMs) like ChatGPT, are forms of “narrow AI.” They are excellent at their specific tasks, whether it’s generating text, understanding speech, or identifying objects. But they can’t suddenly switch to a completely new, untrained area on their own.

For example, while ChatGPT can write amazing articles, it still relies on humans to set up the problem, design its core structure, and select the data it learns from. It’s great at “well-structured problems” (where the rules are clear), but it needs human help to simplify “ill-structured problems.” This dependence on human input means that current AI models, despite their power, aren’t truly general. To reach AGI, we need a major shift in how AI systems learn and adapt independently. Simply making current models bigger won’t be enough; it will just make the energy problem worse if the basic approach isn’t efficient for true general intelligence.

The Current AI Energy Footprint: A Glimpse into the Future

How Much Power Do Today’s AI Models Use?

The current generation of large AI models already uses a lot of energy. For instance, training a model like GPT-3 consumed between 324 to 1,287 MWh (megawatt-hours) of electricity. To put that in perspective, that’s roughly the same amount of electricity used by 120 US homes in a whole year. Newer models like GPT-4 and Claude 3 Opus are even larger, likely needing 2 to 4 times more energy to train.

But it’s not just about training. The daily use of these models, called “inference,” is quickly becoming the biggest energy user. A single query to ChatGPT, especially for advanced models like GPT-4o, uses about 0.43 watt-hours (Wh) of energy. This is ten times more than a typical Google search. With millions of queries happening every day, the total energy used for inference is now greater than that used for training. This is a big change. While training is a huge, but one-time, energy cost, inference is a continuous and growing demand that increases as more people use AI. For AGI, which is imagined as being “always-on” and constantly adapting, the total energy cost of its ongoing operation will be far greater than its initial training. This means we need to focus on making AI efficient for continuous use, not just for the initial setup.

The Self-Accelerating Loop: AI Demanding More AI

A worrying trend is that AI is now being used to design more efficient chips. As AGI develops, it could learn to re-train itself, control advanced computers to optimize its own models, and even design better hardware. This creates a cycle: “More AI → More Compute → More Energy → More Emissions.” This means the energy demand isn’t just growing linearly; it could grow exponentially and become self-perpetuating. If AGI can improve its own hardware and algorithms, its energy needs could increase much faster than human innovation can predict or control. This makes it urgent to develop sustainable solutions before AGI reaches a point where it can rapidly improve itself, as the problem could quickly become too big to manage.

AGI’s Insatiable Appetite: Projections and the Scaling Challenge

How Much Compute Would Human-Level AGI Need?

Estimates for the computing power needed for human-level AGI vary a lot. Some researchers think a powerful gaming PC (like an Nvidia GeForce RTX 4090, with about 8.3e13 FLOP/s) might be enough for human-level AGI. This is based on comparing AGI to the human brain’s computational power.

However, the median forecast from 108 AI experts is much higher, at 3e17 FLOP/s (floating point operations per second). This is orders of magnitude more powerful than current consumer hardware.

The human brain is incredibly efficient at learning. To “train” a human to be an engineer takes about 20 times the compute of one year of their work. Compare this to current AI language models, where this factor can be “several hundred million” times higher! This huge difference in efficiency, where the human brain learns and operates with far less training overhead, points to a big “algorithmic efficiency gap” between biological and artificial intelligence. If AGI is truly general and always learning, it can’t afford the current AI paradigm’s training inefficiency. This means we need fundamental breakthroughs in algorithms, perhaps inspired by how the brain works, just as much as we need raw hardware power.

Projected Energy Demands for AGI-Scale Models

If current trends continue and the “scaling hypothesis” proves true, AGI-scale models are expected to be “power devourers.” They will likely need constant computation, real-time adaptation, and much larger models trained with more data and longer cycles. Forecasts suggest AGI-scale models could use 10 to 100 times more energy than current Generative AI.

Data center projections really show the scale of this challenge: In 2023, AI-related data centers used about 4.5 GW (gigawatts) globally. This is expected to jump to 14–18.7 GW by 2028, potentially making up 20% of all data center energy use. All global data centers together used about 415 TWh (terawatt-hours) in 2024 (about 1.5% of global electricity). This is expected to more than double by 2030, possibly reaching 1,000–1,300 TWh. The International Energy Agency (IEA) predicts that data centers’ total electricity use could exceed 1,000 TWh by 2026, which is roughly equal to Japan’s entire annual electricity consumption. In the United States, AI-driven data centers could account for almost half of the growth in electricity demand by 2030. This comparison to a whole country’s energy use shows that this isn’t a small increase, but a huge national-level energy requirement that will put immense strain on power grids worldwide. This means the energy challenge for AGI isn’t just a tech problem; it’s a global infrastructure and geopolitical issue.

Conclusion: Navigating the Energy Crossroads to AGI

While an individual’s daily use of ChatGPT uses very little electricity, the combined effect of widespread AI adoption is huge. The total daily queries for just one advanced model like GPT-4o already use as much electricity annually as tens of thousands of U.S. homes, and this includes all the significant energy used by data center infrastructure. Looking ahead, the growth of AI-driven data centers is projected to double global data center electricity consumption by 2030. This increasing demand poses major challenges for our energy grids.

Have you ever wondered why computers seem to love the number 2 so much? Well, it all starts with something called the binary system, which is the foundation of all computing. In this article, we’ll explore why the number 2 is so important, how it works, and how it’s used in computer science and various applications.

The Magic of the Number 2

What is Binary?

• Binary System: The binary system is like the language of computers. Instead of using ten digits (0–9) like we do in the decimal system, binary only uses two digits: 0 and 1.
• Base of 2: Binary is a base-2 system, which means every number is represented using only the digits 0 and 1.

Why Base 2?

Computers are built using millions of tiny switches called transistors. These switches can be either off (0) or on (1). Using binary makes it simple for computers to store and process information because it matches the physical nature of the hardware.

What are Transistors? Transistors are tiny electronic devices that act as switches in a computer. They can be in one of two states: off (0) or on (1).

How They Work: When electricity flows through a transistor, it turns on (1). When there is no electricity, it turns off (0). These simple on/off states are the foundation of all computer operations.

Storing Data: Each bit of data (binary digit) is represented by a transistor. For example, the binary number 1011 is represented by four transistors in the states: on (1), off (0), on (1), and on (1).

Characters in Binary: To represent characters like “A”, computers use a standard encoding system called ASCII (American Standard Code for Information Interchange). Each ASCII character is represented using 8 bits (1 byte). For example, the character “A” is represented by the binary number 01000001.

Example: Representing “A” in Binary:

• The ASCII value for “A” is 65.
• The binary representation of 65 is 01000001.
• Transistors Needed: Each bit in the binary representation of “A” corresponds to a transistor. Therefore, it takes 8 transistors to represent the character “A”.

Powers of 2 are the foundation of the binary system. Each bit (binary digit) in a computer represents a power of 2.

Computer memory and storage are often organized in sizes that are powers of 2, like 1 KB (kilobyte) being 1024 bytes (2¹⁰).

How Computers Use Powers of 2

Memory and Storage:

• Memory Sizes: Memory sizes in computers are always powers of 2. For example: 1 KB = 1024 bytes (2¹⁰) 1 MB = 1024 KB (2²⁰) 1 GB = 1024 MB (2³⁰)

Data Structures:

• Binary Trees: In a binary tree, each node has up to two children. The height and balance of these trees often involve powers of 2.
• Heaps: A binary heap is a special tree-based data structure that satisfies the heap property and relies on binary principles.

Algorithms:

• Divide and Conquer: Algorithms like mergesort and quicksort use a divide-and-conquer strategy, splitting data into halves, leveraging the power of 2 for efficiency.
• Exponentiation by Squaring: This method efficiently computes large powers by breaking the problem into smaller powers of 2.

Networking:

• IP Addresses: IPv4 addresses are 32-bit numbers, allowing for 2³² unique addresses.
• Subnets: Network subnets are often divided using powers of 2 to create efficient and manageable networks.

Why Understanding Powers of 2 is Awesome

Efficiency: Knowing about powers of 2 helps you understand how computers work efficiently. It’s like having a superpower to see behind the scenes of technology.

Problem-Solving: Many problems in computer science can be simplified by understanding powers of 2. It helps in designing faster algorithms and managing data better.

Hardware Design: Hardware engineers design memory, processors, and storage devices around powers of 2. It’s crucial for creating the gadgets and devices we use every day.

Conclusion

The power of 2 is a cornerstone of computer science, forming the basis of binary systems, memory organization, data structures, and algorithms. By understanding how powers of 2 work and their applications, you can gain a deeper appreciation for the technology we use daily and become better at solving problems and designing efficient systems. Whether you’re counting on your fingers or designing the next big app, the power of 2 is your friend in the world of computing.

Imagine you have a giant pile of LEGO bricks. Finding the right piece in this huge pile can be slow and frustrating. Sharding is like organizing these bricks into smaller piles based on color or type, making it easier and faster to find the pieces you need.

What is Sharding?

At its core, sharding is the process of splitting a large database into smaller, more manageable pieces called shards. Each shard operates as an independent database, holding a subset of the total data. This distributed approach allows you to spread the data load across multiple servers, improving performance and facilitating horizontal scaling.

Why Use Sharding?

1. Scalability: Sharding enables horizontal scaling, allowing you to add more servers to handle increasing loads.
2. Performance: Distributing data across multiple servers reduces the load on each server, leading to faster query response times.
3. Availability: With data spread across multiple servers, the system can remain operational even if one server fails.
4. Cost Efficiency: Scaling out with multiple smaller servers can be more cost-effective than continually upgrading a single large server.

Basic Sharding Strategies

1. Range Sharding: Data is divided into shards based on ranges of a sharding key. Example: Users with IDs 1–1000 go to Shard 1, IDs 1001–2000 to Shard 2. Pros: Simple to implement and understand. Cons: Can lead to uneven distribution if data is not uniformly distributed.
2. Hash Sharding: A hash function is applied to a sharding key, and the. result determines the shard. Example: The hash of a user ID modulo the number of shards determines the shard Pros: Evenly distributes data across shards. Cons: Range queries can be complex and less efficient.
3. Geographic Sharding: Data is divided based on geographic location. Example: Users in North America are stored in Shard 1, users in Europe in Shard 2. Pros: Reduces latency by keeping data close to users. Cons: Managing data that spans multiple regions can be complex.

Advanced Sharding Techniques

1. Consistent Hashing: Distributes data across nodes using a hash function that maps both data and nodes to a ring. Example: Data and nodes are assigned positions on a circular ring using a hash function. Pros: Minimizes data movement when nodes are added or removed; evenly distributes data. Cons: More complex to implement and manage.
2. Directory-Based Sharding: Uses a lookup table to map each data item to a specific shard. Example: A central directory maintains a map of user IDs to shard numbers. Pros: Provides flexibility in shard assignment. Cons: Introduces additional complexity in maintaining the directory.
3. Composite Sharding: Combines multiple sharding strategies to optimize data distribution. Example: Data is first sharded by geographic location and then by hash within each geographic shard. Pros: Can handle complex data distribution needs. Cons: Implementation and maintenance can be challenging.

Implementing Sharding: A Step-by-Step Guide

1. Identify the Shard Key: Choose a key that will determine how data is distributed. A good shard key ensures even distribution and minimizes cross-shard queries.
2. Design the Shard Schema: Plan how data will be partitioned. Decide on the number of shards and how they will grow over time.
3. Set Up Infrastructure: Deploy the necessary hardware or cloud instances to host the shards. Ensure network configuration supports efficient communication between shards.
4. Implement Sharding Logic: Modify your application to include sharding logic. This might involve adding middleware or using database features that support sharding.
5. Monitor and Adjust: Continuously monitor the performance of your shards. Adjust the distribution or add more shards as needed to handle increased load.

Real-World Examples

1. Facebook: Uses a sharded MySQL architecture to manage billions of users’ data, ensuring scalability and performance.
2. Twitter: Employs sharding to handle massive amounts of tweets, user data, and interactions efficiently.
3. Amazon: Utilizes sharding to scale its e-commerce platform, ensuring fast and reliable service for millions of customers worldwide.
4. Ethereum Sharding: Sharding in Ethereum is designed to improve scalability by splitting the blockchain into multiple shards, each capable of processing its fown transactions and smart contracts.

Conclusion

Sharding is a powerful tool for managing large-scale databases, providing scalability, improved performance, and increased availability. By understanding both basic and advanced sharding techniques, you can design a system that meets your application’s needs and efficiently handles growing data volumes. Implementing sharding requires careful planning and consideration, but the benefits make it a worthwhile investment for any large-scale application.

What is a Message Queue?

A message queue is a mechanism for asynchronous communication between services, commonly used in serverless and microservices architectures. It enables different components of a system to communicate and perform tasks independently by decoupling the sending and receiving processes. Essentially, a message queue serves as a buffer that temporarily holds messages (such as tasks, data, or events) until they are retrieved and processed by the receiving service. This approach enhances system reliability, scalability, and maintainability by allowing services to function and scale independently.

Key Concepts:

Producer and Consumer: Producer is the entity that sends messages to the queue. Consumer is the entity that retrieves and processes messages from the queue.

Message: A discrete unit of data passed between the producer and the consumer via the queue. Messages can contain various types of information, such as job instructions, event notifications, or data payloads.

{
  "orderId": "12345",
  "customerId": "67890",
  "items": [
    {"itemId": "abc", "quantity": 2},
    {"itemId": "def", "quantity": 1}
  ],
  "orderTimestamp": "2023-05-25T15:30:00Z"
}

Queue: A data structure that holds messages until they are processed. The queue ensures that messages are delivered in a reliable and ordered manner.

Why Use Message Queues?

1. Decoupling: Message queues enable different components of a system to function independently by acting as intermediaries between producers and consumers. This allows producers to send messages at their own pace and consumers to process those messages at a different rate, without causing disruptions. As a result, message queues enhance system modularity and flexibility, allowing each part of the system to scale and evolve independently.
2. Scalability: By decoupling services, message queues enable systems to scale more effectively. Additional consumers can be added to process the queued messages, allowing the system to handle increased loads.
3. Reliability: Message queues provide reliability through features like message persistence and delivery guarantees. Even if a consumer fails, the messages remain in the queue until they are successfully processed.
4. Load Balancing: Queues can distribute work among multiple consumers, ensuring that no single consumer is overwhelmed, which enhances system performance and resource utilization.

Popular Message Queue Implementations:

1. RabbitMQ: A widely-used open-source message broker that implements the Advanced Message Queuing Protocol (AMQP). It supports various messaging patterns and provides robust features like message acknowledgments and persistent storage. Use Case: Reddit uses RabbitMQ to manage its message queue for handling a variety of tasks. This includes background job processing, real-time message delivery, and coordination between microservices. Reason for Choice: RabbitMQ’s support for multiple messaging patterns, robust features like message acknowledgments, persistent storage, and its reliability in delivering messages make it suitable for handling Reddit’s diverse and high-volume message traffic.
2. Apache Kafka: A distributed streaming platform often used for building real-time data pipelines and streaming applications. Kafka is known for its high throughput and fault tolerance. Use Case: Netflix uses Apache Kafka for real-time data streaming to monitor the state of its distributed systems. Kafka helps in collecting and processing event data from various microservices. Reason for Choice: Kafka’s distributed nature, scalability, and fault tolerance are essential for Netflix’s large-scale, real-time data processing requirements.
3. Amazon SQS (Simple Queue Service): A fully managed message queuing service by AWS. It offers scalability, durability, and ease of use, making it a popular choice for cloud-based applications. Use Case: Airbnb uses Amazon SQS to decouple components of its application. SQS helps in managing background jobs, handling asynchronous processing, and ensuring reliable communication between microservices. Reason for Choice: SQS’s fully managed nature, ease of use, scalability, and integration with other AWS services make it ideal for Airbnb’s cloud-based architecture.
4. ActiveMQ: An open-source message broker that supports multiple messaging protocols. It is often used in enterprise environments and provides features like clustering and message routing. Use Case: JPMorgan Chase uses ActiveMQ for processing financial transactions and ensuring reliable communication between different parts of their financial systems. Reason for Choice: ActiveMQ’s reliability, support for JMS (Java Message Service), and its ability to handle the demands of a financial institution with high transaction volumes and stringent reliability requirements.

Common Message Queue Patterns:

Point-to-Point: In this pattern, each message is delivered to a single consumer. It is typically used for tasks like job processing, where each task should be handled by one worker.

Scenario: A web application generates tasks that need to be processed, such as resizing images. Each task is sent as a message to a RabbitMQ queue. A pool of workers listens to the queue and processes tasks one by one. Each task is consumed by a single worker, ensuring that tasks are not processed multiple times.

Technology: RabbitMQ

Message Flow: Producer: The web application sends a task to the RabbitMQ queue → Queue: The message is stored in the queue → Consumer: A worker retrieves and processes the task from the queue.

Publish-Subscribe: This pattern allows messages to be broadcast to multiple consumers. It is useful for event-driven architectures where multiple services need to react to the same event.

Scenario: In a financial trading platform, real-time stock price updates need to be broadcast to multiple services, such as a trading dashboard, a risk management system, and a notification service for traders. Using the publish-subscribe pattern with Amazon SNS, a stock price update can be published to an SNS topic, and multiple subscribers can receive the update simultaneously.

Technology: Amazon SNS (Simple Notification Service) and Amazon SQS (Simple Queue Service)

Message Flow: Publisher: Stock price data feed publishes the update to an SNS topic → SNS Topic: Broadcasts the update to all subscribed endpoints, including SQS queues. → Subscribers: Trading Dashboard: Receives real-time updates directly from SNS. Risk Management Queue (SQS): Receives updates for risk recalibration. Notification Service Queue (SQS): Receives updates for sending alerts. Analytics Queue (SQS): Receives updates for data analysis and storage.

Request-Reply: A pattern where a service sends a request message and waits for a reply message. This is often used in RPC (Remote Procedure Call) systems.

Scenario: Order Status Inquiry Service

Technology: RabbitMQ

Message Flow: Client: A user requests the status of their order through a web application. The request is sent to a RabbitMQ request queue → Server: The server listens for requests on the RabbitMQ request queue. When a request is received, the server processes the request by checking the order status in the database and then sends a reply message to a dedicated reply queue. → Client: The client listens for the reply message on the reply queue and processes the response to display the order status to the user.

Best Practices for Using Message Queues:

1. Idempotency: Ensure that message processing is idempotent, meaning that processing the same message multiple times has the same effect as processing it once. This prevents issues from message duplication.
2. Monitoring and Alerting: Implement robust monitoring and alerting for your message queue system. Track metrics like queue length, processing time, and error rates to identify and address issues promptly.
3. Dead Letter Queues (DLQ): Use DLQs to handle messages that cannot be processed successfully after multiple attempts. This helps in isolating problematic messages and ensures they do not block the queue.
4. Backpressure Management: Implement strategies to handle backpressure, such as rate limiting or shedding load, to prevent system overload when the message production rate exceeds consumption capacity.

Conclusion:

Message queues are a crucial component in modern system design, facilitating asynchronous communication, scalability, and reliability. By grasping their concepts, patterns, and best practices, you can effectively utilize message queues to build robust and scalable systems.

Hashing is a fundamental concept in computer science and software engineering. It involves transforming input data of any size into a fixed-size value, usually a string of numbers and letters. This value is called a hash code, hash value, or simply hash.

What is Hashing?

Hashing is a technique used to uniquely identify data by transforming it into a fixed-size hash value or hash code. This transformation is performed by a hash function, which maps input data of varying lengths into a consistent, fixed-length output. The main purpose of hashing is to allow for quick data retrieval and comparison, making it an essential tool in data structures like hash tables, as well as in ensuring data integrity and security in various applications.

Key Properties of Hash Functions

1. Deterministic: The same input will always produce the same hash code.
2. Fixed Output Size: Regardless of the input size, the output hash code has a fixed length.
3. Efficient: Hash functions are designed to be fast to compute.
4. Pre-image Resistance: Given a hash code, it should be infeasible to compute the original input.
5. Collision Resistance: It should be difficult to find two different inputs that produce the same hash code.
6. Avalanche Effect: A small change in the input should produce a significantly different hash code.

Common Hash Functions

• MD5: Produces a 128-bit hash value. It’s fast but not suitable for cryptographic purposes due to vulnerabilities. (Hash Size: 128 bits (16 bytes, Maximum Number of Unique Hash Values: 2¹²⁸)
• SHA-1: Produces a 160-bit hash value. It’s more secure than MD5 but still has known weaknesses. (Hash Size: 160 bits (20 bytes), Maximum Number of Unique Hash Values: 2¹⁶⁰)
• SHA-256: Part of the SHA-2 family, produces a 256-bit hash value and is widely used for security purposes.

# Output:
# Input: Hello, World!
# MD5: b10a8db164e0754105b7a99be72e3fe5
# SHA-1: 2ef7bde608ce5404e97d5f042f95f89f1c232871
# SHA-256: a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b56ee1feb2ef8d7e6

Why Different Hashing Functions?

Evolution of Security Requirements: As computational power increases, the feasibility of attacks on hash functions improves. Algorithms like MD5 and SHA-1, which were once considered secure, have become vulnerable to attacks. More secure algorithms like SHA-256 were developed to address these vulnerabilities.

Performance Trade-offs: Faster algorithms like MD5 are useful in scenarios where performance is critical, and security is less of a concern. In contrast, SHA-256, while slower, provides a higher level of security, making it suitable for cryptographic applications.

Specific Use Cases: Different applications have different requirements. For example, MD5 is still used for non-cryptographic checksums due to its speed, while SHA-256 is used in security-sensitive contexts.

Legacy Systems: Older systems and protocols were built using MD5 or SHA-1 before their vulnerabilities were discovered. Transitioning to more secure algorithms takes time, and some legacy systems still use these older functions.

Example: Implementing a Hash Table

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in range(size)]

    def hash_function(self, key):
        return hash(key) % self.size

    def insert(self, key, value):
        index = self.hash_function(key)
        for item in self.table[index]:
            if item[0] == key:
                item[1] = value
                return
        self.table[index].append([key, value])

    def search(self, key):
        index = self.hash_function(key)
        for item in self.table[index]:
            if item[0] == key:
                return item[1]
        return None

# Example usage
hash_table = HashTable(10)
hash_table.insert("name", "Alice")
hash_table.insert("age", 30)
print(hash_table.search("name"))  # Output: Alice
print(hash_table.search("age"))   # Output: 30

Real-Life Examples of Hashing

Password Storage: When you create an account on a website, your password is not stored as plain text. Instead, it’s passed through a hash function, and the resulting hash value is stored. When you log in, the system hashes the entered password and compares it to the stored hash. If they match, you’re granted access. Why It’s Important: This ensures that even if the database is compromised, attackers cannot easily retrieve the actual passwords.

Version Control Systems: In systems like Git, every commit (a set of changes) is identified by a hash. This hash represents the state of the repository at that point in time and is used to track changes, revert to previous versions, and manage branches.Why It’s Important: This allows developers to collaborate effectively, maintain a history of changes, and ensure the integrity of the codebase.

Hash Tables and Databases: Hash tables are used in databases to index data. For example, when you search for a record in a database, the hash of the search key is used to quickly locate the record in the hash table, providing fast access. Why It’s Important: This allows for efficient data retrieval, which is critical for performance in large databases.

Blockchain and Cryptocurrencies: In blockchain technology (like Bitcoin), each block contains a hash of the previous block, forming a chain. Transactions within a block are hashed, and the resulting hash is used to ensure the integrity and immutability of the blockchain. Why It’s Important: This ensures security, prevents tampering, and maintains a trustworthy ledger of transactions.

Conclusion

Hashing is a powerful tool for efficient data retrieval, integrity verification, and security. Understanding the principles of hash functions and their applications is crucial for designing and implementing scalable and robust systems. Whether you’re building a simple hash table or securing passwords, hashing provides a reliable way to manage and protect data.

Imagine you have an office filled with documents, and every time you work on a document, you leave it scattered on your desk. Eventually, the desk becomes so cluttered that you can’t find the documents you need, and there’s no space left to work efficiently.

Introduction: Java garbage collection is an automatic process in the Java Virtual Machine (JVM) that frees up memory by removing objects no longer in use. This essential feature helps prevent memory leaks and reduces the need for manual memory management.

How Does the Garbage Collector Know What to Clean Up?

If you’re still working(referenced) on a document or it’s stored in your filing cabinet (variables and references in your program), the Garbage Collector leaves it alone.

Not in Use (Unreferenced) Documents: If you’ve left a document on your desk and forgotten about it (no variables or references pointing to it), the Garbage Collector picks it up and puts it away.

Types of Garbage Collectors in Java

1. Serial Garbage Collector: The Serial GC is the simplest form of garbage collector in Java. It uses a single thread to perform all garbage collection work.

You go through each document one by one, deciding whether it’s still needed or not. Once you’ve sorted everything, you discard the unnecessary documents and neatly organize the ones you still need. This way, you create a tidy workspace and can work efficiently again.

How It Works: During garbage collection, the application is paused, and the single GC thread cleans up the memory. This is known as a “stop-the-world” event.

Use Case: Suitable for small applications with single-threaded environments where pause times are not critical.

You take a break from work to clean up the entire desk by yourself.

Here’s a Python example demonstrating this concept using a single-threaded garbage collection approach:

import gc

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f'Object {self.name} created')

    def __del__(self):
        print(f'Object {self.name} destroyed')

def create_objects():
    obj1 = MyClass('obj1')
    obj2 = MyClass('obj2')
    # Create a cyclic reference
    obj1.ref = obj2
    obj2.ref = obj1
    return obj1, obj2

def perform_serial_gc():
    # Disable automatic garbage collection
    gc.disable()
    
    # Manually invoke garbage collection
    print('Starting garbage collection...')
    gc.collect()
    print('Garbage collection complete')

# Create objects and form cyclic references
obj1, obj2 = create_objects()

# Manually perform garbage collection
perform_serial_gc()

# Remove references to objects
del obj1
del obj2

# Perform garbage collection again to clean up
perform_serial_gc()

2. Parallel Garbage Collector: The Parallel GC, also known as the “Throughput Collector,” uses multiple threads to speed up the garbage collection process.

You and several of your colleagues decide to clean up the desk together. Each of you takes a portion of the documents, sorting through them simultaneously. Some colleagues focus on sorting, while others handle discarding unnecessary documents and organizing the ones still needed. By working in parallel, you manage to clean up the desk much faster, creating a tidy workspace where everyone can work efficiently again.

How It Works: It uses multiple threads to collect garbage in the Young Generation, making it efficient for applications running on multi-core processors.

Use Case: Ideal for applications that can tolerate longer pause times but require high throughput, such as batch processing systems.

You and several colleagues stop working and clean up the desk together, each handling different sections simultaneously.

Here’s a Python example demonstrating this concept using a parallel garbage collection approach:

import gc
import threading

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f'Object {self.name} created')

    def __del__(self):
        print(f'Object {self.name} destroyed')

def create_objects():
    obj1 = MyClass('obj1')
    obj2 = MyClass('obj2')
    # Create a cyclic reference
    obj1.ref = obj2
    obj2.ref = obj1
    return obj1, obj2

def perform_gc():
    print('Starting garbage collection...')
    gc.collect()
    print('Garbage collection complete')

def parallel_gc(num_threads):
    threads = []
    for _ in range(num_threads):
        thread = threading.Thread(target=perform_gc)
        threads.append(thread)
        thread.start()
    
    for thread in threads:
        thread.join()

# Create objects and form cyclic references
obj1, obj2 = create_objects()

# Perform parallel garbage collection using multiple threads
parallel_gc(num_threads=4)

# Remove references to objects
del obj1
del obj2

# Perform parallel garbage collection again to clean up
parallel_gc(num_threads=4)

3. Concurrent Mark-Sweep (CMS) Collector: The CMS collector aims to minimize pause times by performing most of its work concurrently with the application.

You and your colleagues decide to clean up the desk while continuing to work. One group of colleagues starts by marking all the documents you still need as they notice them, while another group continues working as usual. During a brief break, the first group sweeps through the desk, quickly discarding the documents that were not marked as needed. By marking documents in the background and only briefly pausing to discard the unnecessary ones, you manage to keep the workspace tidy without significantly interrupting your work. This way, the desk stays organized, and you can work efficiently with minimal disruption.

How It Works: It has four phases: initial mark, concurrent mark, remark, and concurrent sweep. Only the initial mark and remark phases cause pauses.

Use Case: Suitable for applications requiring low latency and can afford some CPU overhead for concurrent GC activities.

One group of colleagues marks needed documents while others continue working. During a brief break, the marked documents are sorted and the unnecessary ones are discarded.

Here’s a Python example demonstrating this concept using a Concurrent Mark-Sweep collection approach:

import gc
import threading
import time

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f'Object {self.name} created')

    def __del__(self):
        print(f'Object {self.name} destroyed')

def create_objects(num_objects):
    objects = []
    for i in range(num_objects):
        obj = MyClass(f'obj{i}')
        objects.append(obj)
    return objects

def mark_phase():
    print('Starting mark phase...')
    gc.collect()
    print('Mark phase complete')

def sweep_phase():
    print('Starting sweep phase...')
    gc.collect()
    print('Sweep phase complete')

def concurrent_mark_sweep_gc():
    # Concurrent Mark Phase
    mark_thread = threading.Thread(target=mark_phase)
    mark_thread.start()
    mark_thread.join()

    # Concurrent Sweep Phase
    sweep_thread = threading.Thread(target=sweep_phase)
    sweep_thread.start()
    sweep_thread.join()

# Create objects
objects = create_objects(num_objects=10)
time.sleep(0.5)  # Simulate time delay for object usage

# Perform CMS garbage collection
concurrent_mark_sweep_gc()

# Remove references to objects
for obj in objects:
    del obj

# Perform CMS garbage collection again to clean up
concurrent_mark_sweep_gc()

4. Garbage-First (G1) Collector: The G1 collector is designed for applications with large heaps and aims to provide predictable pause times.

You and your colleagues decide to tackle the most cluttered areas of the desk first, where the mess is the worst. Each of you targets these high-priority sections, quickly sorting through the documents to identify which ones are still needed and which ones can be discarded. Once the most cluttered areas are clean, you gradually move on to the less messy sections. By focusing on the worst messes first, you efficiently clean up the entire desk, ensuring that the workspace remains organized and easy to work in.

How It Works: G1 divides the heap into regions and collects garbage in regions that contain the most reclaimable space first. It uses a mix of concurrent and parallel phases.

Use Case: Ideal for large-scale applications needing predictable pause times and efficient memory management.

You and your colleagues focus on the messiest parts of the desk first, working together to clean those up, and then gradually move on to less messy sections. The work stops briefly during the cleanup but is optimized to minimize disruption.

Here’s a Python example demonstrating this concept using a Garbage-First collection approach:

import gc
import threading
import random
import time

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f'Object {self.name} created')

    def __del__(self):
        print(f'Object {self.name} destroyed')

def create_objects(num_objects):
    objects = []
    for i in range(num_objects):
        obj = MyClass(f'obj{i}')
        objects.append(obj)
    # Randomly create cyclic references
    for obj in objects:
        obj.ref = random.choice(objects)
    return objects

def perform_gc(region):
    print(f'Starting garbage collection in region {region}...')
    gc.collect()
    print(f'Garbage collection complete in region {region}')

def g1_gc(num_regions):
    threads = []
    for region in range(num_regions):
        thread = threading.Thread(target=perform_gc, args=(region,))
        threads.append(thread)
        thread.start()
    
    for thread in threads:
        thread.join()

# Create objects in different regions
num_regions = 4
all_objects = []
for _ in range(num_regions):
    all_objects.extend(create_objects(num_objects=10))
    time.sleep(0.5)  # Simulate time delay between object creation

# Perform G1 garbage collection
g1_gc(num_regions=num_regions)

# Remove references to objects
for obj in all_objects:
    del obj

# Perform G1 garbage collection again to clean up
g1_gc(num_regions=num_regions)

1-Star Skill Moves

• First-Time Feint Turn: Hold L1 + R1 + flick LS down / Hold LB + RB + flick LS down
• Bridge Skill: Double tap R1 / Double tap RB
• Directional Nutmeg: Hold L1 + R1 + RS in any direction / Hold LB + RB + RS in any direction
• Ball Juggle (while standing): L2 + tap R1 / LT + tap RB
• Open Up Fake Shot Left: Hold L1 + Square or Circle then tap X + LS top left diagonally / Hold LB + X or B then tap A + LS top left diagonally
• Open Up Fake Shot Right: Hold L1 + Square or Circle then tap X + LS top right diagonally / Hold LB + X or B then tap A + LS top right diagonally
• Flick Up for volley: Hold R1 + click RS / Hold RB + click RS

2-Star Skill Moves

• Feint Forward and Turn: Flick RS down twice / Flick RS down twice
• Body Feint right/left: Flick RS right/left / Flick RS right/left
• Stepover right/left: Roll RS from the top of the stick to the right/left / Roll RS from the top of the stick to the right/left
• Reverse Stepover right/left: Roll RS from the right/left to the top of the stick / Roll RS from the right/left to the top of the stick
• Ball Roll right/left: Hold RS right/left / Hold RS right/left

3-Star Skill Moves

• Stutter Feint: Hold L2 + flick RS left then right (or right then left) / Hold LT + flick RS left then right (or right then left)
• Heel Flick: Flick RS up and then down / Flick RS up and then down
• Roulette right: Roll RS from the bottom and clockwise to the right / Roll RS from the bottom and clockwise to the right
• Roulette left: Roll RS from the bottom and anti-clockwise to the left / Roll RS from the bottom and anti-clockwise to the left
• Fake left and go right: Roll RS from the left anti-clockwise to the right / Roll RS from the left anti-clockwise to the right
• Fake right and go left: Roll RS from the right clockwise to the left / Roll RS from the right clockwise to the left
• Heel Chop right/left (while running): Hold L2 + Square or Circle then X + hold LS right/left / Hold LT + X or B then A + hold LS right/left
• Heel to ball roll: Hold L1 + flick RS up then down / Hold LB + flick RS up then down
• Ball Hop (while standing): Hold L1 + click RS / Hold LB + click RS
• Heel to Heel Flick: Flick RS up and then down / Flick RS up and then down
• Simple rainbow: Flick RS down, then up twice / Flick RS down, then up twice
• Spin right: Hold R1 + roll RS from bottom clockwise to right / Hold RB + roll RS from bottom clockwise to right
• Spin left: Hold R1 + roll RS from the bottom anti-clockwise to the left / Hold RB + roll RS from the bottom anti-clockwise to the left
• Stop and Turn right/left (while running): Flick RS up then right/left / Flick RS up then right/left
• Ball roll cut right: Hold RS left then hold LS right / Hold RS left then hold LS right
• Ball roll cut left: Hold RS right then hold LS left / Hold RS right then hold LS left
• Fake pass (while standing): Hold R2 + Square or Circle then X / Hold RT + X or B then A
• Fake pass exit right/left (while standing): Hold R2 + Square or Circle then X + flick LS top right/left diagonally / Hold RT + X or B then A + flick LS top right/left diagonally
• Quick ball rolls: Hold RS down / Hold RS down
• Drag to Heel: Hold L1 + flick RS down, then right or left / Hold LB + flick RS down, then right or left
• Lane Change right/left: Hold L1 + hold RS right/left / Hold LB + hold RS right/left
• Three-touch roulette right/left: Hold L2 + flick RS down then right/left / Hold LT + flick RS down then right/left
• Drag backspin right/left: Flick RS down then right/left / Flick RS down then right/left

5-Star Skill Moves

• Elastico: Roll RS from right clockwise to left / Roll RS from right clockwise to left
• Reverse Elastico: Roll RS from left anti-clockwise to right / Roll RS from left anti-clockwise to right
• Advanced Rainbow: Flick RS down, hold up, then flick up / Flick RS down, hold up, then flick up
• Hocus Pocus: Roll RS from bottom clockwise to left, then roll anti-clockwise to right / Roll RS from bottom clockwise to left, then roll anti-clockwise to right
• Triple Elastico: Roll RS from bottom anti-clockwise to right, then roll clockwise to left / Roll RS from bottom anti-clockwise to right, then roll clockwise to left
• Ball Roll and Flick Left (while running): Hold RS left then flick up / Hold RS left then flick up
• Ball Roll and Flick Right (while running): Hold RS right then flick up / Hold RS right then flick up
• Heel Flick Turn: Hold L2 + R1 + flick RS up then down / Hold LT + RB + flick RS up then down
• Sombrero Flick (while standing): Flick RS up, up, down / Flick RS up, up, down
• Turn and Spin Left: Flick RS up then left / Flick RS up then left
• Turn and Spin Right: Flick RS up then right / Flick RS up then right
• Ball Roll Fake Left (while standing): Hold RS left then flick RS right / Hold RS left then flick RS right
• Ball Roll Fake Right (while standing): Hold RS right then flick RS left / Hold RS right then flick RS left
• Ball Roll Fake Turn: Hold L2 + flick RS up then flick RS either left or right / Hold LT + flick RS up then flick RS either left or right
• Rabona Fake (while jogging): Hold L2 + Square or Circle then X + LS down / Hold LT + X or B then A + LS down
• Elastico Chop Left: Hold L2 + hold R1 then roll RS from right clockwise to left / Hold LT + hold RB then roll RS from right clockwise to left
• Elastico Chop Right: Hold L2 + hold R1 then roll RS from left anti-clockwise to right / Hold LT + hold RB then roll RS from left anti-clockwise to right