DEV Community: fabriciomsdev

Draft: What are the differences between arrow functions and traditional functions?

fabriciomsdev — Thu, 15 Aug 2024 21:43:08 +0000

The Javascript traditional functions have some superpowers instead of simple arrow functions because normal functions follow the Javascript prototype pattern and do not have access to the magic keywords “this” where we can control the function context.

I show below some powers of JS normal functions:

Using functions as constructors:

As an arrow, you will get an error:

  const Person = (name) => {
    this.name = name;
  };

  const person = new Person("John");

The error we get:

Using a normal function:

function  Product(title, price){
  this.title  =  title;
  this.price  =  price;
}

let  p1  =  new  Product("Pen",100);

console.log(p1);

As a result we will get:

Having access to "arguments" of the context:

  function myFunc() {
    console.log(arguments);
  }

  myFunc(1, 'text', 5, 6); // Logs [1, 'text', 5, 6

Having their own access to this context:

  const person = {
    value: 'I used normal functions',
    showTheValue: function() {
      setTimeout(function() {
        console.log(this.value); // "this" refers to obj
      }, 1000);
    }
  };

  person.showTheValue(); // Logs "I used normal functions"

Using arrow functions:

  const person = {
    value: 'arrow function',
    showTheValue: () => {
      setTimeout(() => {
        console.log(this.value); // "this" does not refer to obj
      }, 1000);
    }
  };

  obj.showTheValue(); // Logs undefined or throws an error depending on strict mode

Conclusion:

Arrow functions are more concise and straightforward focused only on creating a function that executes a piece of code, normal functions can be used to solve a lot of problems in different ways not only to execute a piece of code.

If you see that a SQL SELECT query is slow - what would you do to improve it?

fabriciomsdev — Thu, 15 Aug 2024 21:04:14 +0000

If a SQL SELECT query is slow, there are some simple steps we can take to identify the cause and improve its performance.

I will explain the above step by step:

1 Step - First see the plan for the execution of the query:

To do that you can use EXPLAIN or EXPLAIN ANALYZE to understand how this query is working behind the scenes.

For example, I built a simple book stores system, with 3 entities, Books, Authors, and Publisher, I ran a simple query with a merge between Books and Authors to show how it works

As you can see in the table Result 1 this command can show the query execution plan with all process in the query running it can be used to see the bottlenecks in the process, I will proposital add a bottleneck in the process for example adding a table in the query merge without foreign keys.

CREATE TABLE books_publisher (
    publisher_id SERIAL PRIMARY KEY,
    publisher_name VARCHAR(100) NOT NULL
);

ALTER TABLE books_book
ADD COLUMN publisher_id INTEGER;

INSERT INTO books_publisher (publisher_name) VALUES ('Penguin');
INSERT INTO books_publisher (publisher_name) VALUES ('Harper Collins');
INSERT INTO books_publisher (publisher_name) VALUES ('Oxford University Press');
INSERT INTO books_publisher (publisher_name) VALUES ('Pearson');

UPDATE books_book
SET publisher_id = (SELECT publisher_id FROM books_publisher ORDER BY RANDOM() LIMIT 1);

Now I run the query doing a join with publisher:

Note: The time of execution is 11.180 ms

2 Step - Verify foreign keys and indexes:

I will add a foreign key index to improve the algorithm when we run the query:

ALTER TABLE books_book
ADD CONSTRAINT fk_publisher
FOREIGN KEY (publisher_id)
REFERENCES books_publisher(publisher_id);

CREATE INDEX idx_publisher_id
ON books_book (publisher_id);

CREATE INDEX books_book_btree_publisher_id ON public.books_book USING btree (publisher_id);

After improving in DDL structure:

Note: The time of execution is 4.168 ms

3 Step - Verify what business needs, and filter data:

For example to count how many books a publisher send for each author we should do the query:

select
    books_publisher.publisher_name,
    books_author."name"  as author,
    count(*) qty
from books_book
inner join books_author 
on books_book.author_id = books_author.id
inner join books_publisher 
on books_publisher.publisher_id = books_book.publisher_id
group by books_publisher.publisher_name, books_author."name";

This query took:

We can remove the books where we did not have publishers to avoid unnecessary loops I will add a filter:

  where books_book.publisher_id is not null

It is the result:

It is a very small example, on the large datasets other things we can do are:

remove necessary data from attribute selection
do views or materialized views with your subqueries to preprocess data
organize data to follow normalization rules or unfollow (it can work too), depending on the kind of feature you want to provide to your customer
- Verify resources of the database, such as: connections opened, connections idle, CPU and RAM use.

What is Python GIL? How it works?

fabriciomsdev — Thu, 15 Aug 2024 19:12:18 +0000

Things you should know before reading this article:

What is Parallelism?
What is Concurrency?
What is a Deadlock?
What is Race Concurrency?
What is a Process?
What is a Thread?

Introduction

The Global Interpreter Lock, is a lock that protects access to Python objects and carefully controls thread execution, preventing race concurrency in data access and modification, ensuring that only one thread can execute Python code at a time.

Without the GIL, Python’s memory management can be not thread-safe, it could lead to inconsistencies and crashes. (Deadlocks)

2 - How it works?

It's very simple, Thread will hold the GIL when it is running, and after running the Thread will release the GIL. The next threads must request access to the GIL in order to execute Opcodes (low-level operations). I draw one example of GIL behavior below:

Moment 1:

Moment 2:

Moment 3:

It means that Python developers can utilize async code, and multi-threaded code and never have to worry about acquiring locks on any variables in the process running or having processes crash from deadlocks.

3 - Pros of using GIL:

It simplifies the implementation of CPython's memory management, avoiding race conditions.
This mechanism ensures that Python's core data structures, like dictionaries and lists, are thread-safe without requiring complex locking mechanisms.
The GIL makes it easier to integrate C extensions with Python and allows the use of CPython, the most common interpreter and compiler used by the community.

4 - Cons of using GIL:

The most significant drawback of the GIL is that it prevents Python programs from taking full advantage of multi-core CPUs using multi-threading.
In CPU-bound applications, the GIL can become a significant bottleneck, as it prevents true parallel execution of threads
As Developer, you may face challenges when trying to optimize multi-threaded Python programs.

5 - How to Deal With GIL Cons?

Instead of using threads, you can use processes to run your algorithms in some cases. For IO/Bound operations Threading and concurrency can allow you to have a better use of your resources, for CPU/Bound operations you can use the multiprocessing library to better resource use.