DEV Community: Atchukola Naresh

Django Technical Paper

Atchukola Naresh — Thu, 15 Jun 2023 13:07:13 +0000

What is secret key?

A Django secret key is a random string that is used to protect your Django application from security attacks. It is used for a variety of purposes, including:

Signing cookies: Cookies are small files that are stored on a user's computer when they visit your website. They can be used to store information about the user, such as their username, password, and session ID. Django uses a secret key to sign cookies, which helps to prevent them from being tampered with.
- Generating CSRF tokens: CSRF (Cross-Site Request Forgery) is a type of attack that allows an attacker to trick a user into performing an action on a website without their knowledge or consent. Django uses a secret key to generate CSRF tokens, which are used to protect against CSRF attacks.
- Generating password reset tokens: When a user forgets their password, they can request a password reset link to be sent to their email address. This link contains a password reset token, which is used to verify the user's identity and reset their password. Django uses a secret key to generate password reset tokens.
It is important to keep your Django secret key secret. If it is compromised, an attacker could use it to perform a variety of security attacks on your application. You should never share your Django secret key with anyone, and you should never commit it to version control.
To generate a Django secret key, you can use the following command:

Code snippet

python -c 'import random; print(random.SystemRandom().get_random_bytes(32))'

This will generate a 32-character random string. You can then copy and paste this string into your Django settings file.

The Django secret key is a critical part of your Django application's security. By keeping it secret, you can help to protect your application from security attacks.

What are the default Django apps inside it? Are there more?

Django comes with a number of default apps that are installed when you create a new project. These apps provide basic functionality that is commonly needed in web applications, such as:

Admin: A web-based interface for managing your Django project's content, users, and other settings.
Auth: A system for authenticating users and managing their permissions.
Contenttypes: A system for defining and managing the types of content that can be stored in your Django project.
Sessions: A system for tracking user sessions and storing session data.
Messages: A system for sending and receiving messages between users.
Staticfiles: A system for managing static files, such as images, CSS, and JavaScript.

In addition to the default apps, there are a number of third-party apps that can be installed and used with Django. These apps provide additional functionality, such as:

Django Rest Framework: A powerful framework for building RESTful APIs.
Django Channels: A framework for building real-time applications.
Django Celery: A framework for running asynchronous tasks.
Django South: A migration tool for managing changes to your Django project's database schema.
Django Debug Toolbar: A powerful tool for debugging Django applications.

The number of default Django apps is subject to change, but there will always be a number of core apps that are included with Django. These apps provide the basic functionality that is needed to build a web application. Third-party apps can be used to add additional functionality to your Django project.

If you are new to Django, I recommend that you start with the default apps. Once you have a basic understanding of how Django works, you can start exploring third-party apps.

What is middleware in django? What are different kinds of middleware in django? Read up a little on each security issue?

Middleware in Django is a way to add custom functionality to your Django application. It is a general-purpose framework that allows you to intercept and modify requests and responses before they reach your views. Middleware can be used for a variety of purposes, such as:

Authentication and authorization
Session management
Caching
Security
Performance optimization

Django includes a number of built-in middleware, such as:

AuthenticationMiddleware: This middleware handles authentication for your application.
SessionMiddleware: This middleware handles session management for your application.
GzipMiddleware: This middleware compresses responses to reduce bandwidth usage.
CommonMiddleware: This middleware provides a number of common features, such as error handling and static file serving.

You can also write your own middleware. To do this, you need to create a class that inherits from the MiddlewareMixin class. Your class must define the process_request() and process_response() methods. The process_request() method is called before the request is passed to your views, and the process_response() method is called after the response is generated by your views.

Here are some of the security issues that can be addressed with middleware:

Cross-site request forgery (CSRF): CSRF is a type of attack where an attacker tricks a user into submitting a form to your application without their knowledge. This can be used to perform actions on behalf of the user, such as transferring money out of their account or making a purchase.
Cross-site scripting (XSS): XSS is a type of attack where an attacker injects malicious code into a web page that is viewed by a user. This malicious code can then be executed on the user's computer, potentially stealing their cookies or other sensitive information.
Session fixation: Session fixation is a type of attack where an attacker tricks a user into using a session ID that the attacker has chosen. This allows the attacker to take control of the user's session and perform actions on their behalf.

Middleware can be used to mitigate these security risks by checking requests for malicious content, enforcing authentication, and managing sessions securely.

Here are some examples of how middleware can be used to improve security:

The CSRFMiddleware class checks requests for the presence of a CSRF token. If the token is not present or is invalid, the request is rejected.
The XSSMiddleware class scans responses for malicious code. If any malicious code is found, it is replaced with harmless text.
The SessionMiddleware class ensures that sessions are created securely and that session IDs are not exposed to users.

By using middleware, you can add additional security features to your Django application and protect your users from a variety of attacks.

Cross site request forgery (CSRF)

CSRF attacks allow a malicious user to execute actions using the credentials of another user without that user’s knowledge or consent.

Django has built-in protection against most types of CSRF attacks, providing you have enabled and used it where appropriate. However, as with any mitigation technique, there are limitations. For example, it is possible to disable the CSRF module globally or for particular views. You should only do this if you know what you are doing. There are other limitations if your site has subdomains that are outside of your control.

CSRF protection works by checking for a secret in each POST request. This ensures that a malicious user cannot “replay” a form POST to your website and have another logged in user unwittingly submit that form. The malicious user would have to know the secret, which is user specific (using a cookie).

When deployed with HTTPS, CsrfViewMiddleware will check that the HTTP referer header is set to a URL on the same origin (including subdomain and port). Because HTTPS provides additional security, it is imperative to ensure connections use HTTPS where it is available by forwarding insecure connection requests and using HSTS for supported browsers.

Be very careful with marking views with the csrf_exempt decorator unless it is absolutely necessary.

SQL injection protection

SQL injection is a type of attack where a malicious user is able to execute arbitrary SQL code on a database. This can result in records being deleted or data leakage.

Django’s querysets are protected from SQL injection since their queries are constructed using query parameterization. A query’s SQL code is defined separately from the query’s parameters. Since parameters may be user-provided and therefore unsafe, they are escaped by the underlying database driver.

Django also gives developers power to write raw queries or execute custom sql. These capabilities should be used sparingly and you should always be careful to properly escape any parameters that the user can control. In addition, you should exercise caution when using extra() and RawSQL.

Clickjacking protection:

Clickjacking is a type of attack where a malicious site wraps another site in a frame. This attack can result in an unsuspecting user being tricked into performing unintended actions on the target site.

Django contains clickjacking protection in the form of the X-Frame-Options middleware which in a supporting browser can prevent a site from being rendered inside a frame. It is possible to disable the protection on a per view basis or to configure the exact header value sent.

The middleware is strongly recommended for any site that does not need to have its pages wrapped in a frame by third party sites, or only needs to allow that for a small section of the site.

Gateways in Django:

WSGI and ASGI are both Python web application programming interfaces (APIs) that allow you to create web applications using Python. WSGI was the first widely adopted API for Python web applications, and it is still in use today. ASGI is a newer API that is designed to be more efficient and scalable than WSGI.

WSGI

WSGI stands for Web Server Gateway Interface. It is a specification that defines how a web server communicates with a Python web application. WSGI applications are typically written as a set of functions that handle requests and return responses. The web server calls these functions in response to incoming requests.

WSGI is a synchronous API, which means that the web server blocks while it is waiting for the Python application to return a response. This can lead to performance problems in applications that handle a lot of concurrent requests.

ASGI

ASGI stands for Asynchronous Server Gateway Interface. It is a newer API that is designed to be more efficient and scalable than WSGI. ASGI applications are typically written using asynchronous programming techniques. This allows the web server to continue handling other requests while the Python application is processing a request.

ASGI is a more flexible API than WSGI. It supports a wider range of web servers and Python web frameworks. ASGI is also more future-proof than WSGI. It is designed to support new technologies, such as WebSockets.

Django

Django is a popular Python web framework. Django supports both WSGI and ASGI. Django applications that use WSGI are typically deployed using a web server such as Gunicorn or uWSGI. Django applications that use ASGI are typically deployed using a web server such as Daphne or Hypercorn.

Which API should you use?

If you are creating a new Python web application, you should use ASGI. ASGI is the more modern API and it offers a number of advantages over WSGI. If you are already using WSGI and you are happy with the performance, you can continue using WSGI. However, if you are experiencing performance problems, you should consider migrating your application to ASGI.

Here is a table that summarizes the key differences between WSGI and ASGI

What is ondelete Cascade in models in django?

The on_delete option in Django's models.py file is used to specify what should happen to a model instance when the model instance that it is related to is deleted. The on_delete option can be set to one of the following values:

CASCADE: When the parent model instance is deleted, all of the child model instances that are related to it will also be deleted.
PROTECT: When the parent model instance is deleted, the delete operation will be prevented if any child model instances are related to it.
SET_NULL: When the parent model instance is deleted, the foreign key field in the child model instances will be set to NULL.
SET_DEFAULT: When the parent model instance is deleted, the foreign key field in the child model instances will be set to the default value.
SET(...): When the parent model instance is deleted, the foreign key field in the child model instances will be set to a custom value.

The on_delete option is a powerful tool that can be used to maintain the integrity of your database. However, it is important to use it carefully, as it can also lead to data loss if it is not used correctly.

Here is an example of how the on_delete option can be used:

class Post(models.Model):
    title = models.CharField(max_length=255)
    body = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ['-created_at']

class Comment(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE)
    author = models.CharField(max_length=255)
    body = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True

Fields are used to store data in your models. They can be used to store simple data types, such as strings and numbers, or more complex data types, such as lists and dictionaries.
Validators are used to validate data before it is stored in your models. They can be used to check for things like invalid characters, empty values, and out-of-range values.

Here are some of the most commonly used fields and validators in Django:

CharField is used to store a string of text. It has a max_length argument that can be used to limit the length of the string.
TextField is used to store a long string of text. It does not have a max_length argument, so there is no limit to the length of the string.
IntegerField is used to store an integer value. It has a min and max argument that can be used to limit the range of the integer.
FloatField is used to store a floating-point value. It has a min and max argument that can be used to limit the range of the floating-point value.
BooleanField is used to store a boolean value. It can be set to True or False.
DateField is used to store a date value. It can be set to a specific date or to the current date.
DateTimeField is used to store a date and time value. It can be set to a specific date and time or to the current date and time.

Here are some of the most commonly used validators in Django:

MinLengthValidator is used to check that the value is not shorter than a certain length.
MaxLengthValidator is used to check that the value is not longer than a certain length.
EmailValidator is used to check that the value is a valid email address.
URLValidator is used to check that the value is a valid URL.
RegexValidator is used to check that the value matches a specific regular expression.

You can also write your own custom validators. To do this, you need to create a class that inherits from the django.core.validators.Validator class. Your class must define a validate() method that takes the value to be validated as its argument.

Fields and validators are a powerful way to ensure that the data in your models is valid. By using them, you can help to prevent errors and make your applications more robust.

Understanding the difference between Python module and Python class?

Modules

A module is a self-contained unit of code that can be imported into another module. Modules are typically used to organize code and to share code between different applications. For example, you might have a module that contains code for performing mathematical operations, and you might have another module that contains code for performing string manipulation operations. You could then import these modules into your application and use the code in them to perform the desired operations.

Classes

A class is a blueprint for creating objects. Classes define the properties and methods of an object. Properties are data that is associated with an object, and methods are actions that an object can perform. For example, you might have a class that represents a car. The class could define properties such as the car's make, model, and year, and it could define methods such as start_engine, drive, and stop. You could then create objects that are instances of the car class. Each object would have its own set of properties, and it could perform the actions defined by the methods in the class.

## Using ORM queries in Django Shell

Sure, you can use ORM queries in the Django shell to interact with your database. The Django shell is a Python interpreter that is pre-loaded with all of the Django models and functions. This makes it easy to write and test ORM queries without having to start a web server.

To use the Django shell, you need to first start it. You can do this by running the following command:

Code snippet

python manage.py shell

Once the Django shell is started, you can import the models that you want to use. For example, if you have a model called User, you would import it like this:

Code snippet

from myapp.models import User

Once you have imported the models, you can start writing ORM queries. ORM queries are written in Python, and they use the same syntax as SQL queries. For example, the following query will select all of the users from the database:

Code snippet

