DEV Community: NightBird07

[Boost]

NightBird07 — Sun, 11 Jan 2026 20:56:37 +0000

NightBird07

Apr 29 '25

Rediscovering the Joy of Software through Open Source

#webdev #programming #beginners #ai

Comments

3 min read

Rediscovering the Joy of Software through Open Source

NightBird07 — Tue, 29 Apr 2025 06:30:27 +0000

In the rapidly evolving world of AI, it often feels like everything is getting blurred—students are losing their focus, and with it, the joy that comes from the journey of failing and eventually succeeding. Not long ago, the path to becoming a better software developer was clearer: curated roadmaps, classic recommended books, structured learning approaches. But now, the global focus has shifted. The fear of being replaced by AI overshadows the intrinsic motivation to improve.

Let us remind ourselves: the purpose of AI is not to instill fear, but to inspire us to become even better. Today, I want to talk about something we all crave but sometimes lose sight of—the joy of building, the feeling of proficiency, and how open source can reignite that passion.

Open Source is Difficult—And That’s the Point

No one can deny it: open source projects are hard. Behind every repository is often a masterpiece that took years of iterations, architecture decisions, rewrites, and community collaboration. These projects aren’t always straightforward. Sometimes they diverge from common patterns to prioritize clarity or performance. You might ask:

If open source is so difficult, what can I possibly do about it?

To answer that, let me tell you a personal story.

My Journey: Reinventing the Wheel and Hitting Walls

I love recreational programming—which for me means reinventing the wheel. It’s my way of learning deeply. One day, I challenged myself to build a torrent client. Things were going well until performance issues emerged. My application couldn't keep up. So I ventured into multithreading with Go, revisiting multiple chapters from Concurrency in Go to refresh patterns and avoid common pitfalls.

Yet, my program remained sluggish. That’s when I turned to open source—not to copy, but to observe and compare. How did others do it? Could the problem I’m facing already be solved elsewhere?

Open Source Saved Me

I was lucky. I found an actively maintained torrent client written in Go. As I dove into the codebase, something clicked. I could actually understand it. Not every single line, of course—but I saw the reasoning behind the structure, the flow, the function choices. It was like reading a story you’ve already tried to write.

That’s when I realized: this is the entry point to building anything.

The New Workflow: Build, Test, Read Open Source

Here’s my new mindset:

Build something yourself
Test it thoroughly and reflect
Then read open source projects doing the same thing

By the time you reach step 3, you’re no longer a passive reader. You’re an explorer. You’ve felt the pain, made the mistakes, and you’re equipped to understand what you're reading.

This approach can be summarized as:

Step	Description
1	Become the user of the system
2	Make mistakes — even be overly critical if needed
3	Manually write as much code as possible before automation

Open Source is Still Difficult—But Now It’s Worth It

Even after these steps, you’re not guaranteed access to the inner circle of any project. But you will gain a faster, smoother understanding of codebases and architecture. You will be able to make meaningful pull requests, open thoughtful issues, and join discussions.

As a student, you might not always have access to a senior developer or mentor. So create your own path:

Be curious
Think deeply and patiently
Allow yourself to fail multiple times
Reach the point of giving up, then try again

Finally, read the solution in open source. You’ll think:

"Wait, I did this too!"

And that moment of self-validation is powerful. It keeps you going.

Tools That Still Matter (Even in the Age of AI)

Many tools are no longer talked about because of the AI boom, but those who truly value open source and learning still use them:

Awesome for Beginners — curated beginner-friendly projects
CodeTriage — get issues from real projects in your inbox
Up for Grabs — discover issues tagged as good first contributions

In conclusion, open source isn’t just code—it’s a conversation, a mirror, and sometimes even a mentor. You don’t have to wait for permission to get involved. Start by building, keep failing, and then read the source code of those who walked the path before you.

That's how we rediscover joy in this AI-driven era.

Build something. Break it. Then see how others fixed it.

Index Optimization in Database Query Performance: Guidelines and Real-world Examples

NightBird07 — Mon, 11 Sep 2023 18:59:56 +0000

Don’t get too smug with your current level after reading a ton of articles (especially, mine) because today, I am going to throw some curveballs at you and if you can hit them all, then you are truly a geek and you deserve a party popper. In the world of database query optimization, the choice of indexes can make or break your queries. This article reveals the secrets of picking and tweaking indexes, supported by real-world examples. We’ll talk about situations where the right index can make your query fly and when it might need a makeover.

