databasesindexingperformancequery optimizationsoftware engineering

Database Indexing Strategy: From Basics to Compound and Covering Indexes

Explore the evolution of database indexing from simple to advanced strategies. Learn how to optimize queries with compound and covering indexes.

23 min readUpdated By the AiCanCode.org team · How we write
Share on LinkedIn
Database Indexing Strategy: From Basics to Compound and Covering Indexes
In this guide · 11 sections

Database Indexing Strategy: From Basics to Compound and Covering Indexes

The Midnight Crisis: A Slow Query Nightmare

It was a typical night for Alex, a seasoned database engineer, until the clock struck midnight. Suddenly, the phone rang, jolting Alex from a deep sleep. On the other end was a frantic voice from the operations team: "The application is crawling, and users are flooding us with complaints!" Alex's heart raced as they logged into the system, only to find a single query consuming an inordinate amount of time and resources. This wasn't just a minor hiccup; it was a full-blown crisis.

The Impact of a Slow Query

The application in question was a critical component of a popular e-commerce platform. Users were trying to browse products, add items to their carts, and make purchases, but the sluggish performance was causing frustration and abandonment. Sales were plummeting, and the company's reputation was at stake. The slow query was acting like a bottleneck, affecting not just the database but the entire user experience. Every second counted, and Alex knew that a swift resolution was imperative.

Setting the Stage for Indexing

As Alex delved deeper into the issue, it became clear that the query was scanning the entire table to retrieve the necessary data. This was a classic case of a full table scan, a performance killer in any database system. The realization hit Alex like a bolt of lightning: the solution lay in optimizing the query through indexing. But where to start? The database was vast, with numerous tables and columns, each with its own unique characteristics.

Alex's mind raced through the possibilities. Could a simple index solve the problem, or was a more complex strategy required? The clock was ticking, and the pressure was mounting. It was time to embark on a journey into the world of database indexing, a journey that would not only resolve the immediate crisis but also enhance the application's performance for the future.

Before Indexes: The Era of Full Table Scans

As Alex sat at their desk, pondering the sluggish performance of the application, they couldn't help but think back to the early days of databases. Before the advent of indexing, databases operated in a much simpler, albeit less efficient, manner. Every query, regardless of its complexity, required a full table scan. This meant that the database had to examine every single row in a table to find the relevant data, a process that was both time-consuming and resource-intensive.

The Challenge of Full Table Scans

Imagine a library where every time you needed a book, you had to check each one on the shelf until you found the right one. This was the reality of full table scans. For small datasets, this approach was manageable, but as data volumes grew, the inefficiencies became glaringly apparent. Queries that should have taken milliseconds were dragging on for seconds, or even minutes, as the database sifted through potentially millions of rows.

For Alex, this historical context was a reminder of the importance of efficient data retrieval. The application's slow query was a modern echo of those early database struggles, highlighting the necessity for a more sophisticated approach.

The Birth of Indexing

The solution to the full table scan problem came in the form of indexing. Just as a library uses a catalog to quickly locate books, databases began to use indexes to expedite data retrieval. An index is essentially a data structure that allows the database to find rows more quickly, without having to scan the entire table.

The introduction of indexing marked a significant turning point in database technology. Early database systems, such as IBM's System R in the 1970s, were among the first to implement indexing. These systems used B-trees, a type of balanced tree data structure, to organize and store index data. This innovation allowed databases to perform lookups, insertions, deletions, and updates more efficiently.

Indexing as a Solution

For Alex, understanding the evolution of indexing was crucial in tackling the current performance issue. By implementing the right indexing strategy, they could transform the application's sluggish queries into swift operations. Indexing not only reduced the amount of data scanned during queries but also optimized the overall performance of the database.

As Alex prepared to dive deeper into the world of indexing, they knew that mastering this technique would be key to resolving the midnight crisis and ensuring the application's smooth operation.

What is a Database Index?

As Alex sat at their desk, pondering the sluggish performance of the application, they realized that understanding the core concept of a database index was crucial. A database index is akin to an index in a book. Just as a book index allows readers to quickly locate information without flipping through every page, a database index enables the database to find data without scanning every row in a table.

The Concept of an Index

In simple terms, a database index is a data structure that improves the speed of data retrieval operations on a database table. It acts as a roadmap, guiding the database engine to the exact location of the desired data. Without an index, the database would have to perform a full table scan, examining each row to find the relevant data, which can be time-consuming, especially with large datasets.

