Optymalizacja kodu i bazy danych

Performance issues often stem from inefficient code or slow database interactions. Optimizing these areas is crucial for a fast and responsive application.

In this lesson, we'll dive into practical strategies to make your code run faster and your database queries more efficient.

Even small inefficiencies in your code can lead to big problems under load. Optimized code:

• Reduces resource usage: Less CPU and memory.
• Speeds up execution: Faster response times for users.
• Improves scalability: Handles more users with the same resources.

The choice of algorithm and data structure can have the biggest impact on performance. For example, searching through an unsorted list takes longer than searching a sorted one.

Always consider the time and space complexity (how operations scale with data size) of your chosen approach.

Watch out for these common issues that slow down your code:

• Excessive object creation: Creating many temporary objects can stress the garbage collector.
• Unnecessary computations: Calculating the same value multiple times.
• Inefficient string manipulation: Repeatedly concatenating strings in a loop (especially in Java, C#).

Let's see how optimizing string concatenation can make a difference. Using StringBuilder (Java) is often much faster than repeated + operations in loops.

Try running this example:

The database is often the slowest part of an application. Slow queries can lead to:

• Long user wait times.
• Increased server load.
• Database connection pooling issues.
• Application timeouts.

Optimizing your database is key to overall system performance.

Database indexes are special lookup tables that the database search engine can use to speed up data retrieval. Think of it like an index in a book.

Indexes can dramatically improve the performance of SELECT queries, especially those with WHERE, JOIN, or ORDER BY clauses.

How you write your SQL queries directly impacts performance:

• Select specific columns: Avoid SELECT *; only fetch data you need.
• Filter early: Use WHERE clauses to reduce the data set before joining or sorting.
• Optimize JOINs: Ensure joined columns are indexed.
• Avoid N+1 queries: Fetch related data in one go rather than many individual queries.

A well-designed database schema is fundamental:

• Data Types: Use the smallest appropriate data type (e.g., SMALLINT instead of BIGINT if range allows).
• Normalization: Reduces data redundancy, but can increase JOINs.
• Denormalization: Adds redundancy to reduce JOINs for read-heavy operations. Find a balance!

Before you start optimizing, remember these:

• Measure First: Don't guess where bottlenecks are; use profiling tools.
• Optimize Hot Spots: Focus on the 20% of code/queries that cause 80% of the problems.
• Don't Over-Optimize: Premature optimization can lead to complex, harder-to-maintain code with little benefit.

Which of the following are good practices for optimizing application code or database performance? Select all that apply.

We've explored how to optimize both application code and database interactions to boost performance.

• Choose efficient algorithms and data structures.
• Avoid common code pitfalls like inefficient string handling.
• Utilize database indexes to speed up queries.
• Write smart SQL queries and design your schema for performance.
• Always measure, focus on hot spots, and avoid premature optimization!