Recap on Index Optimization:

And I know you are looking for a cheat sheet, so here is one that could jog your truly brilliant memory when you were diligent. Here’s a crisp recap of key index concepts that can help you nail the questions:

Single-Column Indexes: An index on a single column is effective for filtering data based on that column's values. For example, creating an index on a date_column with the current data-- case sensitive,can accelerate queries that involve date-based filtering.
Multi-Column Indexes: In scenarios where queries involve filtering by multiple columns or sorting by one column, a multi-column index can be advantageous. It optimizes both filtering and sorting operations. For instance, an index on (a, date_column) works well when filtering by a and sorting by date_column(ordere matters).
Multi-Purpose Indexes: Sometimes, a single index can serve multiple query patterns. If you have queries filtering by different combinations of columns, a multi-column index that covers all relevant columns, such as (a, b), can be beneficial for optimizing these queries.
Pattern Search Indexes: When performing text pattern searches, consider using specialized index types like varchar_pattern_ops. These indexes are tailored for efficient pattern matching, as seen in the 'text LIKE' query.
Impact of Conditions: Introducing additional conditions to a query can affect its performance. Whether it makes the query slower, faster, or keeps it the same depends on the specific data and query. Evaluating these changes is essential for efficient indexing.

for each question you have to choose
1- Good Fit
2- Bad Fit -- could be optimized.

Question1

CREATE INDEX first_name_index ON employee(first_name)

SELECT COUNT(*)
FROM employee 
WHERE UPPER(first_name) = 'GORG';

Question 2

CREATE INDEX name_index ON employee(first_name,last_name)

SELECT first_name, last_name FROM employee
WHERE last_name = 'OoPs'
ORDER BY first_name DESC
FETCH FIRST 2 ROW ONLY

Question 3

CREATE INDEX name_index ON employee(first_name,last_name)

SELECT first_name, last_name FROM employee
WHERE last_name = 'OoPs'
AND first_name = 'Hahah'

SELECT first_name, last_name FROM employee
WHERE last_name = 'OoPs'

Question 4

CREATE INDEX notes_index ON employee(notes text_pattern_ops)

SELECT notes FROM employee 
WHERE notes LIKE 'late%'

Tips

1- Indexes can only be used from left to right side. If the first index column is not in the where clause, the index is of little help.
2- Use an index-only scan for queries that access many rows but only a few columns.
Avoid select * to increase chances for an index-only scan.

please, refer to the comment section to see the answer and rate yourself and don't forget to give yourself a Confetti.

Nulls are equal in distinct but inequal in unique.

NightBird07 — Tue, 29 Aug 2023 11:27:57 +0000

While developing ETL pipelines for a new data warehouse, I encountered unexpected query results related to NULL values. This prompted me to delve into the underlying SQL behavior to better understand the discrepancy. In this article, I aim to elucidate the contrasting treatment of NULLs by the DISTINCT and UNIQUE keywords. I'll present examples based on my analysis of the data warehouse.

DISTINCT: Treating Null as Equivalence

When I sought to explore the categories or ranges of values within a specific column—let's say the "jobs" column—the initial result appeared as follows:

[doctor, engineer, ..., null]

This outcome raised a question: Does this mean that there is only a single NULL value? My previous understanding of PostgreSQL led me to believe that NULL values are treated as distinct. However, when I meticulously counted the occurrences of NULL values in the "jobs" column using the query:

SELECT COUNT(*) as nulljobs FROM jobs WHERE jobs IS NULL;

The result unveiled a surprising 140 rows containing NULL values. It seemed that DISTINCT treated NULL values as equivalent. There could be a reasonable explanation for this behavior. The DISTINCT operation is typically employed for visualization or categorization purposes. Hence, treating NULLs as distinct might not make practical sense. However, this raises the question of why NULLs are treated as distinct values in the first place.

This treatment is rooted in the concept of Three-Valued Logic (3VL), which consists of true, false, and unknown. Crucially, "unknown" is not equal to "unknown" in this context. Keep in mind that the comparison "unknown != unknown" doesn't hold. To shed light on this, consider that infinity + infinity equals infinity. This implies that unknown values can be aggregated into a single value or category.

UNIQUE Constraints: Ensuring Uniqueness Among Columns