Structure of a Basic Index: B-trees

One of the most common structures used for database indexes is the B-tree. A B-tree is a self-balancing tree data structure that maintains sorted data and allows searches, sequential access, insertions, and deletions in logarithmic time. Here's a simplified representation of how a B-tree index might look:

In this diagram, the root node acts as the entry point, and each node contains keys that guide the search process. The leaves contain pointers to the actual data rows in the table. This structure allows the database to quickly traverse the tree and locate the desired data with minimal effort.

Role of Indexes in Query Optimization

Indexes play a pivotal role in query optimization. When a query is executed, the database engine evaluates whether an index can be used to speed up the retrieval process. If an appropriate index exists, the engine can bypass the full table scan and directly access the relevant data, significantly reducing the query execution time.

For example, consider a table with a million rows where you need to find all entries with a specific value in a column. Without an index, the database would need to check each row individually. However, with an index on that column, the database can quickly locate the relevant entries, often in a fraction of the time.

As Alex delved deeper into the mechanics of indexes, they realized that the right indexing strategy could transform the application's performance. By understanding the basic components and functions of a database index, Alex was now equipped to tackle the slow query issue head-on, setting the stage for more advanced indexing techniques.

How Indexes Work: The Mechanics Behind the Magic

As Alex sat at their desk, staring at the sluggish query results, they knew it was time to delve deeper into the mechanics of indexing. Understanding how indexes work would be the key to unlocking the performance improvements they desperately needed.

Reducing Data Scans with Indexes

At the heart of indexing is the ability to reduce the amount of data scanned during queries. Without indexes, a database must perform a full table scan, examining each row to find the relevant data. This is akin to searching for a specific book in a library by checking every single title on every shelf. Indexes, however, act like a well-organized catalog, allowing the database to quickly locate the desired information without scanning the entire table.

When a query is executed, the database engine uses the index to quickly narrow down the search space. Instead of scanning all rows, it can jump directly to the relevant data, significantly reducing the time and resources required. This is particularly beneficial for large tables where full scans would be prohibitively slow.

The Process of Index Creation and Maintenance

Creating an index is a straightforward process, but it involves several important steps. When Alex decided to create an index, they initiated the process by specifying the columns to be indexed. The database engine then constructs a data structure, often a B-tree, to store the index. This structure allows for efficient searching, insertion, and deletion operations.

Once created, indexes require maintenance. As data in the table changes—through inserts, updates, or deletes—the index must be updated to reflect these changes. This maintenance ensures that the index remains accurate and continues to provide performance benefits. However, it also introduces some overhead, as the database must manage both the table data and the index data.

The Importance of Index Selectivity

As Alex explored further, they encountered the concept of index selectivity, a crucial factor in the effectiveness of an index. Selectivity refers to the uniqueness of the indexed values. An index with high selectivity means that the indexed column contains many unique values, allowing the database to quickly narrow down the search results.

For example, an index on a column containing unique user IDs would have high selectivity, as each value is distinct. In contrast, an index on a column with only a few distinct values, such as a boolean flag, would have low selectivity. High selectivity indexes are more efficient because they reduce the number of rows the database must examine.

Visualizing the Indexing Process

To better understand how indexes work, Alex sketched out a diagram illustrating the process:

In this diagram, when a query is executed, the database first checks if an appropriate index exists. If it does, the index is used to retrieve the data efficiently. If not, a full table scan is performed, which is less efficient. The results are then returned to the user.

By understanding these mechanics, Alex was able to appreciate the power of indexes in optimizing query performance. With this knowledge, they were ready to tackle the next step in their journey: creating their first index and witnessing the transformation firsthand.

Creating Your First Index: A Step-by-Step Guide

As Alex sat at their desk, the clock ticking past midnight, they knew it was time to tackle the sluggish query that had been plaguing their application. The solution lay in creating a database index, a task that would transform the way their queries interacted with the data. Let's walk through the process Alex followed to create their first index and optimize query performance.

Understanding the Basics

Before diving into the SQL commands, it's essential to understand what an index does. An index in a database is akin to an index in a book. It allows the database to quickly locate and access the data without scanning every row in a table. This efficiency is achieved by creating a data structure, typically a B-tree, that organizes the data in a way that makes searching faster.