users = User.objects.all(

The users variable will now contain a list of all of the users in the database. You can then iterate through the list to access the individual users. For example, the following code will print the name of the first user in the list:

Code snippet

for user in users:
    print(user.name)

You can also use ORM queries to filter and sort the results. For example, the following query will select all of the users who are active:

Code snippet

active_users = User.objects.filter(is_active=True)

The active_users variable will now contain a list of all of the active users in the database. You can also sort the results by any field. For example, the following query will sort the users by their name:

Code snippet

sorted_users = User.objects.order_by('name')

The sorted_users variable will now contain a list of all of the users in the database, sorted by their name.

## Turning ORM to SQL in Django Shell

Sure, you can turn ORM queries to SQL in the Django shell by using the .query attribute. The .query attribute returns a QuerySet object, which is a representation of the SQL query that will be executed. You can then use the .sql method to get the SQL query as a string.

For example, the following code will select all of the users from the database and print the SQL query that will be executed:

Code snippet

from myapp.models import User

users = User.objects.all()

query = users.query

print(query.sql)

The output of the print statement will be the following SQL query:

Code snippet

SELECT * FROM users

You can also use the .query attribute to modify the SQL query before it is executed. For example, the following code will select all of the users who are active and print the SQL query that will be executed:

Code snippet

from myapp.models import User

users = User.objects.filter(is_active=True)

query = users.query

print(query.sql)

The output of the print statement will be the following SQL query:

Code snippet

SELECT * FROM users WHERE is_active = 1

## What are Aggregations in django?

Sure, here's what you need to know about Aggregations in Django:

In Django, aggregations are used to perform calculations on data. They can be used to find the total, average, minimum, maximum, or count of data in a QuerySet.

There are a number of different aggregations that can be used in Django. Some of the most common aggregations include:

Count(): This aggregation returns the number of objects in a QuerySet.
Sum(): This aggregation returns the sum of the values in a field.
Avg(): This aggregation returns the average of the values in a field.
Min(): This aggregation returns the minimum value in a field.
Max(): This aggregation returns the maximum value in a field.

To use an aggregation, you can use the aggregate() method on a QuerySet. The aggregate() method takes a dictionary as its argument. The keys of the dictionary are the names of the aggregations that you want to use, and the values of the dictionary are the arguments that you want to pass to the aggregations.

For example, the following code will find the total number of users in the database:

Code snippet

from django.db.models import Count

users = User.objects.all()

total_users = users.aggregate(Count('id'))['id__count']

print(total_users)

What are Annotations in django

Annotations in Django are a way to add additional data to each object in a QuerySet. They are similar to aggregations, but they are applied to each object in the QuerySet, rather than the entire QuerySet as a whole.

To use annotations, you can use the annotate() method on a QuerySet. The annotate() method takes a dictionary as its argument. The keys of the dictionary are the names of the annotations that you want to use, and the values of the dictionary are the expressions that you want to use to calculate the annotations.

For example, the following code will add a new field called total_orders to each user object in the QuerySet:

Code snippet

from django.db.models import Count

users = User.objects.all()

users = users.annotate(total_orders=Count('orders'))

for user in users:
    print(user.total_orders)

What is a migration file? Why is it needed?

Django, a migration file is a Python file that describes the changes that need to be made to a database schema. Migration files are used to keep the database schema in sync with the Django models.

Migration files are needed because Django models are defined in Python, but databases are defined in SQL. Migration files bridge the gap between these two languages by providing a way to describe the changes that need to be made to the database schema in Python.

When you make changes to your Django models, you need to create a new migration file that describes the changes. You can then use the migrate command to apply the changes to the database.

Migration files are also used to roll back changes to the database schema. If you make a change to your Django models that you don't like, you can use the revert command to roll back the changes to the previous migration.

Migration files are a powerful tool that can help you keep your database schema in sync with your Django models. They are a valuable part of the Django development process.

Here are some of the benefits of using migration files:

They help to keep your database schema in sync with your Django models. This can help to prevent errors and data loss.
They make it easy to roll back changes to the database schema. This can be helpful if you make a mistake or if you need to revert to a previous version of the database.
They can be used to automate the creation and deployment of database schemas. This can save you time and effort.

If you are using Django, I recommend that you use migration files to manage your database schema. They are a valuable tool that can help you to develop and deploy your Django applications more effectively.

What are SQL transactions? (non ORM concept)

In SQL, a transaction is a set of operations that are performed together as a unit. Transactions are used to ensure that data is always consistent in the database.

There are four properties of transactions that are known as ACID:

Atomicity: All of the operations in a transaction must be completed successfully, or none of them can be completed.
Consistency: The database must be in a consistent state before and after the transaction is completed.
Isolation: Transactions should not interfere with each other.
Durability: Once a transaction is completed, the changes made to the database should be permanent.

Transactions are implemented using locks. A lock is a mechanism that prevents other transactions from accessing data that is being modified by a transaction.

What are atomic transactions?

An atomic transaction is a set of database operations that are treated as a single, indivisible unit. This means that either all of the operations in the transaction are performed successfully, or none of them are performed.

Atomicity is one of the four ACID properties of transactions, which also include consistency, isolation, and durability.

Atomicity is important for ensuring the integrity of data in a database. If a transaction is not atomic, it is possible for the database to be left in an inconsistent state. For example, if a transaction withdraws money from one account and deposits it into another, but the withdrawal fails, the account from which the money was withdrawn will be left with less money than it had before.

Atomic transactions are implemented using locks. When a transaction starts, it acquires locks on the data that it needs to modify. This prevents other transactions from accessing the data until the current transaction finishes.

If a transaction fails, the locks that it acquired are released. This allows other transactions to access the data again.

Atomic transactions are a fundamental concept of database management systems. They are used to ensure the integrity of data in databases, and they are a key part of many database applications.

Here are some examples of atomic transactions:

Transferring money from one bank account to another: This transaction involves two operations: withdrawing money from one account and depositing it into another. If either of these operations fails, the transaction will fail and the money will not be transferred.
Updating a customer's record: This transaction involves two operations: updating the customer's name and updating the customer's address. If either of these operations fails, the transaction will fail and the customer's record will not be updated.
Deleting a product from an inventory system: This transaction involves one operation: deleting the product from the inventory system. If this operation fails, the product will not be deleted from the inventory system.

Atomic transactions provide a number of benefits, including:

Data integrity: Atomic transactions ensure that data is always consistent in the database. This is important for applications that need to maintain accurate data.
Data reliability: Atomic transactions help to protect data from corruption. If a transaction fails, the database will be rolled back to the state it was in before the transaction started.
Data availability: Atomic transactions can help to improve data availability. If a transaction fails, other transactions will not be blocked. This can help to improve the performance of your database applications.

Asynchronous JavaScript Technical Paper

Atchukola Naresh — Thu, 01 Jun 2023 09:33:33 +0000

Callbacks:

What is a Callback
Function?
In JavaScript, a callback function is a function that is passed into another
function as an argument. This function can then be invoked at a later stage
of time.
Since, in JavaScript, functions are objects, functions can be passed as
arguments.

function printFirstName(firstname, cb){
console.log(firstname)
cb ('Rogers')
}
function printLastName(lastname) {
console.log(lastname)
}
printFirstName('Steve' printLastName )// callback

const isEven = (n)=>{
return n%2==0
}
let printResult = (evenFn, num) =>{
const isNumEven = evenFn(num)
console.log(The number ${num} is an Even Number ${isNumEven} `)
}
printResult (isEven,16)

callback functions is the one of the reson to call JavaScript as the Functional programming.

- Promises:

What is a Promise in JavaScript?

A promise in JavaScript is no different from a promise in real life. If you take a promise from me that I will bring you a bar of chocolate, there can be three cases here:

You are waiting for me to come (the promise is in a PENDING state)
I bought you a bar of chocolate (the promise is in a FULFILLED state)
The shop was closed, or due to any reason, the promise failed ( the promise goes to the REJECTED state).

Similarly, when you call an asynchronous function, i.e., a function that might send a response in the future, you are actually taking a promise. At first, the promise remains in the PENDING state because no response has been received. After some time, when the response is received, there are two possible cases:

We got a response (i.e., the promise goes to the FULFILLED state)
We got an error and no response (the promise got REJECTED)

Note: Getting a response means the promise is in the SETTLED state. In other words, the promise is not in the PENDING state now, and it has been either RESOLVED or REJECTED.

:::

How Promises Work

In technical terms, a promise is an object that is returned as a response to an asynchronous function. It can be one of these four possible states:

PENDING
FULFILLED
REJECTED
SETTLED

Let us understand this in a bit more detail. The moment a promise is invoked, it goes to the PENDING state and waits for a response to come. We might get the correct response, which makes the promise FULFILLED, or we might get an error, i.e., the promise goes to the REJECTED state. A promise is said to be SETTLED if it is not in the pending state, i.e., either the response has arrived or an error has occurred.

Note: Once settled, a promise cannot be resettled.

Code snippet

// Create a promise that resolves after 1 second
let promise = new Promise(function(resolve, reject) {
  setTimeout(() => resolve("done"), 1000);
});

// Chain promises together
promise.then(function(result) {
  return fetch("https://example.com/api/data");
}).then(function(response) {
  return response.json();
}).then(function(data) {
  // Do something with the data
});

// Handle errors
promise.catch(function(error) {
  // Handle the error
});

The first example creates a promise that resolves after 1 second. The new Promise() constructor takes two arguments: a function that is called when the promise is resolved or rejected, and a function that is called when the promise is rejected. In this case, the resolve() function is called after 1 second, which resolves the promise.
The second example chains promises together. The then() method on a promise takes a function as an argument. This function is called when the promise is resolved, and it is passed the result of the promise. In this case, the then() method is called twice. The first time, the function is called with the result of the first promise, which is the string "done". The second time, the function is called with the result of the second promise, which is the JSON data from the API.
The third example handles errors. The catch() method on a promise takes a function as an argument. This function is called when the promise is rejected, and it is passed the error object. In this case, the catch() method is called if the promise is rejected for any reason.

Promises are a powerful tool for asynchronous programming in JavaScript. They allow you to write code that is more concise, readable, and maintainable.

- Code Control:

Asynchronous JavaScript code control is the process of managing the execution of asynchronous JavaScript code. This can be done using a variety of techniques, including:

Callbacks: Callbacks are functions that are passed as arguments to other functions and are called when those functions complete. This is a common technique for asynchronous code, as it allows the caller to specify what should happen when the asynchronous operation completes.
Promises: Promises are objects that represent the outcome of an asynchronous operation. They can be used to chain together asynchronous operations and to handle errors.
async/await: async/await are new JavaScript keywords that make it easier to write asynchronous code. They allow you to write code that looks like synchronous code, but that actually executes asynchronously. The best technique for asynchronous JavaScript code control depends on the specific needs of the application. Callbacks are a simple and straightforward way to control asynchronous code, but they can be difficult to manage when there are multiple callbacks nested together. Promises are a more powerful tool that can be used to chain together asynchronous operations and to handle errors. async/await is the newest technique, and it offers the most concise and readable syntax for asynchronous code.

Here is an example of how to use callbacks to control asynchronous code:

Code snippet

function doSomethingAsync(callback) {
  // Do something asynchronous here...
  callback();
}

doSomethingAsync(function() {
  // This code will be executed when the asynchronous operation completes.
});

Here is an example of how to use promises to control asynchronous code:

Code snippet

function doSomethingAsync() {
  // Do something asynchronous here...
  return new Promise(function(resolve, reject) {
    if (somethingSuccess) {
      resolve();
    } else {
      reject();
    }
  });
}

doSomethingAsync().then(function() {
  // This code will be executed when the asynchronous operation completes successfully.
}).catch(function() {
  // This code will be executed when the asynchronous operation fails.
});

Here is an example of how to use async/await to control asynchronous code:

Code snippet

async function doSomethingAsync() {
  // Do something asynchronous here...
  const result = await something;
  // Use the result here...
}

doSomethingAsync();

Asynchronous JavaScript code control is an important skill for any JavaScript developer. By understanding the different techniques available, you can write code that is both efficient and easy to maintain.

JavaScript Technical Paper

Atchukola Naresh — Tue, 30 May 2023 04:50:20 +0000

For loop:

A for loop in JavaScript is a control flow statement that allows you to execute a block of code repeatedly until a specified condition is met.
Code snippet

for (initialization; condition; iteration) {
  // block of code to be executed repeatedly
}

A for loop in JavaScript is a control flow statement that allows you to execute a block of code repeatedly until a specified condition is met. The syntax for a for loop is as follows:

Code snippet

for (initialization; condition; iteration) {
  // block of code to be executed repeatedly
}

The initialization expression is executed once, before the first iteration of the loop. The condition expression is evaluated before each iteration of the loop. If the condition evaluates to true, the block of code is executed. If the condition evaluates to false, the loop terminates. The iteration expression is executed after each iteration of the loop.

Here is an example of a for loop that prints the numbers from 1 to 10:

Code snippet

for (var i = 1; i <= 10; i++) {
  console.log(i);
}

This loop will first initialize the variable i to 1. Then, it will evaluate the condition i <= 10. Since i is equal to 1, the condition evaluates to true. The block of code is then executed, which prints the value of i to the console. The loop then increments i by 1 and repeats the process. This will continue until i is greater than 10, at which point the condition will evaluate to false and the loop will terminate.

forEach :

The forEach() method in JavaScript is used to iterate over an array and execute a function for each element in the array.

The forEach() method is a convenient way to iterate over an array and execute a function for each element. It is often used to perform simple tasks, such as logging the elements of an array to the console or updating the values of an array.

Code snippet

// Log the elements of an array to the console.
const arr = [1, 2, 3, 4, 5];

arr.forEach(function(element) {
  console.log(element);
});

// Update the values of an array.
const arr = [1, 2, 3, 4, 5];

arr.forEach(function(element) {
  element *= 2;
});

console.log(arr); // [2, 4, 6, 8, 10]

for (...in..):

The for ... in loop in JavaScript is used to iterate over the properties of an object. It can be used to print the properties of an object, or to access the values of the properties. The syntax for the for ... in loop is as follows:
Code snippet

for (let key in object) {
  // Do something with the key and the value of object[key]
}

Code snippet

const object = {
  name: "John Doe",
  age: 30,
  address: "123 Main Street"
};

for (let key in object) {
  console.log(key, object[key]);
}

This code will print the following output:

Code snippet

name John Doe
age 30
address 123 Main Street

for (..of..):

The for ... of loop in JavaScript is used to iterate over the values of an iterable object. It can be used to print the values of an iterable object, or to access the values of the iterable object. The syntax for the for ... of loop is as follows:

Code snippet

for (let value of iterable) {
  // Do something with the value
}

Code snippet

const iterable = [1, 2, 3, 4, 5];

for (let value of iterable) {
  console.log(value);
}

This code will print the following output:

Code snippet

The for ... of loop can also be used to iterate over the values of a string. For example, the following code will print the characters in the string:

Code snippet

const string = "Hello, world!";

for (let value of string) {
  console.log(value);
}

This code will print the following output:

Code snippet

H
e
l
l
o
,

w
o
r
l
d
!

while loop:

A while loop in JavaScript is a programming construct that allows you to execute a block of code repeatedly as long as a given condition is true.

Code snippet

while (condition) {
  // block of code to be executed repeatedly
}

Here is an example of a while loop that prints the numbers from 1 to 10:

Code snippet

var i = 1;
while (i <= 10) {
  console.log(i);
  i++;
}

Mutable and Immutable Methods (in strings);

In JavaScript, strings are immutable, which means that once a string is created, its value cannot be changed. This is in contrast to mutable objects, such as arrays, which can be changed after they are created.

There are a number of methods in JavaScript that can be used to manipulate strings. Some of these methods are mutable, while others are immutable.

Mutable methods

concat(): This method concatenates the specified string to the end of the current string.
replace(): This method replaces all occurrences of the specified substring with the specified replacement string.
slice(): This method returns a new string that is a substring of the current string.

Immutable methods

toUpperCase(): This method returns a new string that is the uppercase version of the current string.
toLowerCase(): This method returns a new string that is the lowercase version of the current string.
trim(): This method returns a new string that has all leading and trailing whitespace characters removed.

It is important to be aware of the difference between mutable and immutable methods when working with strings. If you are using a mutable method, you should be careful not to modify the string in a way that could affect other parts of your code.

Mutable and Immutable Methods (in arrays):

In JavaScript, arrays are mutable objects, which means that their contents can be changed after they have been created. This is done by using the various array methods, such as push(), pop(), shift(), unshift(), reverse(), sort(), and splice().

Mutable Array Methods

push(): Adds an element to the end of the array.
pop(): Removes the last element from the array and returns it.
shift(): Removes the first element from the array and returns it.
unshift(): Adds an element to the beginning of the array.
reverse(): Reverses the order of the elements in the array.
sort(): Sorts the elements in the array.
splice(): Removes and/or adds elements from the array.

Immutable Array Methods

There are also a number of immutable array methods that do not mutate the original array. These methods return a new array with the changes applied.

map(): Applies a function to each element in the array and returns a new array with the results.
filter(): Filters the array by returning only the elements that meet a certain condition.
reduce(): Reduces the array to a single value by applying a function to each element.

JavaScript

function swap(a, b) {
  const temp = a;
  a = b;
  b = temp;
}

const x = 1;
const y = 2;

swap(x, y);

console.log(x, y); // 2, 1

Use code with caution. Learn more

content_copy

In this example, the swap() function takes two arguments: a and b. The a and b arguments are references to the variables x and y. When the swap() function is called, the values of a and b are swapped. The changes to a and b are reflected in the calling function, because a and b are references to the variables x and y.

- Pass by Reference and Pass by Value - add codeblocks;

Pass by reference

JavaScript

function swap(a, b) {
  const temp = a;
  a = b;
  b = temp;
}

const x = 1;
const y = 2;

swap(x, y);

console.log(x, y); // 2, 1

JavaScript

function add(a, b) {
  return a + b;
}

const x = 1;
const y = 2;

const z = add(x, y);

console.log(z); // 3

In this example, the add() function takes two arguments: a and b. The a and b arguments are the values of the variables x and y. When the add() function is called, the values of a and b are added together and the result is returned. The changes to a and b are not reflected in the calling function, because a and b are the values of the variables x and y.

In general, pass by reference is used when you want to modify the value of an argument in the calling function. Pass by value is used when you only want to use the value of an argument in the called function.

Array methods - add codeblocks and mention mutable/immutable;

Array.pop-

The array.pop() method in JavaScript is used to remove the last element from an array and returns that element. This method changes the length of the array so it was a
mutable method.

The array.pop() method takes no arguments.

Here is an example of how to use the array.pop() method:

JavaScript

const numbers = [1, 2, 3, 4, 5];

const lastNumber = numbers.pop();

console.log(lastNumber); // 5

console.log(numbers); // [1, 2, 3, 4]

Array.push:

The array.push() method in JavaScript is used to add one or more elements to the end of an array. This method changes the length of the array.

The array.push() method takes one or more arguments, which are the elements to be added to the end of the array.

Here is an example of how to use the array.push() method:

JavaScript

const numbers = [1, 2, 3];

numbers.push(4, 5);

console.log(numbers); // [1, 2, 3, 4, 5]

- Array.concat:

The array.concat() method in JavaScript is used to merge two or more arrays. This method does not change the existing arrays, but instead returns a new array.

The array.concat() method takes one or more arguments, which are the arrays to be merged.

Here is an example of how to use the array.concat() method:

JavaScript

const numbers1 = [1, 2, 3];
const numbers2 = [4, 5, 6];

const numbers3 = numbers1.concat(numbers2);

console.log(numbers3); // [1, 2, 3, 4, 5, 6]

- Array.slice:

The array.slice() method in JavaScript is used to extract a portion of an array into a new array. This method does not change the original array, but instead returns a new array.

The array.slice() method takes three arguments:

The start index of the portion to be extracted.
The end index of the portion to be extracted.
The optional third argument is a boolean value that indicates whether or not to include the end index in the extracted portion. If the third argument is omitted or false, the end index is not included in the extracted portion.

Here is an example of how to use the array.slice() method:

JavaScript

const numbers = [1, 2, 3, 4, 5];

const numbers2 = numbers.slice(1, 3);

console.log(numbers2); // [2, 3]

- Array.splice:

array.splice() method in JavaScript is used to remove, add, or replace elements in an array. This method changes the original array, and returns the removed elements as a new array.

The array.splice() method takes four arguments:

The index of the first element to be removed, added, or replaced.
The number of elements to be removed.
The elements to be added, or an empty array if no elements are to be added.
An optional fifth argument that indicates whether or not to return the removed elements. If the fifth argument is omitted or false, the removed elements are not returned.

Here is an example of how to use the array.splice() method to remove elements from an array:

JavaScript

const numbers = [1, 2, 3, 4, 5];

numbers.splice(1, 2);

console.log(numbers); // [1, 4 ,5]

In this example, the array.splice() method is called on the numbers array. The array.splice() method removes the elements at index 1 and 2, inclusive. The numbers array is then logged to the console. The numbers array now only contains the numbers 1 ,4, 5.

Here is an example of how to use the array.splice() method to add elements to an array:

JavaScript

const numbers = [1, 2, 3, 4, 5];

numbers.splice(2, 0, 6, 7);

console.log(numbers); // [1, 2, 6, 7, 3, 4, 5]

In this example, the array.splice() method is called on the numbers array. The array.splice() method adds the numbers 6 and 7 at index 2. The numbers array is then logged to the console. The numbers array now contains the numbers 1, 2, 6, 7, 3, 4, and 5.

Here is an example of how to use the array.splice() method to replace elements in an array:

JavaScript

const numbers = [1, 2, 3, 4, 5];

numbers.splice(2, 1, 6);

console.log(numbers); // [1, 2, 6, 4, 5]

In this example, the array.splice() method is called on the numbers array. The array.splice() method replaces the element at index 2 with the number 6. The numbers array is then logged to the console. The numbers array now contains the numbers 1, 2, 6, 4, and 5.

- Array.join:

The Array.join() method in JavaScript is used to join the elements of an array into a string. The elements of the string will be separated by a specified separator and its default value is a comma(, ).

The syntax for the Array.join() method is:

Code snippet

array.join(separator)

array is the array to be joined
separator is the string that will be used to separate the elements of the array. If no separator is specified, a comma will be used by default.

For example, the following code will join the elements of the array variable into a string, separated by commas:

Code snippet

const array = [1, 2, 3, 4];
const joinedArray = array.join(',');

console.log(joinedArray); // "1,2,3,4"

The Array.join() method can also be used to join the elements of an array into a string, separated by a custom separator. For example, the following code will join the elements of the array variable into a string, separated by spaces:

Code snippet

const array = ['Hello', 'World'];
const joinedArray = array.join(' ');

console.log(joinedArray); // "Hello World"

- Array.flat:

The Array.flat() method in JavaScript is used to flatten an array. This means that it will combine all of the sub-arrays in the original array into a single, flat array.

The syntax for the Array.flat() method is:

Code snippet

array.flat([depth])

Where:

array is the array to be flattened
depth is an optional parameter that specifies the maximum depth of the sub-arrays to be flattened. If no depth is specified, all sub-arrays will be flattened.

For example, the following code will flatten the array variable:

Code snippet

const array = [1, 2, [3, 4], [5, 6]];
const flatArray = array.flat();

console.log(flatArray); // [1, 2, 3, 4, 5, 6]

Array.find:

The Array.find() method in JavaScript is used to find the first element in an array that satisfies a given condition. The method takes a callback function as an argument, and the callback function is called once for each element in the array. If the callback function returns a truthy value for any element, the Array.find() method returns that element. If the callback function never returns a truthy value, the Array.find() method returns undefined.

The syntax for the Array.find() method is:

Code snippet

array.find(callback)

Where:

array is the array to be searched
callback is a function that takes an element of the array as its argument and returns a truthy or falsy value

For example, the following code will find the first element in the array variable that is greater than 10:

Code snippet

const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const firstGreaterThan10 = array.find(element => element > 10);

console.log(firstGreaterThan10); // 11

- Array.indexOf:

The array.indexOf() method in JavaScript returns the first index of the element in the array if it is present at least once. Returns -1 if the element is not found in the array.

The syntax for array.indexOf() is:

Code snippet

array.indexOf(element[, fromIndex])

element is the value to search for.
fromIndex is the index to start the search from. If not specified, the search starts at index 0.

Code snippet

const array = [1, 2, 3, 4, 5];

// Find the index of the first occurrence of 3
const index = array.indexOf(3);
console.log(index); // 2

// Find the index of the first occurrence of 6
const index = array.indexOf(6);
console.log(index); // -1

// Find the index of the first occurrence of 3, starting at index 2
const index = array.indexOf(3, 2);
console.log(index); // 3

- Array.includes:

The Array.prototype.includes() method in JavaScript checks if an array contains a specified element or not.

The syntax for Array.prototype.includes() is:

element is the value to search for.
fromIndex is the index to start the search from. If not specified, the search starts at index 0.

The includes() method returns true if the element is found in the array, and false if it is not found.

Here are some examples of how to use Array.prototype.includes():

Code snippet

const array = [1, 2, 3, 4, 5];

// Check if the array includes 3
const includes3 = array.includes(3);
console.log(includes3); // true

// Check if the array includes 6
const includes6 = array.includes(6);
console.log(includes6); // false

// Check if the array includes 3, starting at index 2
const includes3FromIndex2 = array.includes(3, 2);
console.log(includes3FromIndex2); // true

- Array.findIndex:

The Array.findIndex() method in JavaScript is used to find the index of the first element in an array that satisfies a provided testing function. The method returns the index of the element that satisfies the testing function or -1 if no element passed the test.

The syntax for the Array.findIndex() method is as follows:

Code snippet

array.findIndex(callback[, thisArg])

array is the array to be searched.
callback is a function that takes an element of the array as its input and returns a Boolean value. The function will be called for each element in the array, and the first time it returns a truthy value, the Array.findIndex() method will return the index of that element.
thisArg is an optional value that will be used as the this value inside the callback function. If thisArg is not specified, the this value will be undefined.

Here is an example of how to use the Array.findIndex() method:

Code snippet

const arr = [1, 2, 3, 4, 5];

const index = arr.findIndex(x => x % 2 === 0);

console.log(index); // 1

- Array.forEach:

The Array.forEach() method is an iterative method that calls a provided callback function once for each element in an array in ascending-index order. Unlike map(), forEach() always returns undefined and is not chainable. The typical use case is to execute side effects at the end of a chain.

The callback function is called with the following arguments:

element: The current element being processed in the array.
index: The index of the current element being processed in the array.
array: The array forEach() was called upon.

The callback function can modify the array, but it cannot change the length of the array.

Here is an example of how to use Array.forEach():

Code snippet

const array = [1, 2, 3, 4, 5];

array.forEach((element, index) => {
  console.log(`The element at index ${index} is ${element}`);
});

The callback function is called with the following arguments:

element: The current element being processed in the array.
index: The index of the current element being processed in the array.
array: The array forEach() was called upon.

The callback function can modify the array, but it cannot change the length of the array.

Here is an example of how to use Array.forEach():

Code snippet

const array = [1, 2, 3, 4, 5];

array.forEach((element, index) => {
  console.log(`The element at index ${index} is ${element}`);
});

Use code with caution. Learn more

content_copy

This code will print the following to the console:

Code snippet

The element at index 0 is 1
The element at index 1 is 2
The element at index 2 is 3
The element at index 3 is 4
The element at index 4 is 5

- Array.map:

The Array.map() method is an iterative method that creates a new array from the results of calling a provided function on every element in the calling array. The callback function is called with the following arguments:

element: The current element being processed in the array.
index: The index of the current element being processed in the array.
array: The array map() was called upon.

The callback function must return a value, which will be the corresponding element in the new array.

Here is an example of how to use Array.map():

Code snippet

const array = [1, 2, 3, 4, 5];

const newArray = array.map((element) => {
  return element * 2;
});

console.log(newArray); // [2, 4, 6, 8, 10]

- Array.filter:

The Array.filter() method is an iterative method that creates a new array from the elements of an existing array that pass a test implemented by a provided function. The callback function is called with the following arguments:

element: The current element being processed in the array.
index: The index of the current element being processed in the array.
array: The array filter() was called upon.

The callback function must return a Boolean value, which will be used to determine whether the element is included in the new array. If the callback function returns true, the element is included in the new array. If the callback function returns false, the element is not included in the new array.

Here is an example of how to use Array.filter():

Code snippet

const array = [1, 2, 3, 4, 5];

const newArray = array.filter((element) => {
  return element % 2 === 0;
});

console.log(newArray); // [2, 4]

- Array.reduce:

The Array.reduce() method is a recursive method that applies a function to each element of an array, from left to right, and returns a single value. The callback function is called with the following arguments:

accumulator: The current value of the accumulator.
element: The current element being processed in the array.
index: The index of the current element being processed in the array.
array: The array reduce() was called upon.

The callback function must return a value, which will be the new value of the accumulator.

Here is an example of how to use Array.reduce():

const array = [1, 2, 3, 4, 5];

const sum = array.reduce((accumulator, element) => {
  return accumulator + element;
}, 0);

console.log(sum); // 15

- Array.sort:

The Array.sort() method in JavaScript is used to sort the elements of an array in place. By default, the sort() method sorts the array elements in ascending order with the smallest value first and largest value last. The sort() method casts elements to strings and compares the strings to determine the orders.

The following is an example of how to use the Array.sort() method to sort an array of numbers in ascending order:

Code snippet

const numbers = [10, 5, 2, 1, 8, 7, 6, 3, 4, 9];

numbers.sort();

console.log(numbers); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

- Array methods chaining:

JavaScript chaining is a technique that allows you to call multiple methods on an object in a single statement. This can make your code more concise and easier to read.

To chain methods, you simply separate the method names with periods (.). For example, the following code chains the toUpperCase() and slice() methods on the str variable:

Code snippet

str.toUpperCase().slice(0, 5);

This code will return the first five characters of str in uppercase letters.

- String methods - add codeblocks and mention mutable/immutable;

Mutable and Immutable Methods (in strings);

There are a number of methods in JavaScript that can be used to manipulate strings. Some of these methods are mutable, while others are immutable.

Mutable methods

concat(): This method concatenates the specified string to the end of the current string.
replace(): This method replaces all occurrences of the specified substring with the specified replacement string.
slice(): This method returns a new string that is a substring of the current string.

Immutable methods

toUpperCase(): This method returns a new string that is the uppercase version of the current string.
toLowerCase(): This method returns a new string that is the lowercase version of the current string.
trim(): This method returns a new string that has all leading and trailing whitespace characters removed.

toLocaleUpperCase() : Converts a string to uppercase, based on the current locale.

Code snippet

const str = "Hello";
const uppercaseStr = str.toLocaleUpperCase(); // "HELLO"

const str = "Hello";
const repeatedStr = str.repeat(3); // "HelloHelloHello"

trim() : Removes whitespace from the beginning and end of a string.

Code snippet

const str = "   Hello, world!   ";
const trimmedStr = str.trim(); // "Hello, world!"

substring() : Extracts a substring from a string.

Code snippet

const str = "Hello, world!";
const substring = str.substring(0, 5); // "Hello"

split() : Splits a string into an array of substrings based on a delimiter.

Code snippet

const str = "Hello, world!";
const arrayOfSubstrings = str.split(","); // ["Hello", "world!"]

** slice()** : Extracts a substring from a string.

Code snippet

const str = "Hello, world!";
const substring = str.slice(0, 5); // "Hello"

replace() : Replaces all occurrences of a substring in a string with another string.

Code snippet

const str = "Hello, world!";
const newStr = str.replace("world", "universe"); // "Hello, universe!"

indexOf() : Returns the index of the first occurrence of a substring in a string.

Code snippet

const str = "Hello, world!";
const index = str.indexOf("world"); // 6

concat() : Concatenates two or more strings.

Code snippet

const str1 = "Hello, ";
const str2 = "world!";
const combinedStr = str1.concat(str2); // "Hello, world!"

- Object methods and operations - add codeblocks and mention mutable/immutable:

keys() : Returns an array of the object's property names.

Code snippet

const obj = {
  name: "John Doe",
  age: 30
};

const propertyNames = Object.keys(obj);

values() : Returns an array of the object's property values.

Code snippet

const obj = {
  name: "John Doe",
  age: 30
};

const propertyValues = Object.values(obj); // ["John Doe", 30]

entries() : Returns an array of tuples, where each tuple contains a property name and its value.

Code snippet

const obj = {
  name: "John Doe",
  age: 30
};

const propertyEntries = Object.entries(obj); // [["name", "John Doe"], ["age", 30]]

get() : Returns the value of the object's property with the specified name.

Code snippet

const obj = {
  name: "John Doe",
  age: 30
};

const name = obj.get("name"); // "John Doe"

set() : Sets the value of the object's property with the specified name.

Code snippet

const obj = {
  name: "John Doe"
};

obj.set("age", 30);

const age = obj.get("age"); // 30

deleteProperty() : Deletes the object's property with the specified name.

Code snippet

const obj = {
  name: "John Doe"
};

delete obj.name;

console.log(obj.name); // undefined

toString() : Returns a string representation of the object.

Code snippet

const obj = {
  name: "John Doe",
  age: 30
};

const stringRepresentation = obj.toString(); // "{name: 'John Doe', age: 30}"

Hoisting in JS:

Sure, hoisting in JavaScript is the process of moving all variable and function declarations to the top of their scope, before any code is executed. This means that even if you declare a variable or function below where it is used, it will still be available in the scope where it is used.

For example, the following code will print "Hello, world!" even though the greet() function is declared below the console.log() statement:

Code snippet

function greet() {
  console.log("Hello, world!");
}

greet();

This is because the greet() function is hoisted to the top of the scope where it is defined.

Hoisting can be a bit confusing at first, but it is an important concept to understand in JavaScript. By understanding hoisting, you can avoid errors in your code and write more efficient code.

Here are some things to keep in mind about hoisting:

Only variable and function declarations are hoisted. Expressions are not hoisted.
Hoisting does not affect the order of execution of your code. The code will still be executed in the order in which it is written.
Hoisting can be used to your advantage. For example, you can use hoisting to declare variables that are only used in one part of your code. This can make your code more readable and easier to maintain.

Scopes:

In JavaScript, a scope is a region of code where a variable is accessible. There are three types of scopes in JavaScript:

Global scope: The global scope is the outermost scope in a JavaScript program. Variables declared in the global scope are accessible from anywhere in the program.
Function scope: A function scope is created when a function is defined. Variables declared in a function scope are only accessible from within that function.
Block scope: A block scope is created when a block of code is enclosed in curly braces ({}). Variables declared in a block scope are only accessible from within that block.

When you declare a variable, the JavaScript engine will create a new entry in the current scope's symbol table. The symbol table is a data structure that stores information about all of the variables in a scope. When you access a variable, the JavaScript engine will look up the variable's name in the current scope's symbol table. If the variable is found, the engine will return the variable's value. If the variable is not found, the engine will throw an error.

It is important to understand scopes in JavaScript in order to avoid errors in your code. For example, if you declare a variable in a function scope and then try to access it outside of the function, you will get an error.

Here are some tips for using scopes in JavaScript:

Declare variables in the smallest scope possible. This will make your code more readable and easier to maintain.
Use descriptive variable names. This will help you to understand what each variable is used for.
Use the let and const keywords to declare variables. These keywords will help you to avoid errors caused by accidentally overwriting variables.

Closures:

A closure is a function that has access to variables that are declared in an outer scope. This means that the function can access those variables even after the outer scope has closed. Closures are a powerful tool that can be used to create reusable code and to implement complex functionality.

To create a closure, you need to define a function inside of another function. The inner function will have access to all of the variables that are declared in the outer function, even after the outer function has returned.

For example, the following code defines a function called makeCounter() that returns a function that increments a counter. The makeCounter() function creates a closure around the counter variable. This means that the increment() function will be able to access the counter variable even after the makeCounter() function has returned.

Code snippet

function makeCounter() {
  let counter = 0;

  function increment() {
    counter++;
    return counter;
  }

  return increment;
}

const counter = makeCounter();

console.log(counter()); // 1
console.log(counter()); // 2

In this example, the increment() function is able to access the counter variable because it is defined inside of the makeCounter() function. The makeCounter() function returns the increment() function, which means that the increment() function can be used outside of the makeCounter() function.

Closures can be used to create reusable code. For example, you could define a function that takes a callback function as an argument. The callback function would then be able to access any variables that are declared in the outer function. This allows you to encapsulate functionality in a function and then reuse that functionality in other parts of your code.

Closures can also be used to implement complex functionality. For example, you could use closures to create a timer function that keeps track of the time that has passed since the function was called. The timer function could then be used to implement features such as a countdown timer or a stopwatch.

Closures are a powerful tool that can be used to create reusable code and to implement complex functionality. If you are not familiar with closures, I encourage you to learn more about them. They can be a valuable asset in your JavaScript toolkit.

- Debugging:

Debugging in JavaScript can be a challenge, but there are a number of tools and techniques that can help you find and fix errors in your code.

One of the most basic debugging techniques is to use the console.log() function to print the values of variables and expressions to the console. This can be helpful for tracking down the source of an error.

Another useful debugging technique is to use breakpoints. Breakpoints allow you to pause the execution of your code at a specific point. This can be helpful for inspecting the values of variables and expressions at a specific point in the code.

There are a number of different debugging tools available for JavaScript. Some popular debugging tools include:

Chrome DevTools: Chrome DevTools is a powerful debugging tool that is built into the Chrome web browser. Chrome DevTools allows you to inspect the DOM, the JavaScript code, and the network traffic for a web page.

Opens in a new window Chrome Developers

Chrome DevTools in Google Chrome

Node Inspector: Node Inspector is a debugging tool for Node.js applications. Node Inspector allows you to inspect the JavaScript code, the environment variables, and the system logs for a Node.js application.

Opens in a new window GeeksforGeeks

Node Inspector in Node.js

WebStorm: WebStorm is a commercial IDE for JavaScript development. WebStorm includes a powerful debugger that allows you to inspect the JavaScript code, the DOM, and the network traffic for a web page.

Opens in a new window JetBrains

WebStorm IDE

No matter what debugging tool you choose, the most important thing is to be patient and persistent. Debugging can be a time-consuming process, but it is essential for finding and fixing errors in your code.

Here are some additional tips for debugging JavaScript code:

Start by isolating the problem. Try to narrow down the problem to a specific part of your code. This can be done by using breakpoints and the console.log() function.
Use the debugger's features to inspect the code. The debugger's features can be used to inspect the values of variables, the structure of the code, and the execution of the code.
Be patient and persistent. Debugging can be a time-consuming process, but it is essential for finding and fixing errors in your code.

Technical Paper on HTML/CSS

Atchukola Naresh — Wed, 24 May 2023 12:48:25 +0000

CSS Box Model:

The CSS box model is a way of representing HTML elements in CSS. It consists of four parts:

Content - This is the actual content of the element, such as text or images.
Padding - This is the space between the content and the border.
Border - This is the line that surrounds the content and padding.
Margin - This is the space between the border and other elements on the page.

The following image shows the different parts of the box model:

The size of the box is determined by the sum of the widths and heights of the content, padding, border, and margin. For example, if the content is 100px wide, the padding is 20px, the border is 10px, and the margin is 10px, then the total width of the box will be 140px.

The CSS box model can be used to control the appearance of HTML elements in a variety of ways. For example, you can use the padding property to add space around the content, the border property to add a border around the element, and the margin property to add space between the element and other elements on the page.

Here are some examples of how to use the CSS box model to style HTML elements:

CSS

p {
  padding: 10px;
  border: 1px solid black;
  margin: 5px;
}

This code will add a 10px padding, a 1px solid black border, and a 5px margin to all paragraphs on the page.

CSS

div {
  padding: 10px;
  border: 1px solid black;
  margin: 5px;
  background-color: blue;
}

This code will add a 10px padding, a 1px solid black border, a 5px margin, and a blue background color to all div elements on the page.

The CSS box model is a powerful tool that can be used to control the appearance of HTML elements in a variety of ways. By understanding the different parts of the box model and how to use the CSS properties that control them, you can create custom styles that will make your web pages look their best.

- Inline versus Block Elements. Examples:

some examples of inline and block elements in CSS:

Inline Elements

<a>
<img>
<span>
<br>
<em>
<strong>

Block Elements

<div>
<p>
<h1>
<h2>
<ul>
<li>

Inline elements are displayed inline with the surrounding text, while block elements start on a new line and take up the full width of their container.

Here is an example of how inline and block elements are displayed:

HTML

<p>This is a paragraph.</p>

<div>This is a div element.</div>

<a href="#">This is a link.</a>

The paragraph will be displayed on a new line, while the div element and the link will be displayed inline with the surrounding text.

You can use the display property to change the display type of an element. For example, the following code will change the display type of the div element to inline:

CSS

div {
  display: inline;
}

This will cause the div element to be displayed inline with the surrounding text, just like the link element.

You can also use the display property to create custom layouts. For example, the following code will create a two-column layout:

CSS

div {
  display: inline-block;
}

This will cause the div elements to be displayed side-by-side, with a small gap between them.

The display property is a powerful tool that can be used to control the layout of your web pages. By understanding the different display types and how to use them, you can create custom layouts that will make your pages look their best.

Positioning: Relative/Absolute:

Static: The default value. Elements with static positioning are placed in the document flow according to their source order.
Relative: Elements with relative positioning are positioned relative to their original position in the document flow. This means that they can be moved around using the top, left, bottom, and right properties.
Absolute: Elements with absolute positioning are positioned relative to the nearest positioned ancestor element. If there is no positioned ancestor element, then the element is positioned relative to the html element. Absolute positioned elements are removed from the document flow, and they do not affect the layout of other elements on the page.
Fixed: Elements with fixed positioning are positioned relative to the viewport. This means that they stay in the same place on the page, even when the user scrolls. Fixed positioned elements are also removed from the document flow.

Here is an example of how to use relative positioning to move an element 10 pixels to the right:

Code snippet

.my-element {
  position: relative;
  right: 10px;
}

Here is an example of how to use absolute positioning to position an element 10 pixels to the right of its nearest positioned ancestor:

Code snippet

.my-element {
  position: absolute;
  right: 10px;
}

Common CSS structural classes:

:first-child - Selects the first child of its parent.
:last-child - Selects the last child of its parent.
:only-child - Selects an element that is the only child of its parent.
:nth-child(n) - Selects every nth child of its parent. For example, :nth-child(2) will select every second child.
:nth-of-type(n) - Selects every nth element of a particular type within its parent. For example, :nth-of-type(2) div will select every second div within its parent.
:nth-last-child(n) - Selects every nth child of its parent, counting from the last child. For example, :nth-last-child(2) will select every second child, starting from the last child.
:nth-last-of-type(n) - Selects every nth element of a particular type within its parent, counting from the last child. For example, :nth-last-of-type(2) div will select every second div, starting from the last div.
:first-of-type - Selects the first element of a particular type within its parent. For example, :first-of-type div will select the first div within its parent.
:last-of-type - Selects the last element of a particular type within its parent. For example, :last-of-type div will select the last div within its parent.
:only-of-type - Selects an element that is the only element of a particular type within its parent. For example, :only-of-type div will select a div if it is the only div within its parent.

Common CSS styling classes:

.active: This class is used to style the currently active element, such as a link or button.
.error: This class is used to style elements that have errors, such as form fields with invalid input.
.info: This class is used to style elements that contain informational content.
.success: This class is used to style elements that have been successfully processed, such as form submissions.
.warning: This class is used to style elements that contain warnings or cautions.

These are just a few examples of common CSS styling classes. There are many other possible classes that can be used to style different elements on a web page.

Here are some examples of how these classes can be used:

CSS

.active {
  color: red;
  font-weight: bold;
}

.error {
  background-color: red;
  color: white;
}

.info {
  background-color: lightblue;
  color: black;
}

.success {
  background-color: green;
  color: white;
}

.warning {
  background-color: yellow;
  color: black;
}

These styles can be applied to any element on a web page by adding the appropriate class to the element's HTML tag. For example, to style a link as active, you would add the active class to the a tag.

HTML

<a href="#">This is an active link</a>

The CSS styles would then be applied to this link, making it appear red and bold.

By using CSS styling classes, you can easily style different elements on a web page. This makes it possible to create a consistent look and feel for your website.

CSS Specificity:

CSS specificity is a way of determining which CSS rule will be applied to an element when there are multiple rules that could apply. The rule with the highest specificity will be applied.

Specificity is calculated by counting the number of IDs, classes, and elements in the selector. The more of each type of selector, the higher the specificity.

For example, the following selector has a specificity of 1000:

Code snippet

#myID.myClass

This is because it has one ID selector (#myID) and one class selector (.myClass).

The following selector has a specificity of 10:

Code snippet

.myClass

This is because it has one class selector (.myClass).

The following selector has a specificity of 1:

Code snippet

div

This is because it has one element selector (div).

If there are two rules that could apply to an element, the rule with the higher specificity will be applied. For example, the following two rules could both apply to an element:

Code snippet

#myID.myClass {
  color: red;
}

.myClass {
  color: blue;
}

The first rule has a specificity of 1000 and the second rule has a specificity of 10. Therefore, the first rule will be applied and the element will be red.

You can use specificity to override other CSS rules. For example, if you want to make sure that an element always has a certain color, you can use a rule with a high specificity. For example, the following rule will always make the element red, no matter what other rules are applied:

Code snippet

#myID {
  color: red;
}

You can also use specificity to make sure that a rule only applies to a certain element or set of elements. For example, the following rule will only apply to the element with the ID myID:

Code snippet

#myID {
  color: red;
}

Specificity can be a bit confusing at first, but it is a very powerful tool that can help you control how CSS rules are applied.

CSS Responsive Queries:

CSS responsive queries are a way to control how CSS styles are applied to a web page based on the size of the screen. This allows you to create a website that looks good on all devices, from large desktop monitors to small mobile phones.

To use CSS responsive queries, you need to use the @media rule. The @media rule allows you to specify a set of CSS rules that will only be applied if the screen meets certain criteria. For example, you could use the @media rule to specify a different layout for a mobile phone than you would for a desktop computer.

The syntax for the @media rule is as follows:

Code snippet

@media media_query {
  /* CSS rules */
}

The media_query is a string that specifies the criteria that the screen must meet in order for the CSS rules to be applied. For example, the following media_query would specify that the CSS rules should only be applied if the screen is less than 600 pixels wide:

Code snippet

@media screen and (max-width: 600px) {
  /* CSS rules */
}

You can use a variety of media queries to specify different criteria. For example, you could use the min-width media query to specify that the CSS rules should only be applied if the screen is at least a certain width. You could also use the orientation media query to specify that the CSS rules should only be applied if the screen is in landscape or portrait mode.

Once you have defined your @media rule, you can then specify the CSS rules that you want to apply. These rules will only be applied if the screen meets the criteria that you specified in the media_query.

For example, the following code would specify that the h1 element should be displayed in a larger font size on mobile phones:

Code snippet

@media screen and (max-width: 600px) {
  h1 {
    font-size: 2em;
  }
}

CSS responsive queries are a powerful tool that can help you create a website that looks good on all devices. By using CSS responsive queries, you can ensure that your website is accessible to everyone, regardless of the device they are using.

Flexbox/Grid:

Flexbox and Grid are two different CSS layout models that can be used to create complex and responsive layouts.

Flexbox is a newer layout model that is designed for flexibility and responsiveness. It is based on the concept of a flex container, which can contain any number of flex items. The flex items can be arranged in a single row or column, or they can be arranged in a grid.

Grid is an older layout model that is designed for more complex layouts. It is based on the concept of a grid container, which can contain any number of grid items. The grid items can be arranged in a grid of any size, and they can be positioned anywhere in the grid.

Both Flexbox and Grid are powerful layout models that can be used to create complex and responsive layouts. However, they have different strengths and weaknesses.

Flexbox is a good choice for layouts that need to be flexible and responsive. It is easy to learn and use, and it can be used to create a wide variety of layouts.

Grid is a good choice for layouts that need to be more complex. It is more powerful than Flexbox, and it can be used to create layouts that are not possible with Flexbox.

Ultimately, the best choice for you will depend on the specific needs of your layout. If you need a flexible and responsive layout, then Flexbox is a good choice. If you need a more complex layout, then Grid is a good choice.

Here are some examples of how Flexbox and Grid can be used to create layouts:

Flexbox

A simple layout with a header, body, and footer:

Code snippet

<div class="container">
  <header>
    <h1>This is the header</h1>
  </header>
  <main>
    <p>This is the main content</p>
  </main>
  <footer>
    <p>This is the footer</p>
  </footer>
</div>

A layout with a sidebar and main content area:

Code snippet

<div class="container">
  <aside class="sidebar">
    <ul>
      <li><a href="#">This is a link</a></li>
      <li><a href="#">This is another link</a></li>
      <li><a href="#">This is one more link</a></li>
    </ul>
  </aside>
  <main>
    <p>This is the main content</p>
  </main>
</div>

Grid

A simple layout with a grid of images:

Code snippet

<div class="container">
  <div class="row">
    <div class="col-md-4">
      <img src="image1.jpg" alt="Image 1">
    </div>
    <div class="col-md-4">
      <img src="image2.jpg" alt="Image 2">
    </div>
    <div class="col-md-4">
      <img src="image3.jpg" alt="Image 3">
    </div>
  </div>
</div>

A layout with a grid of images and text:

Code snippet

<div class="container">
  <div class="row">
    <div class="col-md-4">
      <img src="image1.jpg" alt="Image 1">
      <h2>This is the title</h2>
      <p>This is the text</p>
    </div>
    <div class="col-md-4">
      <img src="image2.jpg" alt="Image 2">
      <h2>This is another title</h2>
      <p>This is another text</p>
    </div>
    <div class="col-md-4">
      <img src="image3.jpg" alt="Image 3">
      <h2>This is one more title</h2>
      <p>This is one more text</p>
    </div>
  </div>
</div>

As you can see, both Flexbox and Grid can be used to create a wide variety of layouts. The best choice for you will depend on the specific needs of your layout.

Common header meta tags:

Title: The title meta tag is used to specify the title of the page. This title is displayed in the browser's title bar and in search engine results pages (SERPs).

HTML

<meta name="title" content="This is the title of the page">

Description: The description meta tag is used to provide a brief description of the page. This description is displayed in SERPs, and it can help users decide whether or not to click on your link.

HTML

<meta name="description" content="This is a brief description of the page">

Keywords: The keywords meta tag is used to specify the keywords that are relevant to the page. This information can be used by search engines to index your page and to rank it in search results.

HTML

<meta name="keywords" content="keyword1, keyword2, keyword3">

Robots: The robots meta tag is used to control how search engines crawl and index your page. For example, you can use the robots meta tag to prevent search engines from crawling your sitemap or from indexing your contact page.

HTML

<meta name="robots" content="index, follow">

Viewport: The viewport meta tag is used to control the initial size of the browser window. This can be useful for mobile devices, where you may want to specify a smaller initial window size.

HTML

<meta name="viewport" content="width=device-width, initial-scale=1">

Content-Type: The Content-Type meta tag is used to specify the MIME type of the page. This information is used by the browser to determine how to render the page.

HTML

<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

Refresh: The Refresh meta tag is used to automatically refresh the page after a specified amount of time. This can be useful for pages that display news or other time-sensitive information.

HTML

<meta http-equiv="refresh" content="30">

Author: The Author meta tag is used to specify the author of the page. This information can be displayed in SERPs, and it can help users to identify the source of the information.

HTML

<meta name="author" content="John Doe">

Copyright: The Copyright meta tag is used to specify the copyright information for the page. This information can be displayed in SERPs, and it can help users to understand the terms of use for the page.

HTML

<meta name="copyright" content="Copyright 2023, John Doe">

Noindex: The Noindex meta tag is used to prevent search engines from indexing the page. This can be useful for pages that are not intended to be indexed, such as login pages or private pages.

HTML

<meta name="robots" content="noindex">

Nofollow: The Nofollow meta tag is used to prevent search engines from following links on the page. This can be useful for pages that contain spammy or irrelevant links.

HTML

<a href="https://www.spammywebsite.com" rel="nofollow">This is a spammy link</a>

These are just a few of the most common header meta tags. There are many other meta tags that can be used, and the specific meta tags that you use will depend on the needs of website.

Inheritence:

Inheritance in CSS and HTML is the ability of an element to inherit properties from its parent element. This can be used to save time and effort when styling a web page, as you only need to specify the properties once on the parent element and they will be inherited by all child elements.

To inherit a property in CSS, you use the inherit keyword. For example, the following code will set the font size of all p elements to 16px:

CSS

p {
  font-size: 16px;
}

This will also set the font size of all child elements of p elements, such as span elements.

In HTML, inheritance is used to determine the default values of attributes. For example, the href attribute of the a element has a default value of #. This means that if you do not specify an href attribute on an a element, it will link to the current page.

Inheritance can be a powerful tool when used correctly. However, it is important to understand how it works so that you can avoid unintended consequences. For example, if you set the color property of a parent element to red, all child elements will also be red, even if you have explicitly set the color property of a child element to a different color.

To avoid this, you can use the !important keyword to override the inherited value of a property. For example, the following code will set the color property of the span element to blue, even though the color property of the p element is set to red:

CSS

p {
  color: red;
}

span {
  color: blue !important;
}

S.O.L.I.D Principles

Atchukola Naresh — Mon, 15 May 2023 10:36:35 +0000

SOLID Principles

These are the oldest principles but we are still using these priciples due to maintains's
OO systems improve reusabulity and easy testing.

S.O.L.I.D

SRP - Single responsibility principle
DIP - Dependency inversion principle
OCP - Open/closed principle
LSP - Liskov substitution principle
ISP - Interface segregation principle

SRP - Single responsibility principle:

A class should have only one responsibilty all the methods should be associated with the
that responsibility.

example:

class Email:
    def __init__(self, subject, body, sender, recipient):
         self.subject = subject
        self.body = body
        self.sender = sender
        self.recipient = recipien
class EmailSender:
    def send_email(self, email):
        # Code to send the email using the SMTP server
        pass
class EmailSaver:
    def save_email(self, email):
        # Code to save the email to a database
        pass

In this example, we have separate classes for each responsibility: Email for storing email data, EmailSender for sending emails, and EmailSaver for saving emails to a database. Each class has a single responsibility, making the system easier to understand, modify, and maintain.

OCP - Open/closed principle :

The Open-Closed Principle (OCP) is a fundamental principle in object-oriented programming that states that software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. In other words, the behavior of a system should be extendable without modifying its existing code.

from abc import ABC, abstractmethod

# Abstract class representing a shape
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# Concrete implementation of a Rectangle shape
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

# Concrete implementation of a Circle shape
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

# Function that calculates the sum of areas for multiple shapes
def calculate_total_area(shapes):
    total_area = 0
    for shape in shapes:
        total_area += shape.area()
    return total_area

, if we want to add a Triangle shape, we can create a new class Triangle that inherits from Shape and provides its own implementation of the area() method. We can then pass an instance of Triangle to the calculate_total_area() function, and it will work seamlessly without modifying the existing code.

LSP - Liskov substitution principle:

The Liskov Substitution Principle (LSP) is a principle in object-oriented programming that states that objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program. In other words, if a program is designed to work with a certain type of object, it should also work correctly with any subtype of that object.

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"

def animal_sounds(animals):
    for animal in animals:
        print(animal.make_sound())

The animal_sounds() function demonstrates the Liskov Substitution Principle. It takes a list of Animal objects and calls the make_sound() method on each object. By designing the program to work with the Animal superclass, it can also work correctly with any subtype of Animal, such as Dog or Cat.

animals = [Dog(), Cat()]

animal_sounds(animals)

The animal_sounds() function doesn't need to know the exact type of each object in the list. It treats them all as Animal objects and calls the make_sound() method, which is overridden in the subclasses. As a result, it will print "Woof!" and "Meow!" without any issues.

ISP - Interface segregation principle:

The Interface Segregation Principle (ISP) is a principle in object-oriented programming that states that clients should not be forced to depend on interfaces they do not use. It suggests that classes should have narrowly focused interfaces, tailored to the specific needs of the clients that use them, rather than having large, bloated interfaces that encompass more functionality than necessary.

from abc import ABC, abstractmethod

# Interface for a document
class Document(ABC):
    @abstractmethod
    def open(self):
        pass

    @abstractmethod
    def close(self):
        pass

# Interface for a printable document
class Printable(ABC):
    @abstractmethod
    def print_document(self):
        pass

# Interface for a scannable document
class Scannable(ABC):
    @abstractmethod
    def scan_document(self):
        pass

# Implementation of a Word document
class WordDocument(Document, Printable):
    def open(self):
        print("Opening Word document")

    def close(self):
        print("Closing Word document")

    def print_document(self):
        print("Printing Word document")

# Implementation of a PDF document
class PdfDocument(Document, Printable, Scannable):
    def open(self):
        print("Opening PDF document")

    def close(self):
        print("Closing PDF document")

    def print_document(self):
        print("Printing PDF document")

    def scan_document(self):
        print("Scanning PDF document")

# Client code that only depends on the required interfaces
def print_document(printable):
    printable.print_document()

def scan_document(scannable):
    scannable.scan_document()

The client code demonstrates the usage of the specific interfaces. The print_document() function only depends on the Printable interface, allowing it to print any document that implements that interface. Similarly, the scan_document() function only depends on the Scannable interface, allowing it to scan any document that implements that interface.

DIP - Dependency inversion principle :

The Dependency Inversion Principle (DIP) is a principle in object-oriented programming that states that high-level modules should not depend on low-level modules. Instead, both should depend on abstractions. It suggests that the dependencies between modules should be based on abstractions rather than concrete implementations.

from abc import ABC, abstractmethod

# Abstract class representing a notifier
class Notifier(ABC):
    @abstractmethod
    def send_notification(self, message):
        pass

# High-level module that depends on the Notifier abstraction
class NotificationService:
    def __init__(self, notifier):
        self.notifier = notifier

    def send_notification(self, message):
        self.notifier.send_notification(message)

# Low-level module that implements the Notifier abstraction
class EmailNotifier(Notifier):
    def send_notification(self, message):
        print(f"Sending email notification: {message}")

# Low-level module that implements the Notifier abstraction
class SMSNotifier(Notifier):
    def send_notification(self, message):
        print(f"Sending SMS notification: {message}")

By having the NotificationService depend on the Notifier abstraction rather than concrete implementations, we adhere to the Dependency Inversion Principle. The NotificationService is not tightly coupled to specific notifiers (e.g., EmailNotifier or SMSNotifier), but instead depends on the abstraction provided by the Notifier class. This allows for flexibility and extensibility in the system. We can introduce new notifiers by creating classes that implement the Notifier interface, and the NotificationService will work with them without any modifications.

email_notifier = EmailNotifier()
sms_notifier = SMSNotifier()

notification_service = NotificationService(email_notifier)
notification_service.send_notification("Hello, this is an email notification")

notification_service = NotificationService(sms_notifier)
notification_service.send_notification("Hello, this is an SMS notification")

DBMS Technical Paper

Atchukola Naresh — Fri, 12 May 2023 13:48:00 +0000

ACID Properties:

Introduction to ACID Properties in DBMS

ACID Properties in DBMS ensure consistency and reliability in transactions. For example, when two users try to book the same train ticket, the user who clicks the 'Book Now' button first is given preference. Without ACID Properties, both users could end up with a confirmed ticket, causing problems. ACID Properties prevent errors and maintain consistency, which is crucial when multiple users are trying to book/purchase the same thing

What are ACID Properties in DBMS?

ACID properties are a set of properties that guarantee reliable processing of transactions in a database management system (DBMS). Transactions are a sequence of database operations that are executed as a single unit of work, and the ACID properties ensure that transactions are processed reliably and consistently in a DBMS.

The Atomicity property ensures that a transaction is either executed completely or not at all. The Consistency property ensures that the database remains in a consistent state before and after a transaction. The Isolation property ensures that multiple transactions can run concurrently without interfering with each other. The Durability property ensures that the results of a committed transaction are permanent and cannot be lost due to system failure.

Together, these properties ensure that transactions are processed reliably and consistently in a DBMS, which is essential for the integrity and accuracy of data in a database.

1. Atomicity in DBMS

The term atomicity is the ACID Property in DBMS that refers to the fact that the data is kept atomic. It means that if any operation on the data is conducted, it should either be executed completely or not at all. It also implies that the operation should not be interrupted or just half completed. When performing operations on a transaction, the operation should be completed totally rather than partially. If any of the operations aren’t completed fully, the transaction gets aborted.

Sometimes, a current operation will be running and then, an operation with a higher priority enters. This discontinues the current operation and the current operation will be aborted.

In the example above, if we consider the case that both users get notified that the seat is booked and neither of them is allowed to be seated because only one seat is available on the train, that is a half-fulfilled transaction. The transaction would be complete if they were able to be seated as well. Instead, according to atomicity, the person who clicks the button first books the seat and gets the notification of having purchased a ticket, and the seats left are updated. The second person’s transaction is rolled back and they are notified that no more seats are available. Let us consider an easier example where one person is trying to book a ticket. They were able to select their seat and reach the payment gateway. But, due to bank server issues, the payment could not go through. Does this mean that their booked seat will be reserved for them?

No. This is because one full transaction means reserving your seat and paying for it as well. If any of the steps fail, the operation will be aborted and you will be brought back to the initial state.

Atomicity in DBMS is often referred to as the ‘all or nothing’ rule.

2. Consistency in DBMS

This ACID Property will verify the total sum of seats left in the train+sum of seats booked by users=total the number of seats present in the train. After each transaction, consistency is checked to ensure nothing has gone wrong.

Let us consider an example where one person is trying to book a ticket. They are able to reserve their seat but their payment hasn’t gone through due to bank issues. In this case, their transaction is rolled back. But just doing that isn’t sufficient. The number of available seats must also be updated. Otherwise, if it isn’t updated, there will be an inconsistency where the seat given up by the person is not accounted for. Hence, the total sum of seats left in the train + the sum of seats booked by users would not be equal to the total number of seats present in the train if not for consistency.

3. Isolation in DBMS

Isolation is defined as a state of separation. Isolation is an ACID Property in DBMS where no data from one database should impact the other and where many transactions can take place at the same time. In other words, when the operation on the first state of the database is finished, the process on the second state of the database should begin. It indicates that if two actions are conducted on two different databases, the value of one database may not be affected by the value of the other. When two or more transactions occur at the same time in the case of transactions, consistency should be maintained. Any modifications made in one transaction will not be visible to other transactions until the change is committed to the memory.

Let us use our example of 2 people trying to book the same seat to understand this ACID Property. Two transactions are happening at the same item on the same database, but in isolation. To ensure that one transaction doesn’t affect the other, they are serialized by the system. This is done so as to maintain the data in a consistent state. Let us consider that the two people that click ‘Book Now’, do so with a gap of a few seconds. In that case, the first person’s transaction goes through and he/she receives their ticket as well. The second person will not know of the same until the first person’s transaction is committed to memory. When the second person clicks on ‘Book Now’ and is redirected to the payment gateway, since the first person’s seat has already been booked, it will show an error notifying the user that no seats are left on the train.

4. Durability in DBMS

The ACID Property durability in DBMS refers to the fact that if an operation is completed successfully, the database remains permanent in the disk. The database’s durability should be such that even if the system fails or crashes, the database will survive. However, if the database is lost, the recovery manager is responsible for guaranteeing the database’s long-term viability. Every time we make a change, we must use the COMMIT command to commit the values.

Imagine a system failure or crash occurs in the railway management system and all the trains that everyone had booked have been removed from the system. That means millions of users would have paid the money for their seats but will not be able to board the train as all the details have been destroyed. This could lead to huge losses for the company as users would lose trust in them. In addition, it would create a lot of panics as these trains would be needed for important reasons as well.

CAP Theorem:

CAP Theorem is very imorantant while working with distributed environment.

Distributed enviroment:

a collection of independent components located on different machines that share messages with each other in order to achieve common goals.

The CAP theorem, originally introduced as the CAP principle, can be used to explain some of the competing requirements in a distributed system with replication. It is a tool used to make system designers aware of the trade-offs while designing networked shared-data systems.

The three letters in CAP refer to three desirable properties of distributed systems with replicated data: consistency (among replicated copies), availability (of the system for read and write operations) and partition tolerance (in the face of the nodes in the system being partitioned by a network fault).

The CAP theorem states that it is not possible to guarantee all three of the desirable properties – consistency, availability, and partition tolerance at the same time in a distributed system with data replication.

Consistency –

Consistency means that the nodes will have the same copies of a replicated data item visible for various transactions. A guarantee that every node in a distributed cluster returns the same, most recent and a successful write. Consistency refers to every client having the same view of the data. There are various types of consistency models. Consistency in CAP refers to sequential consistency, a very strong form of consistency.
Availability –

Availability means that each read or write request for a data item will either be processed successfully or will receive a message that the operation cannot be completed. Every non-failing node returns a response for all the read and write requests in a reasonable amount of time. The key word here is “every”. In simple terms, every node (on either side of a network partition) must be able to respond in a reasonable amount of time.
Partition Tolerance –

Partition tolerance means that the system can continue operating even if the network connecting the nodes has a fault that results in two or more partitions, where the nodes in each partition can only communicate among each other. That means, the system continues to function and upholds its consistency guarantees in spite of network partitions. Network partitions are a fact of life. Distributed systems guaranteeing partition tolerance can gracefully recover from partitions once the partition heals.

JOINS :

What are JOINS in SQL?

SQL Joins are mostly used when a user is trying to extricate data from multiple tables (which have one-to-many or many-to-many relationships with each other) at one time. The join keyword merges two or more tables and creates a temporary image of the merged table. Then according to the conditions provided, it extracts the required data from the image table, and once data is fetched, the temporary image of the merged tables is dumped.

Types of JOINS in SQL

INNER JOIN in SQL

SQL Inner Join or Equi Join is the simplest join where all rows from the intended tables are cached together if they meet the stated condition. Two or more tables are required for this join. Inner Join can be used with various SQL conditional statements like WHERE, GROUP BY, ORDER BY, etc.

General Syntax

SELECT column-name 
FROM table-1 INNER JOIN table-2 
WHERE table-1.column-name = table-2.column-name;

We can alternately use just the “JOIN” keyword instead of “INNER JOIN”.

Example

Special Case of INNER JOIN: NATURAL JOIN

SQL Natural Join is a type of Inner join based on the condition that columns having the same name and datatype are present in both the tables to be joined.

General Syntax

SELECT * FROM 
table-1 NATURAL JOIN table-2;

OUTER JOINS in SQL

SQL Outer joins give both matched and unmatched rows of data depending on the type of outer joins. These types are outer joins are sub-divided into the following types:

Left Outer Join
Right Outer Join
Full Outer Join

1. LEFT OUTER JOIN

In this join, a.k.a. SQL Left Join, all the rows of the left-hand table, regardless of following the stated conditions are added to the output table. At the same time, only matching rows of the right-hand table are added.

Rows belonging to the left-hand table and not having values from the right-hand table are presented as NULL values in the resulting table.

General Syntax

SELECT column-name(s)
FROM table1 LEFT OUTER JOIN table2
ON table1.column-name = table2.column-name;

2. RIGHT OUTER JOIN

Similar to the left outer join, in the case of the Right Outer Join, a.k.a. SQL Right Join, all the rows on the right-hand table, regardless of following the stated conditions, are added to the output table. At the same time, only matching rows of the left-hand table are added.

Rows belonging to the right-hand table and not having values from the left-hand table are presented as NULL values in the resulting table.

General Syntax

SELECT column-name(s)
FROM table1 RIGHT OUTER JOIN table2
ON table1.column-name = table2.column-name;

3. FULL OUTER JOIN

The full outer join (a.k.a. SQL Full Join) first adds all the rows matching the stated condition in the query and then adds the remaining unmatched rows from both tables. We need two or more tables for the join.

After the matched rows are added to the output table, the unmatched rows of the left-hand table are added with subsequent NULL values, and then unmatched rows of the right-hand table are added with subsequent NULL values.

General Syntax

SELECT column-name(s)
FROM table1 FULL OUTER JOIN table2
ON table1.column-name = table2.column-name;

- Aggregations, Filters in queries:

Aggregate functions in SQL are used to perform operations on multiple rows of a table and return a single value. A single function can be used to compute multiple values and return the required result.

Types of Aggregate Functions in SQL

Aggregate functions in SQL can be of the following types as shown in the figure. We will be understanding the working of these functions one by one.

1. COUNT() Function

The COUNT() aggregate function returns the total number of rows from a database table that matches the defined criteria in the SQL query.

Syntax:

COUNT(*) OR COUNT(COLUMN_NAME)

COUNT(*) returns the total number of rows in a given table. COUNT(COULUMN_NAME) returns the total number of non-null values present in the column which is passed as an argument in the function.

Let’s take a look at a few examples to understand the function better.

Example:

Suppose you want to know the total number of employees working in the organization. You can do so by the below-given query.

SELECT COUNT(*) FROM EMP_DATA;

As COUNT() returns the total number of rows and the table named EMP_DATA provided above consists of 10 rows, so the COUNT() function returns 10. The output is printed as shown below.

Output:

COUNT(*)
10

2. SUM() Function

The SUM() function takes the name of the column as an argument and returns the sum of all the non NULL values in that column. It works only on numeric fields(i.e the columns contain only numeric values). When applied to columns containing both non-numeric(ex - strings) and numeric values, only numeric values are considered. If no numeric values are present, the function returns 0.

Syntax:

The function name is SUM() and the name of the column to be considered is passed as an argument to the function.

SUM(COLUMN_NAME)

3.AVG() Function

The AVG() aggregate function uses the name of the column as an argument and returns the average of all the non NULL values in that column. It works only on numeric fields(i.e the columns contain only numeric values).

Note: When applied to columns containing both non-numeric (ex - strings) and numeric values, only numeric values are considered. If no numeric values are present, the function returns 0.

Syntax:

The function name is AVG() and the name of the column to be considered is passed as an argument to the function.

AVG(COLUMN_NAME)

4. MIN() Function

The MIN() function takes the name of the column as an argument and returns the minimum value present in the column. MIN() returns NULL when no row is selected.

Syntax:

The function name is MIN() and the name of the column to be considered is passed as an argument to the function.

MIN(COLUMN_NAME)

To understand this better, let’s take a look at some examples.

Example:

Suppose you want to find out what is the minimum salary that is provided by the organization. The MIN() function can be used here with the column name as an argument.

SELECT MIN(Salary) FROM EMP_DATA;

5. MAX() Function

The MAX() function takes the name of the column as an argument and returns the maximum value present in the column. MAX() returns NULL when no row is selected.

Syntax:

The function name is MAX() and the name of the column to be considered is passed as an argument to the function.

MAX(COLUMN_NAME)

FILTER CLAUSE

The filter clause is another tool for filtering in SQL. The filter clause is used to, as the name suggests, filter the input data to an aggregation function. They differ from the WHERE clause because they are more flexible than the WHERE clause. Only one WHERE clause can be used at a time in a query. While on the other hand, multiple FILTER clauses can be present in a single query.

Syntax

EXPRESSION
AGGREGATION FUNCTION 1
FILTER(WHERE CLAUSE)
AGGREGATION FUNCTION 2
FILTER(WHERE CLAUSE)
.
.
.
EXPRESSION

Example

SELECT COUNT(ID)
FILTER(WHERE ID!=2),
AVG(LENGTH(NAME))
FILTER(WHERE LENGTH(NAME)>4)
FROM TEST;

Input table:

MariaDB [db]> SELECT * FROM TEST;
+----+------------------+----------+
| ID | NAME             | EMPLOYED |
+----+------------------+----------+
|  1 | Drake Maverick   |        1 |
|  2 | Nancy Peloski    |        0 |
|  3 | Anakin Skywalker |        0 |
|  4 | Uchiha Obito     |        1 |
|  5 | Anakin Skywalker |        1 |
|  6 | Uchiha Obito     |        1 |
+----+------------------+----------+

Output:

+-------+-----------------------+
| COUNT | AVG                   |
+-------+-----------------------+
|5      | 13.8333333333333333   |
+-------+-----------------------+

In the above query, the number of rows that have an ID other than two is five. We are also printing the average length of names of length greater than 4.

Noramalization:

What is Normalization in SQL?

Let’s begin with why normalization in SQL was introduced originally by discussing the problem it solves. As we know, we’ve relations (or tables) where we store our data, and if you remember one part of DBMS talks about management, we need to manage this data efficiently. Let’s see the wrong way first.

The Three Problems Or Would Say Anomalies Are:

Insertion Anomaly
Deletion Anomaly
Modification Anomaly

Insertion anomaly means cases where you can’t insert data unless you have another dependent piece of information. To see this from the above example, we can’t insert teacher’s data unless we have student data (assuming the key is student_id).

Deletion anomaly means cases where deleting a record can mistakenly delete other prominent information which is in reality independent in nature. In the above example, deleting a student record will also delete the corresponding teacher’s record and that’s not what we want. That’s because let’s say if a student leaves the school and we’ve to delete their data then doing it would also delete corresponding teacher’s data and that’s not what we want because it doesn’t mean the teacher also left the school.

Modification anomaly means cases when instead of updating a single piece of information at one place we’ve to update it at multiple places. For example, student 1 and student 3 have the same subject, and that’s why they are allotted the same teacher. If we ever want to change this teacher name (for some reason) we’ve to do it at 2 places. Assume if they’re duplicated at tons of places then we’ve to do it at every place to provide consistent data. and this you can guess is really difficult here.

So, that’s why normalization. So let’s see now what normalization really is and how it solves these anomalies.

Normalization and Solving Anomalies

Normalization in SQL is nothing but a technique that prevents above-mentioned anomalies, i.e., insertion, deletion, and modification anomalies to happen and reduces data redundancy. It has some set of rules through which it makes this happen. It divides a big table into smaller tables until it doesn’t follow a set of rules and this process is called normalization.

Note: Data redundancy is nothing but a form of data that is duplicated at multiple places inside the database.

Normal Form

Please note the last line from the above paragraph “It divides a big table into smaller tables until it doesn’t follow a set of rules ”. What are these rules? Actually, we divide the normalization process into a set of normal forms. A normal form is nothing but a form of a table that follows some norms (rules) that prevent the above anomalies to some extent. We have a list of normal forms,

1NF
2NF
3NF
BCNF
4NF
5NF
6NF

Complexity to divide tables into a particular normal form increases as we go down. Also, as we go down, all tables should also follow all the normal forms mentioned above. Please read the above line once more. It’s important!

Also, in real-life databases that contain multiple tables, they all must be normalized and all the tables should follow the norms, not just one.

Indexes :

An Index is a special lookup table, built from one or more columns in the database table that speeds up fetching rows from the table or view. There are two types of indexes, Clustered and Non-Clustered Indexes.
A Clustered index is a type of index in which the data is physically sorted in a table. In the Database, there can be only one clustered index per table.
A Non-Clustered Index is a type of index in which a separate key-value structure from the actual data table is created, in which the key contains the column values (on which a Non-Clustered Index is declared) and each value corresponding to that key contain a pointer to the data row that contains the actual value.
There can be one or more Non-Clustered Indexes per table.
In a Clustered Index, the index is the main data and in a non-clustered index, the index is the copy of the main data.
Primary Keys of the table by default are the clustered index, to change the clustered index we have to remove the previous index, and then we can explicitly create a new clustered index.
Indexes can be created or dropped with no effect on the actual data table.

Transactions:

Introduction

You might have encountered a situation when your system got crashed due to some hardware or software issues and got rebooted to ensure that all the data is restored in a consistent state. This protection of user's data even in case of a system failure marks as one of the major advantages of database management system. Various transactions are done as a part of manipulating the data in a database, these transactions can be seen as a set of operations that are executed by the user program in DBMS. Execution of a similar transaction multiple times will lead to the generation of multiple transactions. For example, Withdrawing some amount of money from the ATM can be seen as a transaction that can be done multiple times also.

Operations in Transaction

A certain set of operations takes place when a transaction is done that is used to perform some logical set of operations. For example: When we go to withdraw money from ATM, we encounter the following set of operations:

Transaction Initiated
You have to insert an ATM card
Select your choice of language
Select whether savings or current account
Enter the amount to withdraw
Entering your ATM pin
Transaction processes
You collect the cash
You press finish to end transaction

The above mentioned are the set of operations done by you. But in the case of a transaction in DBMS there are three major operations that are used for a transaction to get executed in an efficient manner. These are:

1. Read/ Access Data 2. Write/ Change Data 3. Commit

Let's understand the above three sets of operations in a transaction with a real-life example of transferring money from Account1 to Account2.

Initial balance in both the banks before the start of the transaction

Account1 - ₹ 5000 Account2 - ₹ 2000

This data before the start of the transaction is stored in the secondary memory (Hard disk) which once initiated is bought to the primary memory (RAM) of the system for faster and better access.

Now for a transfer of ₹ 500 from Account1 to Account2 to occur, the following set of operations will take place.

Read (Account1) --> 5000 Account1 = Account1 - 500 Write (Account1) --> 4500 Read (Account2) --> 2000 Account2 = Account2 + 500 Write (Account2) --> 2500 commit

The COMMIT statement permanently saves the changes made by the current transaction. When a transaction is successful, COMMIT is applied. If the system fails before a COMMIT is applied, the transaction reaches its previous state after ROLLBACK.

After commit operation the transaction ends and updated values of Account1 = ₹ 4500 and Account2 = ₹ 2500. Every single operation that occurs before the commit is said to be in a partially committed state and is stored in the primary memory (RAM). After the transaction is committed, the updated data is accepted and updated in the secondary memory (Hard Disk).

If in some case, the transaction failed anywhere before committing, then that transaction gets aborted and have to start from the beginning as it can’t be continued from the previous state of failure. This is known as Roll Back. :::

Transaction States in DBMS

During the lifetime of a transaction, there are a lot of states to go through. These states update the operating system about the current state of the transaction and also tell the user about how to plan further processing of the transaction. These states decide the regulations which decide the fate of a transaction whether it will commit or abort.

The ROLLBACK statement undo the changes made by the current transaction. A transaction cannot undo changes after COMMIT execution.

Following are the different types of transaction States :

Active State: When the operations of a transaction are running then the transaction is said to be active state. If all the read and write operations are performed without any error then it progresses to the partially committed state, if somehow any operation fails, then it goes to a state known as failed state.
Partially Committed: After all the read and write operations are completed, the changes which were previously made in the main memory are now made permanent in the database, after which the state will progress to committed state but in case of a failure it will go to the failed state.
Failed State: If any operation during the transaction fails due to some software or hardware issues, then it goes to the failed state . The occurrence of a failure during a transaction makes a permanent change to data in the database. The changes made into the local memory data are rolled back to the previous consistent state.
Aborted State: If the transaction fails during its execution, it goes from failed state to aborted state and because in the previous states all the changes were only made in the main memory, these uncommitted changes are either deleted or rolled back. The transaction at this point can restart and start afresh from the active state.
Committed State: If the transaction completes all sets of operations successfully, all the changes made during the partially committed state are permanently stored and the transaction is stated to be completed, thus the transaction can progress to finally get terminated in the terminated state.
Terminated State: If the transaction gets aborted after roll-back or the transaction comes from the committed state, then the database comes to a consistent state and is ready for further new transactions since the previous transaction is now terminated.

Locking mechanism:

We are using MySQL database to execute the Lock mechanism. If you do not have MySQL, download it from here for your respective operating system.

1. Creating a Database

Syntax for creating a database:

CREATE DATABASE <database_name>;

USE <database_name>;

Creating a database named LOCKS in the MySQL database.

-- creating a LOCKS database in MySQL
CREATE DATABASE LOCKS;

-- activating the LOCKS database for use
USE LOCKS;

MySQL Workbench illustration of the above SQL commands:

2. Table Creation

Syntax for creating a table:

CREATE TABLE <table_name> (
    <column_name1> <data_type>,
    <column_name2> <data_type>,
    <column_name3> <data_type>,
   ...
);

Creating a table named employees in the LOCKS database.

CREATE TABLE employees (
    emp_id INT NOT NULL PRIMARY KEY,
    emp_name VARCHAR(255) NOT NULL,
    age INT,
    title VARCHAR(255),
    dept_no INT
);

3. Inserting Data into the Table

Syntax for inserting a row into the table:

INSERT INTO <table_name> VALUES (column1_value, column2_value, column2_value, ...);

Inserting values in the employees table.

INSERT INTO employees VALUES (101, "Abhishek", 22, "Software Engineer", 4);

INSERT INTO employees VALUES (102, "Yuvraj", 22, "Developer Advocate", 2);

4. View Table

Syntax to view table in the output:

SELECT * FROM <table_name>

Viewing the employees table.

SELECT * FROM employees;

5. Applying and Removing Locks

Two types of Lock can be placed on MySQL database resources:

READ Lock
WRITE Lock

These locks are discussed below:

READ LOCK in MySQL

In a READ lock (also known as a shared lock), the user can only read data from a table, and cannot modify the data.
Multiple sessions can obtain a READ lock for a table simultaneously. Other sessions can also read data from the table without having to acquire the lock.
The MySQL session with a READ lock in place can only read data from the table and cannot write anything until the READ lock is freed. Also, other sessions will not be unable to write data to the table. Write operations from another session will be kept in a running... state until the READ lock is freed.

Syntax to apply a READ lock:

LOCK TABLE <table_name> READ;

Syntax to remove lock:

UNLOCK TABLES;

This statement will remove the locks from the table of the active database.

Let's see how we can apply and remove a READ lock from the employees table.

First, create a MySQL connection in the MySQL workbench, connect to the MySQL database using your password, then use the below syntax to get your current MySQL session id.

SELECT connection_id();

Let's place a READ lock on the employees table now.

LOCK TABLE employees READ;

Now, let's try to UPDATE the title of emp_id = 101 to "Advanced Software Engineer".

UPDATE employees SET title="Advanced Software Engineer" where emp_id = 101;

MySQL throws an error as follows:

Error Code: 1099. Table 'employees' was locked with a READ lock and can't be updated

We can see that, we can't write/modify our table contents once we have applied a READ lock on the employees table. Let's try to modify the content of the table from a different session.

Let's create another MySQL connection in the MySQL workbench, again connect to the MySQL database using your password, then use the below syntax to get your current MySQL session id.

SELECT connection_id();

Again, let's try to run the same query.

UPDATE employees SET title="Advanced Software Engineer" where emp_id = 101;

As the first session already has a READ lock in place on the employees table, MySQL keeps the above update query in the running... state on this second session. We can't modify the employees table until and unless the lock is removed from the table from session 1.

We can use SHOW PROCESSLIST; to get detailed information about the query. We can see this in the image below.

Let's remove the READ lock from the table so that the session 2 query will be executed:

UNLOCK TABLES;

Let's check session 2, we can see that the update query which was in running state is executed now.

WRITE LOCK in MySQL

In WRITE lock (also known as an exclusive lock), the user can only write/modify and read the data of a table of the current session only.
Other sessions can't write or read the data until the WRITE lock is freed.

Syntax to apply a WRITE lock:

LOCK TABLE <table_name> WRITE;

Syntax to remove lock:

UNLOCK TABLES;

This statement will remove the locks from the table of the active database.

Now, let's see how we can apply a WRITE lock on the employees table.

Create two MySQL connections in the MySQL workbench, and connect to the MySQL database using your password.

Let's place a WRITE lock on the employees table now in session 1.

LOCK TABLE employees WRITE;

Now, let's try to INSERT a value into the table.

-- writing data into the table session 1
INSERT INTO employees VALUES (103, "Rohan", 24, "Application Engineer", 3);

-- reading data from the table session 1
SELECT * FROM employees;

We can see that, we can write/modify and read data from the employees table from session 1.

Let's try to INSERT another value from session 2 of MySQL.

-- writing data into the table session 1
INSERT INTO employees VALUES (104, "Anupam", 26, "Software Engineer II", 5);

-- reading data from the table session 1
SELECT * FROM employees;

We can see that, we can't read or write data into the table from session 2 of the MySQL database once we have applied a WRITE lock on the employees table.

Let's remove the WRITE lock from the table so that the session 2 query will be executed:

UNLOCK TABLES;

Let's check session 2, we can see that the update query which was in running state is executed now and a row is inserted into the table.

Conclusion

Locks are placed on SQL resources to avoid several transactions to access the same resource simultaneously, such as rows accessed or manipulated by a transaction by two users at the same time.
Locks in SQL are used to adhere to the ACID properties in DBMS during a transaction.
Locks are applied to the database resources like RID, Key, Page, Extent, Table, and Database.
Locks are of 6 types, Extent (X), Shared (S), Update (U), Intent (I), Schema (Sch), and Bulk Update (BU) lock.

Database Isolation Levels:

Transaction Management is an essential mechanism of relational Database Management Systems. They allow for concurrency whilst maintaining the ACID properties: Atomicity, Consistency, Isolation and Durability. They are used to control and maintain the integrity of each action in a transaction, despite errors that may occur in the system.

Understanding the various isolation levels and choosing the one that fits your project and allows to achieve better performance or/and guarantee data consistency. Let’s take a look at them and how to define them on a Play 2 with PostgreSQL environment.

Isolation Levels

A Transaction consists of a series of read and write operations of database objects that are meant to be atomic: either all actions are carried out or none are. [Raghu p.523]

For performance reasons a DBMS might interleave transactions, sacrificing the isolation of a transaction from other concurrently executing transactions. They can run of different levels of isolation, each one having a bigger toll on performance although offering a more isolated execution context. DBMS manage transaction concurrency by applying Locks to the required objects. The more elevated isolation level the more locks the transaction will have to acquire in other to execute, thus preventing other concurrent transactions from using the same resources.

Let’s go over the major JDBC levels:

TRANSACTION_NONEIn this mode, all read and write operations can execute concurrently.
TRANSACTION_READ_COMMITTEDAn operation will only be able to read values that were committed, i.e written by a terminated transaction, before it started. This prevents the problem know as ‘Dirty Read’ (or Write-Read Conflict) which happens when a transaction T1, reads a value written by a another transaction T2, that is not yet committed. If T2 aborts, the value that T1 read will be wrong, thus causing an inconsistency.
TRANSACTION_REPEATABLE_READAll operations within the transaction will only be able to read values that were commit previous to the start of the transaction. Adding this limitation solves the ‘Non-repeatable Read’ problem (or Read-Write Conflict). Assume that a transaction T1 reads a given value. If another transaction T2 overwrites that value, and T1 tries to read it again, T1 will get a different value without having changed it.
TRANSACTION_SERIALIZABLEThis is the stricter mode. Transactions execute as they would in a serial execution mode. They still execute concurrently but if a transaction T1 tries to access any object that was used by another transaction T2, this will cause T1 to abort. In this mode, as well as preventing the previous issues, also the ‘Phantom Read’ is prevented. A ‘Phantom Read’ occurs when, during the course of a transaction T1, when another transaction T2 inserts or deletes rows. The same operation running on T1 context may yield a different result if executed before and after T2.

Isolation level on Play 2

To set the isolation level of the transactions on a Play 2 project use the following config:

db.default.isolation="VALUE"

The allowed values are NONE, READ_COMMITTED_, _READ_UNCOMMITTED, REPEATABLE_READ and SERIALIZABLE. If you get a Configuration Error for an “Unknown isolation level” try adding a space after the value. This is due to a bug in the Play DB API.

Optionally, you can set the level per transaction, if you’re writing plain SQL, by defining the isolation level in the BEGIN TRANSACTION statement, like for example:

BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ;

Or if you using the Slick framework you can set the level in a wrapper for the withTransaction method:

CodacyDB.database.withTransaction { session =>
session.conn.setTransactionIsolation(
java.sql.Connection.TRANSACTION_READ_COMMITTED
)
...
}

We’ve seen and understood different database isolation levels applied to transactions. We’ve specified how this can be achieved in Play using Slick. We’ve used this internally in the process of scaling Codacy to thousands of projects under analysis. Would love to hear what you’re currently using for your application!

Triggers:

What are the Triggers in SQL?

You might have encountered situations where you have to constantly check a database table for a particular column to get updated, where, once updated, you have some tasks to do.

Here the first solution which comes to mind is making a select statement (to check for a specific condition) on the table in an interval of a few seconds or minutes. But this doesn’t seem to be a good choice, right? Instead of us asking the database whether the data has been updated or not, the database should tell us when the data gets updated. This is what exactly triggers do. Triggers, as the name tells us, are stored procedures (procedures are functions that contain SQL statements stored in the database and can return some output) that are executed or fired when some events occur. The user defines these events. The trigger may be set on a row insertion in a table or an update to an existing row and at other points, which we will discuss here. Before moving forward, it is important to discuss what DDL and DML operations are.

DDL stands for Data definition language, which is used in changing the structure of a table, i.e., creating a table, adding a column to an existing table, or deleting the whole table. However, DML stands for Data manipulation language, which is used to manipulate the data, i.e., insert some new data into the table or update existing data. Also, for deleting some rows, we make use of DML operations.

Types of Triggers

The following are the different types of triggers present in SQL.

DML Triggers

These triggers fire in response to data manipulation language (DML) statements like INSERT, UPDATE, or DELETE.

Display Triggers in SQL

If someone creates a trigger but forgets the trigger's name, then you can find the trigger by running a simple command.

Query 6:

SHOW TRIGGERS LIKE 'stu%'\G;

This command will show you the list of all available triggers matching with the string ‘stu’. Note that the \G tag ends the statement just like a semicolon (;). However, since the output table is wide, the \G rotates the table visually to vertical mode.

mysql> SHOW TRIGGERS LIKE 'stu%'\G
********************* 1. row *********************
Trigger: student_name
Event: INSERT
Table: student
Statement: SET full_name = first_name || '' || last_name
Timing: AFTER
Created: NULL
sql_mode: NO_ENGINE_SUBSTITUTION
Definer: me@localhost
character_set_client: utf8
collation_connection: utf8_general_ci
Database Collation: latini_swedish_ci

Drop Triggers in SQL

The deletion of a trigger is quite straightforward. You need to run a simple query to delete a trigger from the database.

So in our case, as per the example above, the query will be

Query 5:

DROP TRIGGER student_name;

This will erase the trigger from the database.

Advantages of Triggers in SQL

Using triggers, you can eliminate the use of schedulers mostly. Schedulers are applications that keep running in the background and help run a task at a specific time. These timely checks can be removed and instead checked immediately whenever a particular data changes using triggers. It is basically a better replacement for schedulers.
These are useful in having additional security checks. There are many critical components in business software, and some of them might risk highly sensitive data if not taken care of properly. Many developers work on a critical component, so some security checks must be done for the data being inserted, updated, or deleted. Here triggers help in maintaining a healthy system by warning about security issues if they exist.
One can eliminate the risk of inserting invalid data into a column by having a check for that column or a simple update. Let’s say in the student_name table (where first_name and middle_name are both nullable, i.e., both the columns can accept null values), someone has inserted a row with middle_name keeping the first_name as null. Here the insertion will be successful, but the data is invalid. We can log the error, or also we can move the middle_name value to first_name.
These are useful in cleaning activities since we can run some cleanup procedures on listening to deletion events. For example, there are two tables, students and parents. Ideally, if we deleted some students' data from the student's table, the corresponding data from parents (entries of those parents whose children are getting removed) also should get deleted. Since we are prone to such mistakes where we forget to delete data from parent's tables deleting from students, we can handle this very easily using triggers. We can have a trigger on students deletion, wherein on each DELETE operation, we may proceed to remove the corresponding entry from the parents' table.

Disadvantages of Triggers in SQL

These are difficult to troubleshoot because they are run automatically, and improper logging will result in unknown updates, which could be very time-consuming to debug in large-scale projects.
Triggers increase the overhead of database DML queries. Since for every row we insert, update or delete, it may either do an update or an insertion – say into a new table, or even a row deletion altogether further that might not be required at the moment.
Only limited validation can be done at triggers like Not Null checks, Equality checks, Unique checks, etc. Though we can use triggers to handle most of our business use cases, it doesn’t give a full proof solution for every case. Since SQL is a data manipulation language, we cannot expect it to replace programming language dependency for validations. We still need to depend on other validation along with this. Also, in some scenarios, data validation on SQL is costly compared to validation on the service side.