The behavior of NULL values under the UNIQUE constraint in PostgreSQL introduces interesting nuances. UNIQUE constraints are particularly tailored for use with partial indexes. In this specific context, the interpretation of NULL values differs significantly. Rather than serving as indicators of mean or central tendencies, NULL values under UNIQUE constraints embody the distinctiveness of other non-null values within a row. As a result, UNIQUE constraints do not revolve around the treatment of NULL values in isolation. Instead, they focus on preserving distinctions among values contained within individual rows.

To illustrate this point further, let's consider a practical scenario involving a PostgreSQL database:

Suppose we have a table named "employees" with columns "employee_id" and "email." We want to ensure that each email address in the "email" column is unique. However, NULL values should not interfere with this uniqueness requirement.

CREATE TABLE employees (
    employee_id serial PRIMARY KEY,
    email VARCHAR(255) UNIQUE
);
-- Create a partial index to enforce uniqueness among non-null ids
CREATE UNIQUE INDEX unique_email
    ON employees (email)
    WHERE email IS NOT NULL;

In this case, PostgreSQL will enforce the UNIQUE constraint on the "email" column, allowing multiple NULL values. This aligns with the concept that the UNIQUE constraint is chiefly concerned with maintaining the distinctiveness of non-null values.

For instance, the following insertions are valid:

-- Valid insertions
INSERT INTO employees (email) VALUES ('john@example.com');
INSERT INTO employees (email) VALUES ('mary@example.com');
INSERT INTO employees (email) VALUES (NULL);

However, attempting to insert duplicate non-null values would result in a violation of the UNIQUE constraint:

-- Invalid insertion due to violation of UNIQUE constraint
INSERT INTO employees (email) VALUES ('john@example.com');

when you SELECT some info using the partial index already made with EXPLAIN it is performing an index scan.

EXPLAIN SELECT * FROM employees WHERE email IS NOT NULL;

Summary and Conclusion

DISTINCT allows duplicate NULLs in the result set, as it considers NULLs as distinct values that represent unknown or missing data. This behavior is based on the three-valued logic of SQL, where unknown is not equal to unknown.
UNIQUE constraints treat NULLs as equal, as they enforce uniqueness among non-null values in a column or a set of columns. This behavior is useful for creating partial indexes that exclude NULL values from the index.
The difference between DISTINCT and UNIQUE has an impact on the query performance and data integrity, as it affects how the data is filtered, sorted, and indexed. Developers should be aware of this difference and use appropriate techniques to handle NULL values in their queries.

PostgreSQL Optimization: A Quick Tip on Using Values Expression

NightBird07 — Sun, 13 Aug 2023 11:50:18 +0000

I have been working with a database that contains thousands of clusters of women, each identified by a UUID. The challenge arises when implementing a clustering algorithm that involves determining if a new cluster exists within a larger cluster. Traditionally, achieving this might necessitate iterative loops in programming languages like Python, adding complexity to the codebase.

Leveraging SQL Power

Instead of resorting to external looping mechanisms, PostgreSQL provides a more streamlined approach using SQL itself. The IN keyword, widely used to filter results, can be used to solve this clustering dilemma. For instance:

SELECT * 
FROM clusters
WHERE cluster_id IN (... over 9000 IDs ...)

However, let's explore an even more efficient way to accomplish this using the values expression and the ANY operator. This technique can yield performance improvements and optimize query execution plans.

The Values Expression and ANY Operator

The values expression constructs a temporary table from a list of expressions, while the ANY operator evaluates if a value is equal to any element within an array or set. Integrating these constructs, the query can be reimagined as:

SELECT * 
FROM clusters
WHERE cluster_id = ANY (VALUES (100), (101), ...)

Surprisingly, this seemingly straightforward alteration can lead to a different and more efficient query execution plan. The database optimizer might choose to employ hash aggregation over values scanning and, potentially, hash joins when dealing with a substantial number of rows.

Impact on Performance

At first glance, this query rewrite might appear counterintuitive. However, its effect on performance can be profound, contingent on the underlying context. If the query planner orchestrates the values scan after completing all joins, it could lead to undesirable consequences. On the flip side, when the planner optimally schedules execution, query performance can experience a remarkable boost. In certain cases, this optimization technique has resulted in up to 100 times faster query execution – a substantial gain that can outweigh the perceived risk.

