<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*v-tl1ilNqK9xMDAT.jpeg"></figure><h4>In the world of software development, particularly in building complex applications, maintaining clean and manageable code is paramount. One of the key principles aiding in this endeavor is Inversion of Control (IoC). This article delves into what IoC is, why it’s important, and how it’s implemented in frameworks like NestJS.</h4>
<h3>What is Inversion of Control (IoC)?</h3>
Inversion of Control (IoC) is a design principle in which the control of object creation and dependency management is inverted. Instead of the component or class creating its dependencies, an external entity (often a framework or a container) is responsible for creating and injecting these dependencies. This principle leads to more modular, testable, and maintainable code.
<h3>Key Benefits of IoC:</h3>
<ul>
<li>
Decoupling: Components are not tightly bound to their dependencies, making them easier to manage and modify.</li>
<li>
Testability: Easier to mock dependencies in unit tests.</li>
<li>
Maintainability: Promotes cleaner and more modular code, reducing the complexity of managing dependencies.</li>
</ul>
<h3>IoC in Practice: Dependency Injection (DI)</h3>
One of the most common implementations of IoC is Dependency Injection (DI). DI is a technique where an object’s dependencies are provided to it, rather than the object creating them itself. There are several types of DI, including constructor injection, property injection, and method injection.
<h3>Constructor Injection:</h3>
Constructor injection is one of the most popular forms of DI, where dependencies are provided through a class constructor.
<pre>class MyService { constructor(private readonly emailService: EmailService) {} }</pre>
In the example above, MyService receives EmailService as a dependency through its constructor. This approach makes MyService independent of how EmailService is instantiated.
<h3>Implementing IoC in NestJS</h3>
NestJS, a progressive Node.js framework, embraces IoC and DI principles to manage dependencies efficiently. Let’s explore how NestJS implements IoC using decorators and metadata.
<h3>Using the @Injectable() Decorator</h3>
In NestJS, services and other injectable classes are marked with the @Injectable() decorator. This decorator registers the class with the NestJS IoC container.
<pre>import { Injectable } from '@nestjs/common';</pre>
<pre>@Injectable() class EmailService { sendEmail() { // Logic to send an email } }</pre>
<h3>Injecting Dependencies</h3>
To inject dependencies into a class, you simply declare them in the constructor, and NestJS’s IoC container takes care of the rest.
<pre>import { Injectable } from '@nestjs/common';</pre>
<pre>@Injectable() class MyService { constructor(private readonly emailService: EmailService) {}</pre>
<pre> notifyUser() { this.emailService.sendEmail(); } }</pre>
<h3>How NestJS Handles IoC</h3>
Under the hood, NestJS uses the reflect-metadata library to retain metadata about dependencies. When TypeScript is transpiled to JavaScript, type annotations are removed. However, with reflect-metadata, NestJS can retrieve the necessary type information at runtime.
<h3>Setting Up reflect-metadata</h3>
Ensure you have reflect-metadata installed in your project and imported in your main file (e.g., main.ts):
<pre>import 'reflect-metadata';</pre>
This setup allows NestJS to correctly identify and inject dependencies, even after the type annotations are stripped away during transpilation.
<h3>Conclusion</h3>
Inversion of Control (IoC) is a fundamental principle that promotes decoupling and enhances the maintainability and testability of your code. NestJS leverages IoC through its robust Dependency Injection (DI) system, making it a powerful framework for developing scalable and maintainable server-side applications.
By understanding and utilizing IoC and DI in NestJS, you can write cleaner, more modular code that is easier to test and maintain. Whether you’re building simple APIs or complex microservices, IoC principles can significantly improve your development workflow and code quality.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=418404732b61" width="1" height="1" alt="">

Understanding Inversion of Control (IoC) and Its Implementation in NestJS

When working with databases, ensuring data integrity is critical. One of the ways to achieve this in PostgreSQL is by using domain types and enums. These help to define constraints and restrict the type of data that can be inserted into a table. Let’s dive into how they work and why they are so useful.
<h3>Custom Domain Types</h3>
A domain type in PostgreSQL is essentially a custom data type that adds constraints to an existing type. This approach allows you to reuse constraints across multiple tables, making your database schema cleaner and more consistent.
In simple terms, a domain type is a combination of a data type and a constraint. While you could add constraints directly to each column, using a domain type allows you to enforce the same rules across several tables without repeating yourself.
Here’s an example of how we can create and use a custom domain type for a US Postal Code:
<pre>CREATE DOMAIN us_postal_code AS TEXT CONSTRAINT postal_code_format CHECK ( VALUE ~ '^\d{5}$' OR VALUE ~ '^\d{5}-\d{4}$' );</pre>
In the above code:
<ul>
<li>We define a domain called us_postal_code as a TEXT type.</li>
<li>The constraint ensures the postal code follows the format of either a 5-digit code (e.g., 12345) or a 9-digit code with a hyphen (e.g., 12345-6789).</li>
</ul>
Now, let’s create a table and use this domain type:
<pre>CREATE TABLE addresses ( city TEXT, address TEXT, post_code us_postal_code );</pre>
Here are a few insert operations:
<pre>INSERT INTO addresses (city, address, post_code) VALUES ('LA', 'Main-Street', '12345'); -- SUCCESS INSERT INTO addresses (city, address, post_code) VALUES ('LA', 'Main-Street', '1234'); -- ERROR: value for domain us_postal_code violates check constraint "postal_code_format"</pre>
The advantage of using a domain type is that you can reuse this us_postal_code domain across multiple tables, ensuring consistency without redefining the constraints each time.
<h3>Enums in PostgreSQL</h3>
An ENUM is a finite set of predefined values. Enums are an excellent way to store a field that has a fixed set of possible values. For instance, if you were managing the status of an order in an e-commerce system, you might want to define a set of possible statuses, such as {NEW, PAID, IN_DELIVERY, DELIVERED, CANCELED}.
Benefits of Enums:
<ul>
<li>
Text Representation for Humans: Enums are stored as integers in the database, but they are represented as text to humans, which is more intuitive.</li>
<li>
Fixed Values: Enums are great when you know that the set of values is fixed and doesn’t change frequently.</li>
</ul>
Here’s how you can create an enum in PostgreSQL:
<pre>CREATE TYPE mood AS ENUM ('HAPPY', 'SAD', 'NEUTRAL')</pre>
Now, you can use the enum type in a table:
<pre>CREATE TABLE clients ( name TEXT, current_mood MOOD );</pre>
Inserting data into the table is easy:
<pre>INSERT INTO clients(name, current_mood) VALUES ('Bruce', 'HAPPY'), ('Ann', 'SAD'), ('Bob', 'NEUTRAL');</pre>
If you try to insert a value that doesn’t exist in the enum, you’ll get an error:
<pre>INSERT INTO clients(name, current_mood) VALUES ('Jack', 'Obsessed'); -- ERROR: invalid input value for enum mood: "Obsessed"</pre>
<h3>Enum Ordering</h3>
One interesting feature of enums is their ordering. The order of enum values is the order in which they are defined. This order is crucial when performing queries like ORDER BY:
<pre>SELECT * FROM clients ORDER BY current_mood;</pre>
<pre>-- OUTPUT +-----+------------+ |name |current_mood| +-----+------------+ |Bruce|HAPPY | |Ann |SAD | |Bob |NEUTRAL | +-----+------------+</pre>
The result will be sorted based on the internal order of the enum values (HAPPY = 1, SAD = 2, NEUTRAL = 3).
<h3>Adding New Enum Values</h3>
You can extend an existing enum type by adding new values. The new values are added to the end of the list by default, but you can also specify where you want them inserted:
<pre>ALTER TYPE mood ADD VALUE 'EXCITED';</pre>
<pre>INSERT INTO clients(name, current_mood) VALUES ('Jamie', 'EXCITED');</pre>
<pre>SELECT distinct * FROM clients ORDER BY current_mood;</pre>
<pre>+-----+------------+ |name |current_mood| +-----+------------+ |Bruce|HAPPY | |Ann |SAD | |Bob |NEUTRAL | |Jamie|EXCITED | +-----+------------+</pre>
If you want to control the order of the values, you can specify whether the new value should come before or after existing ones:
<pre>ALTER TYPE mood ADD VALUE 'OBSESSED' BEFORE 'SAD'; ALTER TYPE mood ADD VALUE 'AFRAID' AFTER 'HAPPY';</pre>
<h3>Additional PostgreSQL Functions</h3>
A useful function for developers working with PostgreSQL is PG_TYPEOF(), which returns the internal data type of a given value. This can be helpful for debugging or understanding data conversions in your queries.
<pre>PG_TYPEOF('11:13:59.77091+05'::time); -- Returns: time without time zone PG_TYPEOF(12.2999); -- Returns: numeric</pre>
<h3>Conclusion</h3>
By using custom domain types and enums in PostgreSQL, you can enhance data integrity and improve the maintainability of your database schema. Domain types allow you to enforce constraints and reuse them across multiple tables, while enums help manage fixed sets of values in a human-readable format.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=4faf6760b7e9" width="1" height="1" alt="">

PostgreSQL Domain Types and Enums

How to Implement Accurate Booking in Reservation Systems?
In PostgreSQL, exclusion constraints provide a way to ensure that certain combinations of column values are unique across rows. This is useful when you need to prevent conflicting or overlapping data, even if the individual columns can have duplicates.
An exclusion constraint works by specifying that two rows cannot exist if they meet a particular set of conditions. This is typically achieved using a GiST (Generalized Search Tree) or GIN (Generalized Inverted Index) index.
Use Cases for Exclusion Constraints: - Avoid overlapping date range : Prevent two bookings from overlapping in time. - Enforce geometric constraints: Ensure that geometric figures do not intersect each other. - Prevent confliction values in complex data types: For instance, ensuring no two students are assigned the same task.
Let’s create a reservations table and see how we can prevent overlapping bookings.
<h3>Example: Room Reservations</h3>
<pre>CREATE TABLE reservations ( id serial PRIMARY KEY, room_id INTEGER, booking_status TEXT, start_date TIMESTAMP, end_date TIMESTAMP, EXCLUDE USING GIST (TSRANGE(start_date, end_date) WITH &amp;&amp;) );</pre>
Explanation: The EXCLUDE USING GISTclause creates an exclusion constraint that ensures there are no conflicting bookings for the same date range. The TSRANGE(start_date, end_date) WITH &amp;&amp; condition checks for overlapping date ranges.
Inserting a Booking Let’s try to book a room for our next vacation:
<pre>INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (1, 'CONFIRMED', '2025–01–08 14:00:00', '2025–01–15 12:00:00');</pre>
This works fine, and we have our first booking:
<pre>+--+-------+--------------+-------------------+--------------------------+ |id|room_id|booking_status|start_date |end_date | +--+-------+--------------+-------------------+--------------------------+ |1 |1 |CONFIRMED |2025-01-08 14:00:00|2025-01-15 12:00:00 | +--+-------+--------------+-------------------+--------------------------+</pre>
Trying to Insert an Overlapping Booking
Now, let’s try to book the same room for overlapping dates:
<pre>INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (1, 'CONFIRMED', '2025–01–12 14:00:00', '2025–01–18 12:00:00');</pre>
We get an error:
<pre>ERROR: conflicting key value violates exclusion constraint "reservations_tsrange_excl" DETAIL: Key (tsrange(start_date, end_date)) = (["2025–01–12 14:00:00", "2025–01–18 12:00:00")) conflicts with existing key (tsrange(start_date, end_date)) = (["2025–01–08 14:00:00", "2025–01–15 12:00:00")).</pre>
This behavior ensures that overlapping bookings cannot be inserted, much like how you can’t book a hotel room that’s already occupied.
Booking a Different Room at the Same Time
Let’s try to book another room for the same period:
<pre>INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (2, 'CONFIRMED', '2025–01–12 14:00:00', '2025–01–18 12:00:00');</pre>
Oops! We get the same error:
<pre>ERROR: conflicting key value violates exclusion constraint "reservations_tsrange_excl" DETAIL: Key (tsrange(start_date, end_date)) = (["2025–01–12 14:00:00", "2025–01–18 12:00:00")) conflicts with existing key (tsrange(start_date, end_date)) = (["2025–01–08 14:00:00", "2025–01–15 12:00:00")).</pre>
The Issue
The exclusion constraint currently applies to the whole table, meaning it checks for overlapping date ranges across all rooms. What we actually want is to allow bookings in different rooms for the same period. To fix this, we need to modify our exclusion constraint.
Solution: Add room_id to the Exclusion Constraint
By including the room_id in the exclusion condition, we ensure that the constraint only applies to the same room.
<pre>-- Enable the btree_gist extension (if not already enabled) CREATE EXTENSION IF NOT EXISTS btree_gist;</pre>
<pre>-- New table definition with room_id in the exclusion constraint CREATE TABLE reservations ( id serial PRIMARY KEY, room_id INTEGER, booking_status TEXT, start_date TIMESTAMP, end_date TIMESTAMP, EXCLUDE USING GIST (room_id WITH =, TSRANGE(start_date, end_date) WITH &amp;&amp;) );</pre>
Now, we can book two rooms for the same period:
<pre>- Booking two rooms for the exact period INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (1, 'CONFIRMED', '2025–01–12 14:00:00', '2025–01–18 12:00:00'); INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (2, 'CONFIRMED', '2025–01–12 14:00:00', '2025–01–18 12:00:00');</pre>
Result
The table now allows overlapping bookings in different rooms:
<pre>+--+-------+--------------+-------------------+--------------------------+ |id|room_id|booking_status|start_date |end_date | +--+-------+--------------+-------------------+--------------------------+ |1 |1 |CONFIRMED |2025-01-08 14:00:00|2025-01-15 12:00:00 | +--+-------+--------------+-------------------+--------------------------+ |2 |2 |CONFIRMED |2025-01-08 14:00:00|2025-01-15 12:00:00 | +--+-------+--------------+-------------------+--------------------------+</pre>
<h3>Partial Exclusion Constraints</h3>
Now let’s consider what happens when a booking is canceled. The CANCELED status means the room is no longer occupied and can be booked again.
<pre>- Booking a room INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (1, 'CONFIRMED', '2025–01–12 14:00:00', '2025–01–18 12:00:00');</pre>
<pre> - Cancel the booking UPDATE reservations SET booking_status = 'CANCELED' WHERE room_id = 1</pre>
At this point, the reservation for room 1 has been canceled:
<pre>+--+-------+--------------+-------------------+--------------------------+ |id|room_id|booking_status|start_date |end_date | +--+-------+--------------+-------------------+--------------------------+ |1 |1 |CANCELED |2025-01-08 14:00:00|2025-01-15 12:00:00 | +--+-------+--------------+-------------------+--------------------------+</pre>
Trying to Book the Canceled Room Again
We can now insert a new booking for room 1 for the same period:
<pre>- Trying to book the same room and period again INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (1, 'CONFIRMED', '2025–01–12 14:00:00', '2025–01–18 12:00:00');</pre>
Oopps! We get the error again.
<pre>ERROR: conflicting key value violates exclusion constraint "reservations_room_id_tsrange_excl" Detail: Key (room_id, tsrange(start_date, end_date))=(1, ["2025-01-12 14:00:00","2025-01-18 12:00:00")) conflicts with existing key (room_id, tsrange(start_date, end_date))=(1, ["2025-01-12 14:00:00","2025-01-18 12:00:00")).</pre>
<pre>To solve this error, Partial Exclusion Constraints come into play.</pre>
To fix this, we can define a partial exclusion constraint, which only applies to rows that are not canceled.
<h3>Defining the Partial Exclusion Constraint</h3>
A partial exclusion constraint is a constraint that applies only to a subset of rows in a table, based on a specific condition. This is useful when you want to enforce the exclusion condition only under certain circumstances. In our case, apply the condition only if the booking is not Canceled.
This is how we can define Partial Exclusion Constraint.
<pre>EXCLUDE USING GIST (room_id WITH =,TSRANGE(start_date, end_date) WITH &amp;&amp;) WHERE (booking_status != 'CANCELED') -- Extra Where () check added.</pre>
Full Table Definition:
<pre>CREATE TABLE reservations ( id serial primary key, room_id INTEGER, booking_status TEXT, start_date TIMESTAMP, end_date TIMESTAMP, EXCLUDE USING GIST (room_id WITH =,TSRANGE(start_date, end_date) WITH &amp;&amp;) WHERE (booking_status != 'CANCELED') );</pre>
Testing Partial Exclusion
<pre>INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (1, 'CONFIRMED', '2025-01-12 14:00:00', '2025-01-18 12:00:00');</pre>
<pre>INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (2, 'CONFIRMED', '2025-01-12 14:00:00', '2025-01-18 12:00:00');</pre>
<pre>-- Cancel reservation for room_id = 2 UPDATE reservations SET booking_status = 'CANCELED' WHERE room_id = 2;</pre>
<pre>-- Inserting new reservation for exact room_id and period INSERT INTO reservations (room_id, booking_status, start_date, end_date) VALUES (2, 'CONFIRMED', '2025-01-12 14:00:00', '2025-01-18 12:00:00');</pre>
<pre>SELECT * FROM reservations;</pre>
Now, everything works as expected!
<pre>+--+-------+--------------+-------------------+--------------------------+ |id|room_id|booking_status|start_date |end_date | +--+-------+--------------+-------------------+--------------------------+ |1 |1 |CONFIRMED |2025-01-08 14:00:00|2025-01-15 12:00:00 | +--+-------+--------------+-------------------+--------------------------+ |2 |2 |CANCELED |2025-01-08 14:00:00|2025-01-15 12:00:00 | +--+-------+--------------+-------------------+--------------------------+ |3 |2 |CONFIRMED |2025-01-08 14:00:00|2025-01-15 12:00:00 | +--+-------+--------------+-------------------+--------------------------+</pre>
Conclusion
By using exclusion constraints in PostgreSQL, we can enforce the right business rules directly in the database, ensuring that:
<ul>
<li>No overlapping bookings occur for the same room.</li>
<li>Overlapping bookings can be allowed for different rooms.</li>
<li>Canceled bookings can be reused without violating the constraint.</li>
</ul>
Quick Recap: - Exclusion Constraints: Prevent conflicts like overlapping data in tables. - Partial Exclusion Constraints: Apply exclusion logic only to a subset of rows, based on a condition (such as booking_status != 'CANCELED').
In conclusion, exclusion constraints are a powerful tool to ensure data integrity and enforce complex business logic. They allow us to maintain consistency while handling real-world scenarios, such as room bookings in hotels or scheduling systems.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=f9fdb4158f9e" width="1" height="1" alt="">

PostgreSql Exclusion Constraints

recently I have researched about how to improve performance in PostgresSql and I want to share this knowledge with you guys. here my findings Enjoy :)
<h3>How to tune PostgreSQL performance?</h3>
<h3>1. Database design</h3>
Effective database design is crucial for optimizing PostgreSQL performance:
<ul>
<li>
Normalization: It’s crucial to properly normalize your database schema to ensure data integrity and reduce redundancy. Normalization involves organizing data into tables so that each table focuses on a single subject or concept, eliminating data duplication. However, over-normalization can lead to excessive joins between tables, which may degrade performance.</li>
<li>
Denormalization: Denormalization involves intentionally adding redundancy to speed up query performance, especially for read-heavy databases where complex joins slow down access to data.</li>
<li>
Indexing: Indexes allow PostgreSQL to locate and retrieve data quickly without scanning the entire table. Choosing the right columns to index, particularly those frequently used in WHERE clauses, JOIN conditions, and ORDER BY statements, can significantly improve query performance. However, indexes come with trade-offs: they consume additional storage space and create overhead during data writes.</li>
<li>
Partitioning: This is a way to divide a large table into smaller, more manageable pieces based on a specific criterion, such as a range of dates or a list of values. When a query targets a specific partition, PostgreSQL can skip other partitions, reducing the amount of data scanned and speeding up query execution.</li>
</ul>
<h3>2. Hardware and environment tuning</h3>
CPU
<ul>
<li>
Adding cores: The more cores available, the more tasks PostgreSQL can execute in parallel, leading to faster query processing. For example, operations such as parallel query execution, index creation, and data aggregation can benefit significantly from additional cores.</li>
<li>
CPU speed: Faster clock speeds improve the performance of single-threaded tasks</li>
<li>
Hyper-threading: Enabling hyper-threading (if supported) can improve performance by allowing each core to handle multiple threads simultaneously, doubling the number of cores available to PostgreSQL.</li>
<li>
CPU performance tuning: This involves configuring the CPU for performance rather than energy efficiency. In many systems, you can adjust power settings in the BIOS to prioritize performance, ensuring that the CPU runs at higher frequencies under load.</li>
</ul>
RAM
RAM directly affects the database’s ability to cache data, reducing the need to access slower disk storage. The more RAM available, the more data PostgreSQL can keep in memory, which speeds up read operations. There are two key parameters that control how much RAM PostgreSQL uses for caching:
<ul>
<li>
Shared_buffers: As a rule of thumb, shared_buffers should be set to about 25% to 40% of the total system RAM, depending on the workload. However, the actual allocation needs to be balanced with the memory requirements of the operating system and other applications running on the same server. If shared_buffers is too small, PostgreSQL will frequently access the disk, leading to slower performance. If it’s too large, it can starve the system of memory, causing the OS to swap memory to disk, which is detrimental to performance.</li>
<li>
Work_mem: This parameter determines the amount of memory allocated for sorting operations and hash tables in queries. For complex queries, increasing work_mem allows PostgreSQL to perform these operations in memory rather than on disk, speeding up query execution. However, it’s essential to avoid setting work_mem too high globally, as it’s allocated per operation, and multiple operations running concurrently can quickly consume all available RAM.</li>
</ul>
<h3>3. PostgreSQL connections</h3>
Managing the number of active connections to PostgreSQL is crucial for maintaining performance and stability. Each connection to the PostgreSQL server consumes memory and CPU resources
By default, PostgreSQL handles connections on a one-process-per-connection basis, meaning each connection spawns a new process.
<ul>
<li>
Use a connection pooler like PgBouncer: PgBouncer sits between your application and PostgreSQL, maintaining a pool of active connections to the database while queuing excess requests.</li>
<li>
Configure maximum number of connections (max_connections): However, it’s important to find a balance. Setting this value too high can lead to excessive context switching and memory usage, while setting it too low might result in connection refusals when the limit is reached.</li>
</ul>
<h3>4. PostgreSQL buffer pool</h3>
The PostgreSQL buffer pool, controlled by the shared_buffers setting, is where data is temporarily stored before being written to disk or after being read from disk. Properly tuning the buffer pool size is crucial for optimal performance.
If the buffer pool is too small, PostgreSQL will frequently need to fetch data from disk, which is slower than reading it from memory. On the other hand, if the buffer pool is too large, it can consume too much RAM, leaving insufficient memory for the operating system and other processes.
In general, shared_buffers should be set to 25% to 40% of the total system RAM, though this can vary depending on the workload.
<h3>5. PostgreSQL log settings</h3>
Tuning PostgreSQL’s log settings is essential for diagnosing and resolving performance issues. Logs can provide valuable insights into how the database is functioning, where bottlenecks are occurring, and what queries are underperforming.
<ul>
<li>
log_min_duration_statement: Determines the minimum execution time for queries that should be logged. By setting this parameter, you can capture slow queries that exceed a specified duration, allowing you to analyze and optimize them.</li>
<li>
log_checkpoints: Enabling this can help you understand the impact of checkpoints on performance. When enabled, PostgreSQL logs information about each checkpoint, including how long it took and whether it triggered excessive I/O.</li>
<li>
log_lock_waits: Shows which logs any queries that have to wait for a lock for more than a specified duration. This can help identify locking issues, such as deadlocks or contention points.</li>
<li>
log_statement: Configuring this to log all statements (or specific types like ddl for data definition language commands) can provide a comprehensive view of database activity. However, this should be used with caution in production environments, as it can generate a large amount of log data.</li>
</ul>
<h3>6. Query performance tuning</h3>
Query performance tuning is one of the most impactful areas for improving PostgreSQL performance. It involves analyzing how SQL queries are executed and making adjustments to ensure they run as efficiently as possible.
Here are a few common query optimization strategies:
<ul>
<li>
Analyzing the execution plan of queries using the EXPLAIN command. EXPLAIN provides detailed information about how PostgreSQL executes a query, including which indexes are used, the join methods applied, and the estimated cost of each operation.</li>
<li>
Rewriting queries to use joins instead of subqueries, especially correlated subqueries, which can be significantly slower. For instance, a subquery that needs to be executed multiple times for each row in the outer query can often be replaced by a join, which PostgreSQL can execute more efficiently.</li>
<li>
Limiting the number of row returned by queries using the LIMIT clause, especially in cases where only a subset of the data is needed. This reduces the amount of data PostgreSQL needs to process and transmit, speeding up query execution.</li>
<li>
Optimizing JOIN operations is also crucial. For example, ensuring that the columns used in joins are indexed can greatly reduce the time required to execute the join. Additionally, using the appropriate join type (e.g., INNER JOIN, LEFT JOIN) based on the specific needs of the query can avoid unnecessary processing.</li>
<li>
Reducing the number of columns returned by queries can also improve performance. By only selecting the columns you need, you reduce the amount of data that PostgreSQL must read, process, and send back to the client.</li>
</ul>
Also, if you keep this suggestions I am sure you will like them. Here is how you can upgrade your PostgresSql to be more faster.
Keep Enjoying :)
<h3>Limit the number of rows returned by a query</h3>
In case of small tables, we may not need to take care about the number of returned rows (while I highy suggest to limit them anyway!) in case of bigger tables, this can be extremely useful for improving performance of queries.
We can achieve that in SQL by using the keyword LIMIT with following query:
<pre>SELECT * FROM products LIMIT 10</pre>
<h3>Use JOIN instead of subqueries</h3>
If there are many records in the table, running a query with subqueries inside may not be performant — instead we could use the JOIN keyword which can be significantly faster.
Instead of using subqueries like following:
<pre>SELECT * FROM orders WHERE product_id IN (SELECT id FROM products WHERE name = 'Phone');</pre>
We could use JOIN keyword like this:
<pre>SELECT orders.* FROM orders JOIN products ON orders.product_id = products.id WHERE products.name = 'Phone';</pre>
This can be much faster if your table has big amount of rows.
<h3>Use efficient data types for columns</h3>
For rows where there are frequent calculations like average it can be beneficial to check what is the datatype for the column. For example, it will be more efficient to use smallint rather than integer. You can change it like following:
<pre>ALTER TABLE products ALTER COLUMN price TYPE smallint;</pre>
<h3>Use PREPARE for frequently executed queries</h3>
If you know that some queries will be executed frequently, for example a Fetch_Popular_Products_Query, you can use a keyword PREPARE like following:
<pre>PREPARE get_products_by_name (text) AS SELECT * FROM products WHERE name = $1; EXECUTE get_products_by_name('Phone');</pre>
By using this approach, the query will be prepared once and the execution will be reused to improve performance.
<h3>Using INDEX for frequent queries</h3>
If you frequently search for products by their name, you can create an index of the name column like following:
<pre>CREATE INDEX products_name_idx ON products (name);</pre>
It will be especially effective if you would use multiple WHERE or JOIN keywords in your regular query.
<h3>Not use wildcard characters</h3>
Let’s say that we have a query that will search for all products to find those whose name ends with phone:
<pre>SELECT * FROM products WHERE name LIKE '%phone';</pre>
This query will perform a sequential scan of the entire products table, which can be slow if the table is large. To optimize this query, you can rewrite it like this:
<pre>SELECT * FROM products WHERE name LIKE 'phone%';</pre>
This query will use the index created in previous point and perform a much faster index scan.
<h3>Debugging queries with EXPLAIN keyword</h3>
The EXPLAIN command will output the execution plan for the query, which can help you identify any performance issues and you can use it like following:
<pre>EXPLAIN SELECT COUNT(*) FROM products JOIN orders ON products.id = orders.products_id;</pre>
<h3>Use full text search service for faster searching by query/ID</h3>
Searching through milions of records to find a specific record by a name, or more difficult case — part of name, can be really slow. To solve this problem, you could implement a full test search service like <a href="https://www.elastic.co/elasticsearch">ElasticSearch</a> that can be much faster.
How this would work is that you will store key/value pairs inside your ElasticSearch database in a form of POSTGRESQL_ID/RECORD_NAME, then you will search through the values to find a full or part of the name and assigned PostgreSQL ID, and finally you will perform a PostgreSQL query WHERE id = 'POSTGRESQL_ID' instead of WHERE name LIKE 'RECORD_NAME' which can be significantly more performant as you will be querying for specific record rather than records that match certain search criteria.
This approach looks amazing for performance and optimizing queries, but you have to take into consideration that it will add additional layer of complexity and another service to your infrastructure that you would need to maintain.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=a6b3a173869b" width="1" height="1" alt="">