Step-by-Step Index Creation

  1. Identify the Query to Optimize: Alex started by identifying the query that was causing performance issues. The query was searching for users by their email addresses, a common operation that was taking too long due to the lack of an index.

  2. Choose the Right Column: The next step was to determine which column to index. In this case, the email column in the users table was the target, as it was frequently used in search conditions.

  3. Write the SQL Command: With the column identified, Alex wrote the SQL command to create the index. Here's how it looked:

sql CREATE INDEX idx_users_email ON users(email);

  • CREATE INDEX: This command initiates the creation of a new index.
  • idx_users_email: This is the name of the index. It's a good practice to use a naming convention that reflects the table and column names.
  • ON users(email): This specifies the table and column on which the index is being created.

  • Execute the Command: Alex executed the command in their database management tool. The database system then created the index, organizing the email column data into a B-tree structure.

Options for Index Creation

While the basic command is straightforward, SQL provides several options to customize index creation:

  • Unique Index: Ensures that all values in the indexed column are unique. Useful for columns like email addresses.

sql CREATE UNIQUE INDEX idx_users_email_unique ON users(email);

  • Partial Index: Creates an index on a subset of rows, which can be useful for large tables where only a portion of the data is queried frequently.

sql CREATE INDEX idx_active_users_email ON users(email) WHERE active = true;

Verifying the Impact

After creating the index, Alex needed to verify its impact on query performance. Here's how they did it:

  1. Analyze Query Performance: Before and after creating the index, Alex used the EXPLAIN command to analyze the query execution plan.

sql EXPLAIN SELECT * FROM users WHERE email = 'alex@example.com';

The output showed a significant reduction in the number of rows scanned, confirming the index's effectiveness.

  1. Monitor Query Execution Time: By measuring the query execution time before and after indexing, Alex observed a noticeable decrease in the time taken to retrieve results.

  2. Check Index Usage: Alex also checked the database's index usage statistics to ensure that the new index was being utilized by the query optimizer.

With the index in place, the application ran smoothly, and Alex could finally rest easy, knowing they had taken a crucial step in optimizing their database. This experience not only resolved the immediate issue but also equipped Alex with the knowledge to tackle future performance challenges with confidence.

Beyond Basics: Compound Indexes for Complex Queries

As Alex delved deeper into the sluggish application, they realized that some queries were more complex than others, involving multiple columns in their search conditions. This complexity led Alex to explore compound indexes, a powerful tool for optimizing such queries.

Understanding Compound Indexes

A compound index, also known as a composite index, is an index that includes more than one column from a table. Unlike single-column indexes, which only optimize queries filtering on one column, compound indexes can significantly enhance performance for queries that involve multiple columns. By storing a sorted combination of the specified columns, compound indexes allow the database engine to quickly locate rows that match the criteria across all indexed columns.

When Compound Indexes Shine

Compound indexes are particularly beneficial in scenarios where:

  1. Multi-Column Filtering: Queries filter on multiple columns simultaneously. For example, a query that searches for users by both last_name and first_name can benefit from a compound index on (last_name, first_name).

  2. Sorting and Grouping: Queries that require sorting or grouping by multiple columns can see performance improvements. A compound index can help avoid additional sorting operations by providing the data in the desired order.

  3. Join Operations: When joining tables on multiple columns, compound indexes can speed up the join process by reducing the number of rows that need to be scanned.

Creating and Using Compound Indexes

Alex decided to create a compound index to optimize a query that was frequently executed in the application. The query filtered users by both city and age, and looked something like this:

SELECT * FROM users WHERE city = 'New York' AND age > 30;

To create a compound index for this query, Alex used the following SQL command:

CREATE INDEX idx_city_age ON users (city, age);

This index allowed the database to quickly locate users in 'New York' who were older than 30, significantly reducing the query execution time.

Considerations for Compound Indexes

While compound indexes can be powerful, Alex learned that they must be used judiciously:

  • Order Matters: The order of columns in a compound index is crucial. The index is most effective when the query filters on the leading column(s) of the index. For example, the index (city, age) is optimal for queries filtering by city first, but not as effective if the query only filters by age.

  • Index Size: Compound indexes can become large, especially if they include several columns or columns with large data types. This can impact storage and maintenance costs.

  • Redundancy: Avoid creating compound indexes that overlap significantly with existing indexes. For instance, if there's already an index on city, adding age to create a compound index might be redundant unless the specific query patterns justify it.