It's crucial to note that the sequence of execution within the database is determined by the planner's internal tree structure. Generally, joins are prioritized over the WHERE clause, prompting their execution before filtering with the WHERE condition. If you're interested in modifying this behavior, PostgreSQL offers hints to guide query optimization. However, the detailed exploration of hints falls beyond the scope of this article.

Conclusion

In the realm of database optimization, the PostgreSQL database system never ceases to amaze with its wealth of features. This quick tip of utilizing the values expression and ANY operator for enhancing clustering queries showcases how intricate optimizations can lead to remarkable performance gains. While the impact of this technique might vary depending on the specific use case, its potential to dramatically accelerate query execution makes it an invaluable tool in the database optimization toolkit.

C has some API

NightBird07 — Sun, 06 Aug 2023 15:07:47 +0000

I took part in a contest that challenged me to write a very large and complex file. After finishing the first phase, I had to refine my code. I faced a problem with modularity design, which is how to split my code into smaller and simpler modules that use memory effectively. Before I go into more detail about this concept, let me explain some terms that you might need to know.

Memory management is an important aspect of programming, as it affects how well a program can use the available memory resources. Memory management involves allocating, using, and freeing memory for different purposes, such as storing data, executing code, and communicating between processes.

In this article, we will compare two memory management techniques: extern and shared memory. Extern is a keyword that allows a program to access a global variable or a function that is defined in another file. Shared memory is a mechanism that allows multiple processes to access the same memory region for inter-process communication.

Extern:

The “extern” keyword is used in programming languages like C and C++ to declare variables or functions that are defined in other files. When a variable or function is declared as “extern,” it means that its definition can be found in another file within the project. The purpose of using “extern” is to provide a forward declaration so that the compiler knows that the variable or function exists and can be used, even though its definition is located elsewhere.

Using the “extern” keyword allows for variable sharing across files in a project. For example, if you have a variable defined in one source file and you want to access it in another source file, you can declare it as “extern” in the second file. This tells the compiler that the variable is defined in a different file and should be linked appropriately during the compilation process. By using “extern,” you can share variables and functions across multiple files, enabling modular programming and code reuse.

Shared Memory:

Shared memory refers to a region of memory that can be accessed by multiple processes or threads simultaneously. In concurrent programming and inter-process communication (IPC), shared memory is used to exchange data between processes efficiently. Instead of using message passing or other forms of communication, processes can directly read from and write to the shared memory region.

both are the same

though you may conclude that the extern is a safe API to use shared memory with restrict constraints on how to use the extern.

When to Use "Extern":

Use "extern" when sharing variables within a single program, especially when the data needs to be accessed by multiple source files.
It simplifies data sharing and ensures consistency by using a single instance of the variable throughout the program.
"Extern" is suitable for scenarios where multiple components of the program need access to common data without creating separate copies.

When to Use Shared Memory:

Use shared memory when communication is required between independent processes running on the same machine.
It enables data exchange and cooperation between separate programs by allowing them to access and share a common memory space.
Shared memory is beneficial in scenarios where inter-process communication is needed for tasks like data exchange, coordination, or parallel processing.

Final Thoughts and Recommendations:

Both "extern" and shared memory serve important roles in different scenarios. Choose "extern" when focusing on data sharing within a single program to improve code modularity and efficiency.
On the other hand, opt for shared memory when dealing with inter-process communication and cooperation between independent processes.
Understanding the distinctions between these mechanisms will help developers make informed decisions about which approach to employ based on the specific requirements of their projects.

Why Valgrind is a Better Tool for Detecting Memory Leaks than Leak in macOS

NightBird07 — Sat, 22 Jul 2023 13:22:36 +0000

Memory leaks are a common source of bugs and crashes in C/C++ programs. Detecting memory leaks during development is critical, and two main options for memory leak detection on older macOS versions (macOS 10.x) are Valgrind and Leak Sanitizer.

Valgrind:

Valgrind is an open-source debugging and profiling tool for Linux, macOS, and Unix-like systems.
It uses dynamic binary instrumentation to monitor programs at runtime.
Valgrind can perform a range of memory debugging tasks, including detecting memory leaks, reads of uninitialized memory, double frees, and more.

Example:

Here is a simple C++ program that leaks memory:

#include <iostream>

int main() {
    int* x = new int;
    std::cout << *x;
    // x is leaked here
}