How to tune PostgresSql performance?

Object-Oriented Programming (OOP) in JavaScript is a paradigm centered around objects rather than functions.
Unlike procedural programming, which structures programs as sequences of steps or logic, OOP models complex systems as interactive objects.
This guide delves into the core principles of OOP in JavaScript, with some coding examples.
<h3>Fundamentals of OOP in JavaScript</h3>
<h3>1. Objects and Classes In JavaScript, an object is a standalone entity, with properties and type.</h3>
<pre>let dog = { breed: 'Labrador', color: 'black', bark() { console.log('Woof!'); } }; dog.bark(); // Woof!</pre>
Classes, introduced in ES6, are a template for creating objects.
<pre>class Animal { constructor(name) { this.name = name; } speak() { console.log(`${this.name} makes a noise.`); } } let animal = new Animal('Dog'); animal.speak(); // Dog makes a noise.</pre>
<h3>2. Encapsulation Encapsulation means that the internal representation of an object is hidden from the outside.</h3>
<pre>class Car { constructor(brand) { this._brand = brand; } get brand() { return this._brand; } set brand(newBrand) { this._brand = newBrand; } } let myCar = new Car('Ford'); console.log(myCar.brand); // Ford myCar.brand = 'BMW'; console.log(myCar.brand); // BMW</pre>
<h3>3. Inheritance Inheritance allows a class to inherit properties and methods from another class.</h3>
<pre>class Animal { constructor(name) { this.name = name; } speak() { console.log(`${this.name} makes a noise.`); } } class Dog extends Animal { speak() { console.log(`${this.name} barks.`); } } let d = new Dog('Mitzie'); d.speak(); // Mitzie barks.</pre>
<h3>4. Polymorphism Polymorphism allows objects of different classes to be treated as objects of a common superclass.</h3>
<pre>class Animal { speak() { console.log('Animal speaks'); } } class Cat extends Animal { speak() { console.log('Meow'); } } class Dog extends Animal { speak() { console.log('Woof'); } } function makeAnimalSpeak(animal) { animal.speak(); } makeAnimalSpeak(new Cat()); // Meow makeAnimalSpeak(new Dog()); // Woof</pre>
<h3>5. Abstraction Abstraction involves creating simple models representing complex real-world objects.</h3>
<pre>class Vehicle { startEngine() { console.log('Engine started'); } stopEngine() { console.log('Engine stopped'); } } class Car extends Vehicle { startEngine() { console.log('Car engine started'); } } let myCar = new Car(); myCar.startEngine(); // Car engine started</pre>
<h3>Advanced OOP Concepts in JavaScript</h3>
<h3>6. Constructors and the new Keyword Constructors are special functions that create and initialize objects.</h3>
<pre>class Person { constructor(name, age) { this.name = name; this.age = age; } } let person = new Person('Alice', 25); console.log(person); // Person { name: 'Alice', age: 25 }</pre>
<h3>7. Methods — Instance, Static, and Prototype Methods Methods in JavaScript classes can be instance, static, or prototype methods.</h3>
<pre>class Rectangle { constructor(width, height) { this.width = width; this.height = height; } // Instance method getArea() { return this.width * this.height; } // Static method static compareArea(rect1, rect2) { return rect1.getArea() - rect2.getArea(); } } let rect1 = new Rectangle(5, 8); let rect2 = new Rectangle(6, 7); console.log(Rectangle.compareArea(rect1, rect2)); // -2</pre>
<h3>8. Getters and Setters Getters and setters allow you to define Object Accessors (Computed Properties).</h3>
<pre>class Person { constructor(firstName, lastName) { this.firstName = firstName; this.lastName = lastName; } get fullName() { return `${this.firstName} ${this.lastName}`; } set fullName(name) { [this.firstName, this.lastName] = name.split(' '); } } let person = new Person('John', 'Doe'); console.log(person.fullName); // John Doe person.fullName = 'Jane Smith'; console.log(person.fullName); // Jane Smith</pre>
<h3>9. Inheritance with extends and super The extends keyword is used in class declarations to create a class as a child of another class.</h3>
<pre>class Shape { constructor(name) { this.name = name; } move() { console.log(`${this.name} moved`); } } class Circle extends Shape { constructor(radius) { super('Circle'); this.radius = radius; } } let myCircle = new Circle(5); myCircle.move(); // Circle moved</pre>
<h3>Object-Oriented vs. Functional Programming in JavaScript</h3>
Differences Between OOP and Functional Programming - State and Immutability: OOP handles state within objects, which can change over time. In contrast, functional programming prefers immutable data structures and pure functions without side effects. - Methodology: OOP is about modeling real-world entities using objects and classes, whereas functional programming focuses on the computation process and avoids changing state. - Code Reusability: In OOP, reusability comes through inheritance and polymorphism. Functional programming achieves reusability through functions and higher-order functions.
<h3>When to Use OOP or Functional Programming</h3>
Use OOP when: - You’re dealing with a complex system with clearly defined types and relationships. - Your application’s state changes frequently and needs to be managed cohesively. - You prefer a modular and structured approach to organizing code.
Use Functional Programming when: - You need a robust system with operations that don’t depend on or alter the state. - Your focus is on the flow of data and transformations applied to it. - You aim for code that’s easy to test and reason about due to its immutability and purity.
Conclusion: Object-oriented programming in JavaScript offers a powerful way to structure and organize code, especially for complex applications. While it differs from functional programming, both paradigms have unique strengths and can even be combined in a single project for different aspects of the application. Understanding both OOP and functional programming will make you a more versatile and effective JavaScript developer.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=e015ea4a3a1b" width="1" height="1" alt="">

OOP in JS With My Understanding

In this article, we will take a look at how to setup an S3 bucket to host a static website using the aws cli. Skip to the bottom of the article if you just want the script.
<h4>AWS CLI</h4>
The AWS Command Line Interface (CLI) lets us manage all of our AWS services from the command line, without having to use the web console. So instead of clicking a bunch of buttons to create a new EC2 instance, you could just run a command like this:
<pre>aws ec2 run-instances --region $region --image-id "ami-0d4504aaac331dc68" --count 1 --instance-type t2.micro --associate-public-ip-address</pre>
<h4>Setup</h4>
If you haven’t setup the AWS CLI already, you can do so using this link: <a href="https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html">https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html</a>
The reference for all of the commands used here is available at <a href="https://docs.aws.amazon.com/cli/latest/reference/">https://docs.aws.amazon.com/cli/latest/reference/</a>
<h4>S3 Static Website</h4>
The steps for hosting a static website using s3 are pretty much the following:
<ol>
<li>Create a new bucket with a unique name</li>
<li>Enable public access to the bucket</li>
<li>Update the bucket policy for public read access:</li>
</ol>
<pre>{ "Version": "2012-10-17", "Statement": [ { "Sid": "PublicReadGetObject", "Effect": "Allow", "Principal": "*", "Action": "s3:GetObject", "Resource": "arn:aws:s3:::acit-3640-fall-2020-40126/*" } ] }</pre>
<ol>
<li>Enable the s3 bucket to host an index and error html page</li>
<li>Upload your website</li>
</ol>
<h3>1. Create a new bucket with a unique name</h3>
<pre>aws s3 mb "s3://your-bucket-name"</pre>
aws s3 mb will create a new bucket. Make sure you change your-bucket-name to something better.
<h3>2. Enable public access to the bucket</h3>
<pre>aws s3api put-public-access-block \ --bucket your-bucket-name \ --public-access-block-configuration "BlockPublicAcls=false,IgnorePublicAcls=false,BlockPublicPolicy=false,RestrictPublicBuckets=false"</pre>
aws s3api put-public-access-block allows you to configure the public access to the bucket. We’re setting all of the blocks to false to enable public access.
<h3>3. Update the bucket policy for public read access:</h3>
<pre>aws s3api put-bucket-policy --bucket your-bucket-name --policy "{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Sid\": \"PublicReadGetObject\", \"Effect\": \"Allow\", \"Principal\": \"*\", \"Action\": \"s3:GetObject\", \"Resource\": \"arn:aws:s3:::your-bucket-name/*\" } ] }"</pre>
aws s3api put-bucket-policy allows us to specify a bucket policy which has to be written in JSON. This policy will allow anyone to get the objects ot of the bucket.
<h3>4. Enable the s3 bucket to host an index and error html page</h3>
<pre>aws s3 website "s3://your-bucket-name" --index-document index.html --error-document index.html</pre>
aws s3 website configures the bucket as a website. We have to include an index and an error page. We could specify a single page for both of these. This is usually what we want for a single page application.
<h3>5. Upload your static website</h3>
<pre>aws s3 sync directory-path "s3://your-bucket-name/"</pre>
aws s3 sync will update the buckets contents with that of the contents of the local directory.
If we want to just copy a single file, we can use aws s3 cp
<pre># Copy a file to an s3 bucket aws s3 cp path-to-file "s3://your-bucket-name/filename"</pre>
<pre># Copy a file from an s3 bucket aws s3 cp "s3://your-bucket-name/filename" path-to-file</pre>
<h3>s3 vs s3api</h3>
s3api gives you complete control of S3 buckets. s3 gives you a higher level of abstraction for some of the more common operations you want to perform on an S3 bucket.
<h4>Single Script</h4>
As a single bash script, this code would look like this. There are a few more variables to make the region and profile easier to configure.
<pre>#!/bin/bash</pre>
<pre>bucket_name='your-bucket-name' website_directory='/path/to/website/'</pre>
<pre>region='us-east-1' profile='default'</pre>
<pre># 1. Create a new bucket with a unique name aws s3 mb \ --profile $profile \ --region $region \ --region us-east-1 "s3://$bucket_name" </pre>
<pre># 2. Enable public access to the bucket aws s3api put-public-access-block \ --profile $profile \ --region $region \ --bucket $bucket_name \ --public-access-block-configuration "BlockPublicAcls=false,IgnorePublicAcls=false,BlockPublicPolicy=false,RestrictPublicBuckets=false"</pre>
<pre># 3. Update the bucket policy for public read access: aws s3api put-bucket-policy \ --profile $profile \ --region $region \ --bucket $bucket_name \ --policy "{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Sid\": \"PublicReadGetObject\", \"Effect\": \"Allow\", \"Principal\": \"*\", \"Action\": \"s3:GetObject\", \"Resource\": \"arn:aws:s3:::$bucket_name/*\" } ] }"</pre>
<pre># 4. Enable the s3 bucket to host an `index` and `error` html page aws s3 website "s3://$bucket_name" \ --profile $profile \ --region $region \ --index-document index.html \ --error-document index.html</pre>
<pre># # 5. Upload you website aws s3 sync \ --profile $profile \ --region $region \ $website_directory "s3://$bucket_name/"</pre>
Once the bucket is created, you only need to run the sync code to push new updates:
<pre>#!/bin/bash</pre>
<pre>bucket_name='your-bucket-name' website_directory='/path/to/website/'</pre>
<pre>region='us-east-1' profile='default' </pre>
<pre>aws s3 sync \ --profile $profile \ --region $region \ $website_directory "s3://$bucket_name/"</pre>
And if you ever want to completely destroy the bucket:
<pre>#!/bin/bash</pre>
<pre>bucket_name='your-bucket-name' website_directory='/path/to/website/'</pre>
<pre>region='us-east-1' profile='default' </pre>
<pre>aws s3 rm \ --profile $profile \ --region $region \ --recursive s3://$bucket_name aws s3api delete-bucket \ --profile $profile \ --region $region \ --bucket $bucket_name</pre>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=affbb9f8f330" width="1" height="1" alt="">

AWS CLI | Setup an S3 Static Website

Attributes and properties are fundamentally different things. You can have an attribute and property of the same name set to different values. For example:
<pre>&lt;div foo="bar"&gt;…&lt;/div&gt; &lt;script&gt; const div = document.querySelector('div[foo=bar]'); console.log(div.getAttribute('foo')); // 'bar' console.log(div.foo); // undefined div.foo = 'hello world'; console.log(div.getAttribute('foo')); // 'bar' console.log(div.foo); // 'hello world' &lt;/script&gt;</pre>
It seems like fewer and fewer developers know this, partially thanks to frameworks:
<pre>&lt;input className="…" type="…" aria-label="…" value="…" /&gt;</pre>
If you do the above in a framework’s templating language, you’re using attribute-like syntax, but under the hood it’ll sometimes be setting the property instead, and when it does that differs from framework to framework. In some cases, it’ll set a property and an attribute as a side-effect, but that isn’t the framework’s fault.
Most of the time, these distinctions don’t matter. I think it’s good that developers can have a long and happy career without caring about the differences between properties and attributes. But, if you need to dig down into the DOM at a lower level, it helps to know. Even if you feel you know the difference, maybe I’ll touch on a couple of details you hadn’t considered. So let’s dig in…
<h3>The key differences</h3>
Before we get to the interesting stuff, let’s get some of the technical differences out of the way:
<h4>HTML serialisation</h4>
Attributes serialise to HTML, whereas properties don’t:
<pre>const div = document.createElement('div');</pre>
<pre>div.setAttribute('foo', 'bar'); div.hello = 'world';</pre>
<pre>console.log(div.outerHTML); // '&lt;div foo="bar"&gt;&lt;/div&gt;'</pre>
So when you’re looking at the elements panel in browser developer tools, you’re only seeing attributes on elements, not properties.
<h4>Value types</h4>
In order to work in the serialised format, attribute values are always strings, whereas properties can be any type:
<pre>const div = document.createElement('div'); const obj = { foo: 'bar' };</pre>
<pre>div.setAttribute('foo', obj); console.log(typeof div.getAttribute('foo')); // 'string' console.log(div.getAttribute('foo')); // '[object Object]'</pre>
<pre>div.hello = obj; console.log(typeof div.hello); // 'object' console.log(div.hello); // { foo: 'bar' }</pre>
<h4>Case sensitivity</h4>
Attribute names are case-insensitive, whereas property names are case-sensitive.
<pre>&lt;div id="test" HeLlO="world"&gt;&lt;/div&gt; &lt;script&gt; const div = document.querySelector('#test');</pre>
<pre> console.log(div.getAttributeNames()); // ['id', 'hello']</pre>
<pre> div.setAttribute('FOO', 'bar'); console.log(div.getAttributeNames()); // ['id', 'hello', 'foo']</pre>
<pre> div.TeSt = 'value'; console.log(div.TeSt); // 'value' console.log(div.test); // undefined &lt;/script&gt;</pre>
However, attribute values are case-sensitive.
Ok, here’s where things start to get blurry:
<h3>Reflection</h3>
Take a look at this:
<pre>&lt;div id="foo"&gt;&lt;/div&gt; &lt;script&gt; const div = document.querySelector('#foo');</pre>
<pre> console.log(div.getAttribute('id')); // 'foo' console.log(div.id); // 'foo'</pre>
<pre> div.id = 'bar';</pre>
<pre> console.log(div.getAttribute('id')); // 'bar' console.log(div.id); // 'bar' &lt;/script&gt;</pre>
This seems to contradict the first example in the post, but the above only works because Element has an id getter &amp; setter that 'reflects' the id attribute.
When a property reflects an attribute, the attribute is the source of the data. When you set the property, it’s updating the attribute. When you read from the property, it’s reading the attribute.
For convenience, most specs will create a property equivalent for every defined attribute. It didn’t work in the example at the start of the article, because foo isn't a spec-defined attribute, so there isn't a spec-defined foo property that reflects it.
Here’s the spec for &lt;ol&gt;. The "Content attributes" section defines the attributes, and the "DOM interface" defines the properties. If you click on reversed in the DOM interface, it takes you to this:
<blockquote>
The reversed and type IDL attributes must <a href="https://html.spec.whatwg.org/multipage/common-dom-interfaces.html#reflect">reflect</a> the respective content attributes of the same name.
</blockquote>
But some reflectors are more complex…
<h4>Naming differences</h4>
Ok, this is relatively minor, but sometimes the property has a different name to the attribute it reflects.
In some cases it’s just to add the kind of casing you’d expect from a property:
<ul>
<li>On &lt;img&gt;, el.crossOrigin reflects the crossorigin attribute.</li>
<li>On all elements, el.ariaLabel reflects the aria-label attribute (the aria reflectors became cross browser in late 2023. Before that you could only use the attributes).</li>
</ul>
In some cases, names had to be changed due to old JavaScript reserved words:
<ul>
<li>On all elements, el.className reflects the class attribute.</li>
<li>On &lt;label&gt;, el.htmlFor reflects the for attribute.</li>
</ul>
<h4>Validation, type coercion, and defaults</h4>
Properties come with validation and defaults, whereas attributes don’t:
<pre>const input = document.createElement('input');</pre>
<pre>console.log(input.getAttribute('type')); // null console.log(input.type); // 'text'</pre>
<pre>input.type = 'number';</pre>
<pre>console.log(input.getAttribute('type')); // 'number' console.log(input.type); // 'number'</pre>
<pre>input.type = 'foo';</pre>
<pre>console.log(input.getAttribute('type')); // 'foo' console.log(input.type); // 'text'</pre>
In this case, the validation is handled by the type getter. The setter allowed the invalid value 'foo', but when the getter saw the invalid value, or no value, it returned 'text'.
Some properties perform type coercion:
<pre>&lt;details open&gt;…&lt;/details&gt; &lt;script&gt; const details = document.querySelector('details');</pre>
<pre> console.log(details.getAttribute('open')); // '' console.log(details.open); // true</pre>
<pre> details.open = false;</pre>
<pre> console.log(details.getAttribute('open')); // null console.log(details.open); // false</pre>
<pre> details.open = 'hello';</pre>
<pre> console.log(details.getAttribute('open')); // '' console.log(details.open); // true &lt;/script&gt;</pre>
In this case, the open property is a boolean, returning whether the attribute exists. The setter also coerces the type - even though the setter is given 'hello', it's turned to a boolean rather than going directly to the attribute.
Properties like img.height coerce the attribute value to a number. The setter converts the incoming value to a number, and treats negative values as 0.
<h4>value on input fields</h4>
value is a fun one. There's a value property and a value attribute. However, the valueproperty does not reflect the value attribute. Instead, the defaultValue property reflects the value attribute.
I know, I know.
In fact, the value property doesn't reflect any attribute. That isn't unusual, there's loads of these (offsetWidth, parentNode, indeterminate on checkboxes for some reason, and many more).
Initially, the value property defers to the defaultValue property. Then, once the valueproperty is set, either via JavaScript or through user interaction, it switches to an internal value. It's as if it's implemented roughly like this:
<pre>class HTMLInputElement extends HTMLElement { get defaultValue() { return this.getAttribute('value') ?? ''; }</pre>
<pre> set defaultValue(newValue) { this.setAttribute('value', String(newValue)); }</pre>
<pre> #value = undefined;</pre>
<pre> get value() { return this.#value ?? this.defaultValue; }</pre>
<pre> set value(newValue) { this.#value = String(newValue); }</pre>
<pre> // This happens when the associated form resets formResetCallback() { this.#value = undefined; } }</pre>
So:
<pre>&lt;input type="text" value="default" /&gt; &lt;script&gt; const input = document.querySelector('input');</pre>
<pre> console.log(input.getAttribute('value')); // 'default' console.log(input.value); // 'default' console.log(input.defaultValue); // 'default'</pre>
<pre> input.defaultValue = 'new default';</pre>
<pre> console.log(input.getAttribute('value')); // 'new default' console.log(input.value); // 'new default' console.log(input.defaultValue); // 'new default'</pre>
<pre> // Here comes the mode switch: input.value = 'hello!';</pre>
<pre> console.log(input.getAttribute('value')); // 'new default' console.log(input.value); // 'hello!' console.log(input.defaultValue); // 'new default'</pre>
<pre> input.setAttribute('value', 'another new default');</pre>
<pre> console.log(input.getAttribute('value')); // 'another new default' console.log(input.value); // 'hello!' console.log(input.defaultValue); // 'another new default' &lt;/script&gt;</pre>
This would have made way more sense if the value attribute was named defaultvalue. Too late now.
<h3>How frameworks handle the difference</h3>
Back to the example from earlier:
<pre>&lt;input className="…" type="…" aria-label="…" value="…" /&gt;</pre>
How do frameworks handle this?
<h4>REACT</h4>
React does things the other way around. Aside from a predefined set of cases where they favour properties, they’ll set an attribute. This makes their render-to-string method similar in logic.
This explains why custom elements don’t seem to work in React. Since they’re custom, their properties aren’t in React’s ‘predefined list’, so they’re set as attributes instead. Anything that’s property-only on the custom element simply won’t work. This will be fixed in React 19, where they’ll switch to the Preact/VueJS model for custom elements.
The funny thing is, React popularised using className instead of class in what looks like an attribute. But, even though you're using the property name rather than the attribute name, <a href="https://github.com/facebook/react/blob/699d03ce1a175442fe3443e1d1bed14f14e9c197/packages/react-dom-bindings/src/client/ReactDOMComponent.js#L388-L389">React will set the </a><a href="https://github.com/facebook/react/blob/699d03ce1a175442fe3443e1d1bed14f14e9c197/packages/react-dom-bindings/src/client/ReactDOMComponent.js#L388-L389">class attribute under the hood</a>.
<ul><li>
<a href="https://github.com/facebook/react/blob/699d03ce1a175442fe3443e1d1bed14f14e9c197/packages/react-dom-bindings/src/client/ReactDOMComponent.js#L349">setProp in React</a>.</li></ul>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=20d1a10ec2f3" width="1" height="1" alt="">

Jamshid

Makhmudov

Software Engineer

What i do.

Places i’ve worked.

Some of my works.

Medium blog

Understanding Inversion of Control (IoC) and Its Implementation in NestJS

ioc, dependency-injection, ioc-container, nestjs

2025-03-03

PostgreSQL Domain Types and Enums

enum, postgresql, domain-type

2025-01-31

PostgreSql Exclusion Constraints

2025-01-31

How to tune PostgresSql performance?

2025-01-29

My Journey