By implementing compound indexes, Alex was able to address some of the application's performance bottlenecks, paving the way for a smoother user experience. As they continued their journey, Alex knew that understanding when and how to use compound indexes was a crucial step in mastering database optimization.

Covering Indexes: When Less is More

As Alex delved deeper into optimizing the sluggish application, they stumbled upon a particularly intriguing concept: covering indexes. This advanced indexing strategy promised to further enhance query performance by reducing the need for additional data retrieval operations. Intrigued by the potential benefits, Alex decided to explore how covering indexes could be the key to unlocking even faster query execution.

What is a Covering Index?

A covering index is a special type of index that includes all the columns needed to satisfy a query. This means that the database engine can retrieve the required data directly from the index itself, without having to access the actual table. By doing so, covering indexes can significantly reduce the number of I/O operations, leading to faster query performance.

In technical terms, a covering index is an index that "covers" a query if all the columns referenced in the query are included in the index. This includes columns in the SELECT list, WHERE clause, JOIN conditions, and any other part of the query.

Benefits of Covering Indexes

The primary advantage of covering indexes is their ability to minimize I/O operations. When a query is executed, the database engine typically needs to access the table data to retrieve the necessary columns. However, with a covering index, the engine can obtain all the required data directly from the index, bypassing the table altogether. This can lead to substantial performance improvements, especially for read-heavy applications.

Some key benefits of covering indexes include:

  • Reduced I/O Operations: By eliminating the need to access the table data, covering indexes can significantly reduce disk I/O, which is often a major bottleneck in query performance.
  • Faster Query Execution: With fewer I/O operations, queries can be executed more quickly, leading to improved application responsiveness.
  • Efficient Use of Resources: Covering indexes can help optimize resource usage by reducing the load on the database server, allowing it to handle more concurrent queries.

Examples of Queries Benefiting from Covering Indexes

To illustrate the power of covering indexes, let's consider a few examples. Suppose Alex is working with a database table named orders that contains the following columns: order_id, customer_id, order_date, and total_amount.

Example 1: Simple Query

Consider a query that retrieves the order_id and total_amount for orders placed by a specific customer:

SELECT order_id, total_amount
FROM orders
WHERE customer_id = 12345;

To optimize this query with a covering index, Alex can create an index that includes all the columns used in the query:

CREATE INDEX idx_orders_covering ON orders (customer_id, order_id, total_amount);

With this covering index, the database engine can satisfy the query entirely from the index, without accessing the orders table.

Example 2: More Complex Query

Now, consider a more complex query that involves filtering and sorting:

SELECT order_id, total_amount
FROM orders
WHERE customer_id = 12345
ORDER BY order_date DESC;

In this case, Alex can create a covering index that includes the customer_id, order_date, order_id, and total_amount columns:

CREATE INDEX idx_orders_covering_complex ON orders (customer_id, order_date, order_id, total_amount);

This index allows the database engine to efficiently filter, sort, and retrieve the required data directly from the index.

Conclusion

As Alex implemented covering indexes, they observed a noticeable improvement in query performance. By reducing the need for additional I/O operations, covering indexes proved to be a powerful tool in the quest for database optimization. With this newfound knowledge, Alex was well-equipped to tackle even the most demanding query performance challenges, ensuring a smooth and responsive application experience for users.

When to Use Indexes: Balancing Performance and Cost

As Alex delved deeper into optimizing the sluggish application, they quickly realized that while indexes could significantly enhance query performance, they also came with their own set of trade-offs. Understanding when to use indexes and when to avoid them became crucial in striking the right balance between performance and cost.

The Trade-Offs of Using Indexes

Indexes are powerful tools for speeding up data retrieval, but they aren't free. They consume additional storage space and require maintenance, which can impact overall system performance. Here's what Alex discovered:

  • Storage Costs: Each index created on a table consumes additional disk space. For large databases, this can lead to significant storage requirements. Alex noticed that the more indexes they added, the more storage was consumed, which could become costly, especially in cloud environments where storage is billed.

  • Maintenance Overhead: Indexes need to be updated whenever data in the indexed columns is modified. This means that insert, update, and delete operations can become slower as the database has to maintain the indexes. Alex observed that while read operations became faster, write operations could suffer, leading to a potential bottleneck in applications with high write loads.