When running this program through Valgrind, it generates the following leak report:

==123== 4 bytes in 1 blocks are definitely lost in loss record 1 of 1
==123== at 0x100000F3F: operator new(unsigned long) (in /usr/lib/libc++abi.dylib)
==123== by 0x100000DEA: main (main.cpp:4)

Valgrind accurately pinpoints the source of the leak at line 4 and provides the allocation size.

End of Example

Valgrind provides extensive memory usage information, including detailed call stacks for leaked allocations.
One of the key advantages of Valgrind is that it works on existing executables without recompiling the source code.

Leak Sanitizer:

Leak Sanitizer is part of the Address Sanitizer feature in LLVM compiler infrastructure.
It is enabled by building programs with the -fsanitize=address option.

Example:

To enable Leak Sanitizer for the previous example, you would compile it with the following command:

clang++ -fsanitize=address -g -o my_program my_program.cpp

When running the program, Leak Sanitizer would provide a report similar to the following:

LeakSanitizer: detected memory leaks
Direct leak of 4 byte(s) in 1 object(s) allocated from:
#0 0x7fff8939066f in operator new(unsigned long) ../.././libc++abi.dylib (inline)
#1 0x100000dea8 in main main.cpp:4
#2 0x7fff50bbcdc9 in start (libdyld.dylib)

SUMMARY: LeakSanitizer: 4 byte(s) leaked in 1 allocation(s).

End of Example

Leak Sanitizer tracks memory allocation and release during program execution.
It provides basic memory leak reports at process exit, including memory ranges of leaks.
Leak Sanitizer has lower runtime overhead compared to Valgrind, resulting in faster program execution.

Why Valgrind is Better for Memory Leak Detection on macOS 10.x:

Valgrind provides more detailed memory information, including exact stack traces and allocation sizes.
It supports memory profiling, allowing analysis of overall memory usage and identification of other issues.
Valgrind actively tracks memory state during execution, catching issues more accurately.
Valgrind integrates well with debugging tools like GDB for easy inspection of issues.

The main downside of Valgrind is its performance overhead, as programs run slower under Valgrind. However, its rich analysis capabilities usually make this tradeoff worthwhile, especially during active development. For longer runs or production profiling, Leak Sanitizer can complement Valgrind to reduce performance impact. Overall, Valgrind remains the better choice for detailed memory debugging on older macOS versions.

My Journey in Bitcoin Summer Code of Camp: Lessons Learned

NightBird07 — Wed, 12 Jul 2023 12:36:32 +0000

As a participant in the Bitcoin Summer Code of Camp, I faced several challenges that I would like to share with others who may be going through similar experiences. Here are some bullet points that summarize what I learned:

Talk to elders in the same project: While it may seem obvious, you won't have a good idea about the project until you read the documentation and talk to people who have experience with it. Don't be afraid to reach out to seniors and ask questions.
Ask for evaluation: Some seniors can help you find the right spot that matches your current skills. Don't be afraid to ask for feedback on your progress and how you can improve.
Don't be discouraged if you don't know the technology: Learning a new technology is not the main problem. The challenge is how to apply the technology to the project. Focus on understanding the project requirements and how the technology can help you achieve the project goals.
Take your time: Some developers have been watching or working with the company for months, waiting for their chance to participate. You may feel like you're late to the game, but don't rush. Take your time to understand the project, learn the technology, and contribute in a meaningful way.
Participate in hackathons for more challenging projects and new stacks: Hackathons help you get fast and act in a very efficient way to learn. They do have labels for the requirements, current skill level needed, etc., which helps you decide if you are ready for this.

Websites for hackathons: Here are some websites for hackathons that you can check out:

Devpost
HackerEarth
AngelHack

Join open source projects: AGE is also an open source project. If you have any questions or facing any challenges, they provide a very interactive environment for contributors. Don't hesitate to message me if you need any help.
Overall, my experience in the Bitcoin Summer Code of Camp was challenging but rewarding. By following these lessons learned,
I was able to contribute to the project and improve my skills. Good luck to anyone else who is embarking on a similar journey!

Why You should Start Contributing to OpenSource

NightBird07 — Sun, 09 Jul 2023 11:38:12 +0000

My journey in the world of open source projects began last summer when I decided to dive into the Bitcoin project. However, I quickly realized that navigating through the vast amount of resources available was quite overwhelming. In this article, I will share some simple ways to overcome this challenge and provide insights on why you should start contributing to open source projects.

Firstly, it's important to note that not all open source projects require contributions from regular contributors. Some projects are developed and maintained by a core team, while others actively seek contributions from the community. Before diving into a project, it's essential to understand the project's goals, development process, and whether they encourage community contributions.

One interesting aspect of contributing to open source projects is the opportunity to refactor code written by others. While we often hear about the importance of refactoring our own code, exploring and improving someone else's code can be equally intriguing. It allows us to analyze different coding styles, thought processes, and approaches to problem-solving. Open source projects offer a chance to engage with code written by talented developers and learn from their expertise.

When you dive into the world of open source, you'll encounter a diverse range of projects. To get started, it's helpful to narrow down your search by identifying specific open source projects that align with your interests and skills. One of the best platforms to discover open source projects is GitHub, which hosts a vast amount of public code repositories. You can browse through different projects, explore their issues and discussions, and find opportunities to contribute.

If you're unsure where to begin, websites like Up For Grabs can be valuable resources. They curate lists of open source projects that actively seek contributions, making it easier for you to find projects that are suitable for your skills and interests. These platforms provide a starting point for your research and help you navigate the vast space of open source projects.

now, what you are waiting for check the AGE and pull some requests.

Exploring the Limitations of Postgres Partitioning: Lessons Learned and Best Practices

NightBird07 — Sat, 01 Jul 2023 10:51:52 +0000

Postgres partitioning is a popular technique for horizontally slicing large tables into multiple partitions, offering improved query performance and data management. However, it's crucial to understand the limitations and potential pitfalls associated with this approach to avoid performance degradation, application retries, and failures. In this post, we'll delve into the experiences of implementing Postgres partitioning, the challenges faced, and recommended best practices to mitigate these issues.

Understanding the Limitations:

Performance Degradation: Partitioning can lead to a spike in lock manager waits and negatively impact user query performance. An increase in the number of smaller tables, along with multiple indexes and partitions, can generate a significant number of locks per query, causing contention problems.

Challenges Faced:

Backend Struggles: The implementation of partitioning can strain the backend system, particularly when each partition has numerous indexes. The creation of new backend processes for each connection and conflicts arising from lock acquisitions can overwhelm the database, leading to performance issues.

Identifying Key Issues:

Lock Manager Weight: The lock manager becomes burdened with managing the large number of logs created during the partitioning process, resulting in expensive operations and contention problems. This can severely impact query performance and overall system stability.

Best Practices and Solutions:

** Fast Path Locking ** : Be cautious when dealing with a large number of partitions as fast path locking, which relies on an in-memory data structure, has a limited number of locks (16) and can lead to contention issues. Consider using fewer, larger partitions to alleviate contention and ensure smooth operation, especially in long transactions.

Dropping Indexes and Detaching Partitions: Dropping indexes can cause locking contention, while detaching partitions can acquire access exclusive locks, blocking other operations. Upgrade to Postgres version 14 or later, which introduces the "detach concurrently" feature to address these issues.

Postgres Version Upgrade: Upgrading to version 14 offers improved handling of locks by placing soft locks on specific partitions being queried. It provides a solution for complex locking scenarios, enhancing overall performance and management of partitioned tables.

Conclusion:

While Postgres partitioning offers benefits in terms of data management and query optimization, it is crucial to be aware of its limitations and potential challenges. By understanding the intricacies of lock management, fast path locking, and leveraging the advancements in newer Postgres versions, developers can implement partitioning effectively and ensure smooth system operation.

you can watch a whole video HERE it is highly recommended
and even further you can read from this article HERE

Start Using Yaml Files

NightBird07 — Thu, 22 Jun 2023 15:30:44 +0000

Yaml stands for "YAML Ain't Markup Language". It is a human-readable data serialization language that is commonly used to describe configuration files. Some of the benefits of using Yaml are:

Easy to read: Yaml files are easy to read and edit by humans. They use indentation instead of brackets, and colons and dashes instead of equal signs.

Flexible: Yaml supports lists, objects, strings, booleans, integers, floats, null. It can represent complex data structures in a clean format.

Language independent: Yaml files can be parsed and emitted by programs written in any language.