Scenarios Where Indexes May Not Be Beneficial

While indexes can be a boon for query performance, there are scenarios where they might not be the best choice:

  • High Write Workloads: In applications where data is frequently updated or inserted, the overhead of maintaining indexes can outweigh the benefits. Alex found that in such cases, the performance gains in read operations were negated by the slowdown in write operations.

  • Small Tables: For small tables, the performance gain from indexing might be negligible. Full table scans on small datasets can be faster than using an index, as the overhead of accessing the index might not justify the speedup.

  • Low Selectivity Columns: Indexes are most effective on columns with high selectivity, where the indexed column has a wide range of unique values. Indexing columns with low selectivity, such as boolean fields or columns with few distinct values, might not provide significant performance improvements.

Guidelines for Evaluating the Need for Indexes

To determine whether an index is necessary, Alex developed a set of guidelines:

  1. Analyze Query Patterns: Identify the most frequent and time-consuming queries. Focus on optimizing these queries with indexes, as they will have the most significant impact on performance.

  2. Evaluate Column Selectivity: Prioritize indexing columns with high selectivity. Use database statistics to assess the uniqueness of column values and determine if an index would be beneficial.

  3. Consider the Read/Write Ratio: For applications with a high read-to-write ratio, indexes can be more beneficial. Conversely, for write-heavy applications, carefully consider the impact of indexes on write performance.

  4. Monitor and Adjust: Continuously monitor the performance impact of indexes. Use database tools to analyze query execution plans and adjust indexes as needed to ensure optimal performance.

By carefully evaluating these factors, Alex was able to implement an indexing strategy that balanced performance gains with the associated costs, ensuring the application ran smoothly without unnecessary overhead.

Common Pitfalls: Avoiding Indexing Mistakes

As Alex delved deeper into optimizing the sluggish application, they quickly realized that not all indexing strategies are created equal. While indexes can significantly enhance query performance, improper use can lead to new problems. Here are some common pitfalls Alex encountered and how they navigated them.

Over-Indexing: The Double-Edged Sword

One of the most frequent mistakes is over-indexing. In an attempt to speed up every query, developers might create indexes on nearly every column. While this seems like a proactive approach, it can backfire. Each index consumes additional storage space and requires maintenance during data modifications, such as INSERT, UPDATE, or DELETE operations. This can lead to increased I/O operations and slower write performance.

Alex noticed that the database was sluggish during data entry operations. Upon investigation, they found numerous unnecessary indexes. By removing redundant indexes and keeping only those that were essential for query performance, Alex managed to strike a balance between read and write efficiency.

Poorly Chosen Indexes: The Performance Trap

Choosing the wrong columns for indexing can be as detrimental as not having indexes at all. Indexes should be created on columns that are frequently used in WHERE clauses, JOIN conditions, or as part of ORDER BY operations. Indexing columns with low selectivity, such as boolean fields or columns with many duplicate values, often results in minimal performance gains.

Alex encountered a query that was still slow despite having an index. The index was on a column with low selectivity, leading to inefficient query execution. By analyzing the query patterns and understanding the data distribution, Alex redefined the index on a more selective column, resulting in a noticeable performance boost.

Monitoring and Adjusting Indexes: The Continuous Process

Indexing is not a one-time task but an ongoing process. As the application evolves, so do the data and query patterns. Regularly monitoring index usage and performance is crucial. Database management systems like PostgreSQL offer tools such as pg_stat_user_indexes to help identify unused or underutilized indexes.

Alex set up a routine to review index statistics periodically. By using these insights, they could adjust the indexing strategy to align with the current application needs. This proactive approach ensured that the database remained optimized over time.

Tips for Effective Index Management

  • Analyze Query Patterns: Regularly review the most common queries and ensure that indexes support them effectively.
  • Use Database Tools: Leverage built-in database tools to monitor index usage and identify potential improvements.
  • Balance Read and Write Performance: Avoid over-indexing by focusing on indexes that provide the most significant performance benefits.
  • Stay Informed: Keep up with database updates and best practices to ensure that your indexing strategy remains effective.

By avoiding these common pitfalls, Alex was able to transform the application's performance, ensuring a smooth and responsive user experience.