Configuration files: Yaml is a popular format for configuration files. Many applications like Kubernetes, Ansible, and Github Actions use Yaml for their config files.

Model libraries and UML diagrams: Because Yaml has a simple syntax and can represent complex data structures, it is useful for modeling libraries, architectures, and even UML diagrams. The indentation and formatting make the models very readable.

and here is my journey of living with one of the huge libraries ever. Libpg.h though the header file of the libPg is enough to see the available procedures but still you need to give more hints and make it easier to recap the functionality or notes for a specific function.
I started to write YAML files for each function and then connected these files in a UML representation you can actually do similar thing in your local machine with yml2dot and then olaaa you got a visualization of your documentation.

A Deep Dive into EDB Postgres Advanced Server: Features and Benefits

NightBird07 — Tue, 13 Jun 2023 10:13:37 +0000

EnterpriseDB's Postgres Advanced Server (EPAS) is a powerful, Oracle-compatible database management system built on the robust foundation of PostgreSQL. As organizations increasingly seek cost-effective and open-source alternatives to traditional proprietary databases, EPAS has emerged as a popular choice. In this article, we'll take a deep dive into the features and benefits that set EPAS apart from its competitors.

Oracle Compatibility

One of the most notable features of EPAS is its extensive Oracle compatibility. This allows organizations to migrate from Oracle databases to EPAS with minimal disruption to their existing applications and processes. Key Oracle compatibility features include:

PL/SQL support: EPAS includes a comprehensive implementation of PL/SQL, Oracle's procedural language for SQL. This enables developers to use their existing PL/SQL code with minimal changes when migrating to EPAS.
Oracle-style packages: Packages are a key feature of Oracle's PL/SQL language, allowing developers to group related procedures and functions into a single, reusable module. EPAS supports the use of Oracle-style packages, simplifying the migration process.
Oracle data types: EPAS supports a range of Oracle-specific data types, such as NUMBER, VARCHAR2, and DATE. This reduces the need for code changes when migrating from Oracle databases.
EDB Migration Toolkit: This toolkit simplifies the process of migrating Oracle databases to EPAS. It automates the conversion of database schemas, stored procedures, and data, significantly reducing the time and effort required for migration.

Advanced Security

Data security is a top priority for enterprises, and EPAS offers a suite of advanced security features to help protect sensitive information and ensure compliance with regulatory requirements. Key security features include:

Data encryption: EPAS supports Transparent Data Encryption (TDE), which automatically encrypts data at rest, ensuring that sensitive information remains secure.
Row-level security: This feature allows administrators to define security policies based on user roles and privileges, ensuring that users can only access the data they are authorized to see.
Database auditing: EPAS includes comprehensive auditing capabilities, enabling organizations to track and monitor database activity for security, compliance, and performance analysis purposes.

Performance Enhancements

EPAS builds on PostgreSQL's performance capabilities with a range of enhancements designed to improve query execution times and overall system efficiency. These enhancements include:

Index-only scans: EPAS supports index-only scans, a query optimization technique that allows the database engine to retrieve data directly from an index, avoiding the need to access the underlying table. This can significantly improve query performance in certain scenarios.
Parallel query execution: EPAS can execute complex queries in parallel, leveraging multiple CPU cores to process large volumes of data more quickly.
Advanced query optimization: EPAS includes an enhanced query optimizer, which uses sophisticated algorithms to determine the most efficient way to execute a given SQL query.

Scalability and High Availability

As organizations grow and their data requirements expand, the ability to scale databases efficiently becomes increasingly important. EPAS offers several features designed to support scalability and high availability, including:

EDB Postgres Replication Server: This tool enables organizations to set up replication between EPAS instances, providing both load balancing for read-heavy workloads and failover capabilities for high availability.
Table partitioning: EPAS supports table partitioning, a technique that divides large tables into smaller, more manageable pieces. This can improve query performance and simplify data management tasks, such as backups and indexing.
Connection pooling: EPAS includes built-in connection pooling, which allows multiple client connections to share a limited number of database connections. This can help improve system performance and resource utilization in high-concurrency environments.

conclusion

EDB Postgres Advanced Server offers a powerful and cost-effective alternative to traditional proprietary databases. With its Oracle compatibility, advanced security features, performance enhancements, and scalability capabilities, EPAS is an attractive option for organizations looking to modernize their database infrastructure and embrace the benefits of open-source technology.