As Alex continues to optimize the application, they begin to explore the future of database indexing, realizing that staying ahead of the curve is crucial for maintaining performance. The landscape of indexing is evolving rapidly, driven by emerging technologies and innovative techniques.

Emerging Technologies and Techniques

One of the most exciting developments in database indexing is the rise of in-memory databases. These databases store data entirely in RAM, allowing for lightning-fast access times. While traditional disk-based indexes are still relevant, in-memory databases are pushing the boundaries of what's possible, offering near-instantaneous query responses. Technologies like Redis and Memcached are leading the charge, providing powerful tools for applications that require real-time data processing.

Another trend is the use of columnar storage formats, such as Apache Parquet and ORC. These formats are optimized for read-heavy workloads, allowing for efficient data retrieval by storing data in columns rather than rows. This approach significantly reduces the amount of data that needs to be scanned during queries, making it a perfect fit for analytical workloads.

The Role of AI and Machine Learning

Artificial intelligence and machine learning are beginning to play a pivotal role in indexing strategies. Alex discovers that AI can be used to automatically analyze query patterns and suggest optimal indexing strategies. Machine learning algorithms can predict which indexes will be most beneficial based on historical query data, reducing the need for manual tuning.

Companies like Google and Microsoft are already integrating AI into their database products. For example, Google's BigQuery uses machine learning to optimize query execution plans, while Microsoft's Azure SQL Database offers automatic indexing features that leverage AI to continuously monitor and adjust indexes for optimal performance.

Speculating on the Future

Looking ahead, Alex speculates on the future of database performance optimization. One possibility is the development of self-healing databases that can autonomously adjust their indexing strategies in real-time. These databases would use AI to detect performance bottlenecks and automatically create, modify, or drop indexes as needed, without human intervention.

Another exciting prospect is the integration of quantum computing into database systems. While still in its infancy, quantum computing holds the potential to revolutionize data processing, offering unprecedented speed and efficiency. As quantum technology matures, it could lead to entirely new indexing paradigms that are currently unimaginable.

For Alex, staying informed about these trends and innovations is essential. By embracing the future of indexing, they can ensure that their application remains fast, efficient, and ready to meet the demands of tomorrow's users.

Key Takeaways: Mastering Indexing Strategies

As Alex wraps up their journey of optimizing the sluggish application, the power of indexing strategies becomes clear. Indexing is not just a tool but a cornerstone of database performance, transforming how data is accessed and manipulated. Here's a recap of the essential insights and actionable steps to master indexing strategies.

The Importance of Indexing

Indexing is crucial for enhancing database performance. It reduces the time and resources needed to retrieve data, turning slow queries into swift operations. By minimizing full table scans, indexes allow databases to quickly locate the necessary data, significantly improving the user experience and application efficiency.

Types of Indexes and Their Use Cases

Throughout Alex's journey, several types of indexes were explored, each serving unique purposes:

  1. Basic Indexes: These are single-column indexes that improve query performance by allowing quick lookups on individual columns. They are ideal for simple queries where a single column is frequently used in search conditions.

  2. Compound Indexes: These indexes involve multiple columns and are beneficial for complex queries that filter or sort data based on multiple fields. They help in scenarios where queries involve multiple conditions, reducing the need for multiple single-column indexes.

  3. Covering Indexes: These indexes include all the columns needed to satisfy a query, allowing the database to retrieve data directly from the index without accessing the table. They are particularly useful for read-heavy applications where reducing I/O operations is critical.

Actionable Steps for Effective Indexing

To implement effective indexing strategies, consider the following steps:

  • Analyze Query Patterns: Understand the queries that are most critical to your application. Identify which columns are frequently used in WHERE clauses, JOIN conditions, and ORDER BY clauses.

  • Choose the Right Index Type: Based on your query analysis, decide whether a basic, compound, or covering index is most appropriate. Remember that the right index can drastically reduce query execution time.

  • Monitor and Adjust: Regularly monitor the performance of your indexes. Use database tools to analyze index usage and identify any that are underutilized or causing overhead. Adjust your indexing strategy as your application evolves.

By mastering these indexing strategies, Alex not only optimized the application but also laid the groundwork for scalable and efficient database management.

Was this any use?

A

AiCanCode.org Engineering

Practical engineering articles on Java, system design, and AI engineering. Learn more at AiCanCode.org

Share

Discussion

Discussion

Sign in to ask a question — Aria answers, and so do other students.

Loading discussion…