DEV Community: Sagar Dutta

Django Concepts

Sagar Dutta — Fri, 16 Jun 2023 12:34:32 +0000

What is secret key?

The secret key in django settings.py is a random string that is used for making hashes. It is important to keep the secret key secret and not expose it to others, as it can compromise the security of the Django application. Some of the things that depend on the secret key are:

Password reset tokens
CSRF protection
Sessions
Cookie-based messages

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

Django provides some pre-installed apps for users for the developer’s comfort, such as:

admin: A site for managing the Django project
auth: A framework for authentication and authorization
contenttypes: A framework for tracking the models installed in the project
sessions: A framework for managing session data
messages: A framework for displaying messages to users
staticfiles: A framework for managing static files

If we don't need any of them, we can comment-out or delete the appropriate lines from INSTALLED_APPS before running migrate. The default apps provide some useful features and functionality that we can use in our project, such as:

The admin site allows us to create, update and delete objects in our database using a user-friendly interface.
The auth system handles user authentication, permissions and groups.
The contenttypes framework tracks the models installed in the project and allows us to associate data with specific models.
The sessions framework enables us to store and retrieve data on a per-site-visitor basis.
The messages framework enables us to display one-time notifications and alerts to users.
The staticfiles framework helps us manage the static files, such as images, CSS and JavaScript.

What is middleware? What are different kinds of middleware?

Middleware is a framework of hooks into Django’s request/response processing. It’s a light, low-level “plugin” system for globally altering Django’s input or output. Each middleware component is responsible for doing some specific function. Middleware is used to perform a function in the application, such as security, session, csrf protection, authentication, etc. Django provides various built-in middleware and also allows us to write our own middleware.

Middleware in Django can be written as a function or a class that takes a get_response callable and returns a middleware. A middleware is a callable that takes a request and returns a response, just like a view. A middleware can also perform some actions before or after the view is called.

There are different ways to classify middleware in Django. One way is to distinguish between request middleware and response middleware.

Request middleware is middleware that is executed before the view function is called. It allows developers to modify the request object or perform some other action before the request is passed to the view function.
Response middleware is middleware that is executed after the view function is called. It allows developers to modify the response object or perform some other action before the response is returned to the client.

Another way is to distinguish between built-in middleware and custom middleware.

Built-in middleware is middleware that comes with Django by default and provides some common functionality, such as caching, authentication, csrf protection, etc.
Custom middleware is middleware that developers can create and use across their entire project or specific views. Custom middleware can be written as a function or a class that takes a get_response callable and returns a middleware.

CSRF

Cross site request forgery (CSRF) is a type of attack that allows a malicious user to execute actions using the credentials of another user without that user's knowledge or consent. For example, an attacker can create a link or a form that submits data to a web application where the user is already logged in, and perform actions on behalf of the user.

Django has built-in protection against most types of CSRF attacks, providing we have enabled and used it where appropriate. Django's CSRF protection works by using the following components:

A CSRF cookie that is a random secret value, which other sites will not have access to. CsrfViewMiddleware sends this cookie with the response whenever django.middleware.csrf.get_token() is called. It can also send it in other cases. For security reasons, the value of the secret is changed each time a user logs in.
A hidden form field with the name 'csrfmiddlewaretoken', present in all outgoing POST forms. In order to protect against BREACH attacks, the value of this field is not simply the secret. It is scrambled differently with each response using a mask. The mask is generated randomly on every call to get_token(), so the form field value is different each time. This part is done by the csrf_token template tag.
A validation mechanism that checks for a CSRF cookie and a 'csrfmiddlewaretoken' field in all incoming requests that are not using HTTP GET, HEAD, OPTIONS or TRACE. If they are not present or correct, the user will get a 403 error. When validating the 'csrfmiddlewaretoken' field value, only the secret, not the full token, is compared with the secret in the cookie value. This allows the use of ever-changing tokens. This check is done by CsrfViewMiddleware.
An origin and referer header verification mechanism that checks for a valid origin header, if provided by the browser, against the current host and the CSRF_TRUSTED_ORIGINS setting. This provides protection against cross-subdomain attacks. In addition, for HTTPS requests, if the origin header isn't provided, CsrfViewMiddleware performs strict referer checking. This means that even if a subdomain can set or modify cookies on your domain, it can't force a user to post to your application since that request won't come from your own exact domain¹.

To use Django's CSRF protection in our views, we need to follow these steps:

Make sure that django.middleware.csrf.CsrfViewMiddleware is activated in the MIDDLEWARE setting. If we override that setting, remember that this middleware should come before any view middleware that assume that CSRF attacks have been dealt with.
In any template that uses a POST form, use the csrf_token tag inside the
element if the form is for an internal URL. For example:

  <form method="post">{% csrf_token %}
  ...
  </form>

In the corresponding view functions, ensure that RequestContext is used to render the response so that {% csrf_token %} will work properly. If you're using the render() function, generic views, or contrib apps, you are covered already since these all use RequestContext.
If you are using AJAX requests, you need to set a custom X-CSRFToken header (as specified by the CSRF_HEADER_NAME setting) to the value of the CSRF token on each XMLHttpRequest. You can get the token from the csrftoken cookie or from a hidden input field rendered by {% csrf_token %}. You can also use JavaScript frameworks that provide hooks for setting headers on every request.

XSS

Cross site scripting (XSS) is a type of vulnerability that involves manipulating user interaction with a web application to compromise a user's browser environment. These vulnerabilities can affect many web apps, including those built with modern frameworks. XSS attacks happen through injections of scripts that contain HTML tags. For example, an attacker can inject a script that displays an alert or steals a user's cookies.

Django has built-in protection against most types of XSS attacks, providing we have enabled and used it where appropriate. Django templates escape specific characters which are particularly dangerous to HTML, such as <, >, ', ", and &. This prevents the browser from interpreting them as HTML tags and executing them as scripts. However, this protection iClickjacking protections not entirely foolproof, and there are some cases where we need to be extra careful, such as:

When using template literals in JavaScript, which can bypass the escaping mechanism.
When using attribute URLs, such as href or src, which can contain malicious code.
When using JavaScript or CSS data, which can contain expressions that execute scripts.
When using the safe template tag, mark_safe function, or is_safe attribute with custom template tags, which disable the escaping mechanism.
When using the safeseq filter, which disables the escaping for a sequence of variables.
Clickjacking protection
When using html_safe() method, which marks a string as safe for HTML output.
When outputting something other than HTML, such as JSON or XML, which may require different escaping rules.

To prevent XSS attacks in Django, we should follow these best practices:

Quote dynamic data that comes from user input or untrusted sources.
Avoid template literals in JavaScript and use string concatenation instead.
Validate attribute URLs and ensure they start with http:// or https://.
Escape JavaScript data using json_script template tag.
Escape CSS data using css_escaping template filter.
Use safe, safeseq, mark_safe, is_safe, and html_safe() only when you are sure the data is safe and does not contain any HTML tags.
Use autoescape template tag or autoescape context variable to enable or disable escaping for a block of code.

Click Jacking

Clickjacking is a type of attack that tricks a user into clicking on a concealed element of another site which they have loaded in a hidden frame or iframe. For example, an attacker can create a button that overlays a legitimate site's button and perform actions on behalf of the user.

Django provides clickjacking protection in the form of X-Frame-Options middleware. This feature prevents a different site from rendering our site inside a frame. The middleware sets the X-Frame-Options HTTP header to DENY by default, which means that our site cannot be displayed in a frame on any site. We can change this value to SAMEORIGIN, which means that our site can be displayed in a frame on the same origin (including subdomain and port). We can also set the X_FRAME_OPTIONS setting to configure the exact header value sent.

To use Django's clickjacking protection for all responses, we need to activate django.middleware.clickjacking.XFrameOptionsMiddleware in the MIDDLEWARE setting. This middleware is enabled in the settings file generated by startproject.

To disable the clickjacking protection for certain views, we can use the xframe_options_exempt view decorator. For example:

from django.http import HttpResponse
from django.views.decorators.clickjacking import xframe_options_exempt

@xframe_options_exempt
def ok_to_load_in_a_frame(request):
    return HttpResponse("This page is safe to load in a frame on any site.")

We can also use other view decorators to set different values for the X-Frame-Options header, such as xframe_options_sameorigin or xframe_options_deny.

What is WSGI?

Web Server Gateway Interface (WSGI) is a simple calling convention for web servers to forward requests to web applications or frameworks written in the Python programming language. It is a standard interface that makes it possible for applications written with any Python web framework to run in any web server that supports WSGI. It was created in 2003 to promote common ground for portable web application development.

What is ondelete Cascade?

ON DELETE CASCADE is an option when defining a foreign key in SQL. It indicates that related rows should be deleted in the child table when rows are deleted in the parent table. It is a kind of referential action that prevents leaving orphan records or children without parents. For example, if you have two tables: buildings and rooms, where each building has one or many rooms, and each room belongs to one only one building, we can use ON DELETE CASCADE on the foreign key of the rooms table that references the buildings table. This way, when we delete a building, all rooms in that building will be also deleted automatically.

Model Field

A model field is an attribute of a model that defines the type and constraints of the data that can be stored in a database column. A model field can have various options, such as null, blank, default, choices, etc. A model field can also have one or more validators that check the validity of the input data.

A model field is a class attribute of a model that represents a column in a database table. A model field defines the data type of the column, such as CharField, IntegerField, BooleanField, etc. A model field can also have various options that affect how the data is stored and displayed, such as null, blank, default, choices, etc. For example, a null option indicates whether the column can have NULL values or not. A choices option provides a list of tuples to use as choices for the field.

A model field is an instance of a Field class that subclasses django.db.models.Field. Django provides many built-in field types, such as AutoField, BigAutoField, BigIntegerField, BinaryField, etc. We can also create our own custom fields by subclassing Field and implementing the required methods.

A model field is used to map a Python object attribute to a database column. A model field also provides methods and properties to access and manipulate the data associated with the field. For example, a model field has a name property that returns the name of the field, a value_from_object method that returns the value of the field from an object instance, and a get_db_prep_value method that prepares the value for database insertion.

Validators

A validator is a callable object or function that takes a value and raises a ValidationError if it doesn't meet some criteria. Validators can be used in Django at the model level or the level of the form. They can be useful for reusing validation logic between different types of fields.

For example, we can write a validator that only allows even numbers:

from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _

def validate_even(value):
    if value % 2 != 0:
        raise ValidationError(
            _("%(value)s is not an even number"),
            params={"value": value},
        )

We can add this validator to a model field or a form field using the validators argument:

from django.db import models

class MyModel(models.Model):
    even_field = models.IntegerField(validators=[validate_even])

from django import forms

class MyForm(forms.Form):
    even_field = forms.IntegerField(validators=[validate_even])

We can also use a class with a __call__() method for more complex or configurable validators. For example, RegexValidator is a class-based validator that searches the value for a given regular expression.

Django also provides some built-in validators in the django.core.validators module, such as EmailValidator, MinValueValidator, URLValidator, etc.

Understanding the difference between `Python module` and `Python class`?

A Python module is a file containing Python definitions and statements that can be imported into another Python program. A module can contain classes, functions, variables, and other code elements. A module helps to organize the code into logical units and reuse them in different program.

A Python class is a blueprint for creating objects that have attributes and behaviors. A class can inherit from other classes, use metaclasses and descriptors, and create instances. A class is a way to abstract the data and methods that belong to a specific type of objects.

Some differences are:

A module cannot be instantiated, but a class can.
A module is a singleton instance of an internal module class, and its globals are its attributes. A class can have multiple instances, each with its own state and identity.
A module can contain multiple classes, but a class cannot contain multiple modules.
A module is identified by its file name, but a class is identified by its class name.
A module can be executed as a script, but a class cannot be executed directly.

Using ORM queries in Django Shell

ORM queries in Django Shell are a way of interacting with data from various relational databases using an API called ORM (Object Relational Mapping). ORM allows us to write object-oriented code that is translated into raw SQL queries behind the scenes.

To use ORM queries in Django Shell, we need to follow these steps:

Importing the models we want to query from our app. For example, if we have a model called Student in an app called sampleapp, we can import it as:
```
from sampleapp.models import Student
```
Use the model's objects attribute to access the ORM methods, such as all(), create(), get(), filter(), order_by(), etc. For example, if we want to get all the students from the database, we can use:
```
queryset = Student.objects.all()
```
We can print the queryset object to see the results, or use the str() function to see the corresponding SQL query. For example:
```
print(queryset)
str(queryset.query)
```
We can also use dot notation to access the fields of each object in the queryset. For example, if we want to print the name and email of each student, we can use:
```
for student in queryset:
    print(student.name, student.email)
```
We can modify or delete objects using the save() or delete() methods on them. For example, if we want to change the name of a student with id 1, we can use:
```
student = Student.objects.get(id=1)
student.name = "New name"
student.save()
```
We can also perform complex queries using Q objects, F expressions, annotations, aggregations, etc. For example, if we want to get the students whose name starts with 'A' or whose email contains 'gmail', we can use:
```
from django.db.models import Q
queryset = Student.objects.filter(Q(name__startswith='A') | Q(email__contains='gmail'))
```

Turning ORM to SQL in Django Shell

Turning ORM to SQL in Django Shell is a way of seeing the raw SQL query that Django generates based on the ORM query. This can be useful for debugging, optimizing, or learning purposes.

To turn ORM to SQL in Django Shell, we can use the query method of a QuerySet object. This method returns the raw SQL query that Django executes behind the scenes.

For example, if we have a model called Student and we want to see the SQL query for getting all the students from the database, we can do the following:

Import the model from the app. For example:
```
from sampleapp.models import Student
```
Use the model's objects attribute to access the ORM methods, such as all(), and assign it to a variable. For example:
```
queryset = Student.objects.all()
```

Use the print() function or the str() function to see the raw SQL query. For example:

print(queryset.query)
str(queryset.query)

This will print something like:

SELECT "sampleapp_student"."id", "sampleapp_student"."name", "sampleapp_student"."email" FROM "sampleapp_student"

We can use this technique for any ORM query, such as filter(), order_by(), annotate(), etc.

What are Aggregations?

Aggregations are a way of summarizing or computing values from a collection of objects in Django ORM. For example, we can use aggregations to find the average price of all books, the maximum rating of all books, the total number of books per publisher, etc.

To perform aggregations, we can use two methods: aggregate() and annotate(). The aggregate() method returns a dictionary of name-value pairs, where the name is an identifier for the aggregate value and the value is the computed aggregate. For example:

# Average price across all books.
>>> from django.db.models import Avg
>>> Book.objects.aggregate(Avg("price"))
{'price__avg': 34.35}

We can use various aggregate functions, such as Count, Sum, Avg, Min, Max, etc. We can also use field lookups to filter or group by related fields using the double underscore notation. For example:

# Each publisher, with a separate count of books with a rating above and below 5
>>> from django.db.models import Q
>>> above_5 = Count("book", filter=Q(book__rating__gt=5))
>>> below_5 = Count("book", filter=Q(book__rating__lte=5))
>>> pubs = Publisher.objects.annotate(below_5=below_5).annotate(above_5=above_5)
>>> pubs[0].above_5
23
>>> pubs[0].below_5
12

What are Annotations?

Annotations are a way of adding extra attributes to each object in a QuerySet that are derived from some computation or aggregation. For example, we can use annotations to add a count of books for each publisher, a total price of all books in a store, a flag indicating if a book has a rating above a certain threshold, etc.

To perform annotations, we can use the annotate() method on a QuerySet and pass an expression that defines the annotation. The expression can be a simple value, a field reference, an aggregate function, a function, a lookup, or any combination of these using arithmetic or boolean operators. For example:

# Each publisher, each with a count of books as a "num_books" attribute.
>>> from django.db.models import Count
>>> pubs = Publisher.objects.annotate(num_books=Count("book"))
>>> pubs
<QuerySet [<Publisher: BaloneyPress>, <Publisher: SalamiPress>, ...]>
>>> pubs[0].num_books
73

# Each book, with an extra attribute indicating if it has more than 300 pages.
>>> from django.db.models import BooleanField, Case, When
>>> books = Book.objects.annotate(
...     is_long=Case(
...         When(pages__gt=300, then=True),
...         default=False,
...         output_field=BooleanField(),
...     )
... )
>>> books
<QuerySet [<Book: War and Peace>, <Book: The Catcher in the Rye>, ...]>
>>> books[0].is_long
True

We can use annotations in filters, order by clauses, or other annotations. We can also chain multiple annotations together to add more than one extra attribute. For example:

# Each book, with an extra attribute indicating its price after applying a 10% discount,
# and another attribute indicating if it is cheap (less than $20).
>>> from django.db.models import DecimalField, ExpressionWrapper, F
>>> books = Book.objects.annotate(
...     discounted_price=ExpressionWrapper(
...         F("price") * 0.9,
...         output_field=DecimalField(max_digits=10, decimal_places=2),
...     )
... ).annotate(
...     is_cheap=Case(
...         When(discounted_price__lt=20, then=True),
...         default=False,
...         output_field=BooleanField(),
...     )
... )
>>> books
<QuerySet [<Book: War and Peace>, <Book: The Catcher in the Rye>, ...]>
>>> books[0].discounted_price
Decimal('18.00')
>>> books[0].is_cheap
True

What is a migration file? Why is it needed?

A migration file is a Python file that describes the changes to the database schema that are required by the models. For example, if we add a new field to a model, Django will create a migration file that instructs the database to add a new column to the corresponding table.

Migration files are needed because they allow to keep track of the evolution of the database schema over time, and to apply the same changes consistently across different environments (such as development, staging, and production). They also enable us to roll back to a previous state of the database if something goes wrong.

Migration files are usually generated automatically by Django when we run the makemigrations command, which detects any changes we have made to the models since the last migration. We can also create empty migration files manually by using the --empty option with the makemigrations command, and then write our own custom code inside them.

Migration files are stored in a migrations folder inside each app that has models. The migration files have names that start with a number (such as 0001_initial.py) that indicate the order in which they should be applied. We can apply the migrations to the database by running the migrate command, which will execute the SQL statements generated by Django based on the migration files.

What are SQL transactions? (non ORM concept)

A SQL transaction is a grouping of one or more SQL statements that interact with a database. A transaction in its entirety can commit to a database as a single logical unit or rollback (become undone) as a single logical unit. In SQL, transactions are essential for maintaining database integrity. They are used to preserve integrity when multiple related operations are executed concurrently, or when multiple users interact with a database concurrently.

A database application has to account for every possible failure scenario while writing and reading from a database. Without SQL transactions, application code that protects database integrity would be complex and expensive to develop and maintain. With SQL transactions, application code and database maintenance can be simplified.

What are atomic transactions?

Atomic Transactions are associated with Database operations where a set of actions must ALL complete or else NONE of them complete. For example, if someone is booking a flight, you want to both get payment AND reserve the seat OR do neither. If either one were allowed to succeed without the other also succeeding, the database would be inconsistent.

References

https://docs.djangoproject.com/en/4.2/topics/security/

https://snyk.io/blog/preventing-xss-in-django/

https://docs.djangoproject.com/en/4.2/ref/csrf/

https://docs.djangoproject.com/en/4.2/howto/csrf/

https://docs.djangoproject.com/en/4.2/ref/clickjacking/

https://www.stackhawk.com/blog/guide-to-security-in-django/

https://www.pythonpool.com/python-class-vs-module/

https://docs.djangoproject.com/en/4.2/ref/models/fields/

https://docs.djangoproject.com/en/4.2/topics/db/sql/

https://docs.djangoproject.com/en/4.2/topics/db/aggregation/

https://docs.djangoproject.com/en/4.2/topics/migrations/

https://www.linode.com/docs/guides/a-primer-on-sql-transactions/

Grit and Growth Mindset

Sagar Dutta — Thu, 01 Jun 2023 11:53:20 +0000

Grit

Paraphrase

Grit is passion and perseverance for very long-term goals. Grit is sticking with our future, not just for weeks or months, but for years, and working really hard to make that future a reality. Grit is living life like it's a marathon, not a sprint.

Talent doesn't make one gritty. There are many talented individuals
who simply do not follow through their own commitments. Grit is usually unrelated to measures of talent.

The best idea about building grit is something called "growth mindset."
It is the belief that the ability to learn is not fixed, that it can change with our effort.

So growth mindset is important for building grit. We need to take our best ideas, our strongest intuitions, and we need to test them. We need to measure whether we've been successful, and we have to be willing to fail, to be wrong, to start over again with lessons learned. In other words, we need to be gritty.

Key takeaways

We need to have passion and perseverance to reach our goals.
We need to set long-term goals and follow through our commitments.
We need to build growth mindset in order to gritty. Growth mindset is believing that we can change and improve by putting in the required effort.
We need to be willing to fail, accept failures, learn from our mistakes and start over.

Growth Mindset

Paraphrase

People's mindsets play a crucial role in their success. Mindsets have a major influence on people's ability to learn. There are two ways of thinking about skill and development: Fixed mindset and Growth mindset.

People with a fixed mindset believe that skills are born. They believe that skills and intelligence are set and they either have them or don't. They believe that they are not in control of their abilities.
People with a growth mindset believe that skills are built. They believe that skills and intelligence are grown and developed. People who are good at something are good because they built that ability, and people who aren't are not good because they haven't done the work. In short, they believe that they are in control of their abilities.

People with a growth mindset believe in their capacity to learn and grow. They utilize this growth mindset tend to learn, grow and achieve more over time than people with a fixed. Growth mindset really creates a solid foundation for great learning.

There are defining characteristics that set the two mindsets apart.

The first big characteristic we need to talk about is belief.
- People with fixed mindset believe that skills are born and therefore they can't or don't have to learn.
- People with a growth mindset believe that skills are built, therefore they can learn.
The second major characteristic is focus.
- People in a fixed mindset tend to focus on performance and outcomes and results. Their main concern becomes how they look, and to not look bad.
- People with a growth mindset tend to focus more on the process of getting better of learning and growing.

These mindsets and these characteristics have a huge influence on our ability to learn.

There are four key ingredients to growth: effort, challenges, mistakes, and feedback.

People with fixed mindset
- They shy away from putting in effort because they don't believe that they can change.
- They give up when they're met with a challenge and things get hard because they don't want to look bad. So in their mind the challenge becomes a threat and because they don't believe that they can change.
- They hate making mistakes and are discouraged by mistakes, because if they are making mistakes, they not looking good.
- They don't see the value or purpose of feedback because they don't believe in their capacity to grow.
People with growth mindset
- They see the value and purpose of effort because they believe in their capacity to grow.
- They're more likely to take on a challenge and persevere through it because they believe that they can grow, and because they're focused on the opportunity to do that. So they frame a challenge as an opportunity to get better.
- And by focusing on the process and believing in their capacity to grow they're more likely to understand how important mistakes are in this process.
- And when they receive feedback from someone, they're more receptive to this because their focus is on getting better and because they believe that that information can help them grow. And they have the capacity to do so.

So, in one way or the other, every single one of these actions is a byproduct of these characteristics. So, to create a great culture for learning, we have to create growth mindset, which is one of the most important things we can do.

Key takeaways

We need to develop Growth mindset in order to learn and develop skills.
We need to value the purpose of effort because it is proportional to our capacity to grow.
We should be willing to take on challenges and persevere through them. Challenge is an opportunity to get better.
Focusing on the process and learn from mistakes.
Accept feedback and use that information to grow.

Internal Locus of Control

What is the Internal Locus of Control?

Locus of control is the degree to which one believes they have control over their life. Internal Locus of Control is believing that the factors that led to certain outcome are in our control. It is our hard work and our extra effort that allow us to do well in anything. The amount of work we put into something is in our control.

What is the key point in the video?

Internal locus of control is the key to stay motivated. We must feel like we have control over our life and that we are responsible for the things that happen to us if we want to feel motivated all of the time.

Build a Growth Mindset

Paraphrase

A growth mindset begins with the fundamental rule in life and that is believing in our ability to figure things out. If we believe that we can figure things out and we can get better enables us for lifelong improvement and growth.

The second thing to develop a greater growth mindset is questioning our assumptions. Don't let your current knowledge skills and ability box in or narrow down your vision for your future because today has little to do with what you're capable of achieving in the future.

Key takeaways

Develop a 'will figure it out' mentality.
Stop assuming our capabilities based on our current knowledge level

Important JavaScript Concepts

Sagar Dutta — Wed, 31 May 2023 12:28:40 +0000

Loops

for

The for statement creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement (usually a block statement) to be executed in the loop.
```
for (let i = 0; i < 9; i++) {
    console.log(i);
    // more statements
}
```

forEach

The forEach() method executes a provided function once for each array element.

const array1 = ['a', 'b', 'c'];

array1.forEach(element => console.log(element));

// Expected output: "a"
// Expected output: "b"
// Expected output: "c"

for .. in

The for...in statement iterates over all enumerable string properties of an object (ignoring properties keyed by symbols), including inherited enumerable properties.

const object = { a: 1, b: 2, c: 3 };

for (const property in object) {
    console.log(`${property}: ${object[property]}`);
}

// Expected output:
// "a: 1"
// "b: 2"
// "c: 3"

for .. of

The for...of statement executes a loop that operates on a sequence of values sourced from an iterable object. Iterable objects include instances of built-ins such as Array, String, TypedArray, Map, Set, NodeList (and other DOM collections), as well as the arguments object, generators produced by generator functions, and user-defined iterables.
```
const array1 = ['a', 'b', 'c'];

for (const element of array1) {
    console.log(element);
}

// Expected output: "a"
// Expected output: "b"
// Expected output: "c"
```

while

The while statement creates a loop that executes a specified statement as long as the test condition evaluates to true. The condition is evaluated before executing the statement.
```
let n = 0;

while (n < 3) {
    n++;
}

console.log(n);// Expected output: 3
```

Mutable and Immutable Methods (in strings and arrays)

Mutable methods are those that change the original array or string. Immutable methods are those that return a new array or string without modifying the original one.

Some examples of mutable methods for arrays are:

pop(): removes the last element from an array and returns it
push(): adds one or more elements to the end of an array and returns its new length
shift(): removes the first element from an array and returns it
unshift(): adds one or more elements to the beginning of an array and returns its new length
reverse(): reverses the order of the elements in an array
sort(): sorts the elements of an array according to a compare function or lexicographically by default
splice(): changes the contents of an array by removing or replacing existing elements and/or adding new elements

Some examples of immutable methods for arrays are:

slice(): returns a shallow copy of a portion of an array into a new array
concat(): returns a new array that is the result of joining two or more arrays or values
map(): returns a new array with the results of calling a provided function on every element in the calling array
filter(): returns a new array with all elements that pass a test implemented by a provided function

For strings, all methods are immutable, meaning that they do not change the original string but return a new one. Some examples are:

charAt(): returns the character at a specified index in a string
concat(): returns a new string that is the result of joining two or more strings
indexOf(): returns the index of the first occurrence of a specified value in a string, or -1 if not found
replace(): returns a new string with some or all matches of a pattern replaced by a replacement
slice(): returns a portion of a string into a new string
split(): splits a string into an array of substrings using a separator
toUpperCase(): returns a new string with all characters converted to uppercase

Here is some javascript code to illustrate how mutable and immutable methods work:

// Mutable methods for arrays
let fruits = ["apple", "banana", "cherry"];
let last = fruits.pop(); // removes "cherry" from fruits and returns it
console.log(last); // "cherry"
console.log(fruits); // ["apple", "banana"]

let len = fruits.push("durian"); // adds "durian" to fruits and returns its new length
console.log(len); // 3
console.log(fruits); // ["apple", "banana", "durian"]

let first = fruits.shift(); // removes "apple" from fruits and returns it
console.log(first); // "apple"
console.log(fruits); // ["banana", "durian"]

len = fruits.unshift("elderberry"); // adds "elderberry" to fruits and returns its new length
console.log(len); // 3
console.log(fruits); // ["elderberry", "banana", "durian"]

fruits.reverse(); // reverses the order of fruits
console.log(fruits); // ["durian", "banana", "elderberry"]

fruits.sort(); // sorts fruits lexicographically
console.log(fruits); // ["banana", "durian", "elderberry"]

fruits.splice(1, 1, "fig", "grape"); // removes 1 element at index 1 from fruits and inserts "fig" and "grape"
console.log(fruits); // ["banana", "fig", "grape", "elderberry"]

// Immutable methods for arrays
let numbers = [1, 2, 3, 4, 5];
let sliced = numbers.slice(1, 3); // returns a new array with elements from index 1 to 3 (not inclusive) from numbers
console.log(sliced); // [2, 3]
console.log(numbers); // [1, 2, 3, 4, 5]

let joined = numbers.concat([6, 7, 8]); // returns a new array that is the result of joining numbers and [6, 7, 8]
console.log(joined); // [1, 2, 3, 4, 5, 6, 7, 8]
console.log(numbers); // [1, 2, 3, 4, 5]

let doubled = numbers.map(number => number * 2); // returns a new array with the results of multiplying each element in numbers by 2
console.log(doubled); // [2, 4, 6, 8, 10]
console.log(numbers); // [1, 2, 3, 4, 5]

let even = numbers.filter(number => number % 2 === 0); // returns a new array with all even elements from numbers
console.log(even); // [2, 4]
console.log(numbers); // [1, 2, 3, 4, 5]

// Immutable methods for strings
let name = "Alice";
let char = name.charAt(0); // returns the character at index 0 in name
console.log(char); // "A"
console.log(name); // "Alice"

let greeting = name.concat(" ", "Smith"); // returns a new string that is the result of joining name and " Smith"
console.log(greeting); // "Alice Smith"
console.log(name); // "Alice"

let index = name.indexOf("c"); // returns the index of the first occurrence of "c" in name, or -1 if not found
console.log(index); // 2
console.log(name); // "Alice"

let replaced = name.replace("A", "E"); // returns a new string with the first match of "A" replaced by "E" in name
console.log(replaced); // "Elice"
console.log(name); // "Alice"

let sliced = name.slice(1, 3); // returns a portion of name from index 1 to 3 (not inclusive) into a new string
console.log(sliced); // "li"
console.log(name); // "Alice"

let split = name.split(""); // splits name into an array of substrings using "" as a separator
console.log(split); // ["A", "l", "i", "c", "e"]
console.log(name); // "Alice"

let upper = name.toUpperCase(); // returns a new string with all characters in name converted to uppercase
console.log(upper); // "ALICE"
console.log(name); // "Alice"

Pass by Reference and Pass by Value

Pass by value means that when a variable is passed to a function as an argument, the function receives a copy of the variable's value, not the original one. So any changes made to the variable inside the function do not affect the original variable outside the function. This happens when the variable is a primitive data type, such as a number, a string, a boolean, null or undefined.

Pass by reference means that when a variable is passed to a function as an argument, the function receives a reference to the variable's memory location, not a copy of its value. So any changes made to the variable inside the function do affect the original variable outside the function. This happens when the variable is a non-primitive data type, such as an object, an array or a function.

Here are some code snippets to illustrate the difference:

// Pass by value example
let x = 10; // x is a primitive data type (number)

function addFive(y) {
  // y is a copy of x's value
  y = y + 5; // change y's value
  console.log(y); // 15
}

console.log(x); // 10
addFive(x); // pass x to addFive function
console.log(x); // 10 (x's value is not changed)

// Pass by reference example
let obj = { name: "Alice", age: 20 }; // obj is a non-primitive data type (object)

function changeName(person) {
  // person is a reference to obj's memory location
  person.name = "Bob"; // change person's name property
  console.log(person); // { name: "Bob", age: 20 }
}

console.log(obj); // { name: "Alice", age: 20 }
changeName(obj); // pass obj to changeName function
console.log(obj); // { name: "Bob", age: 20 } (obj's name property is changed)

Array methods

Basics:

Array.pop

The pop() method removes the last element from an array and returns that element. This method changes the length of the array.

const myFish = ["angel", "clown", "mandarin", "sturgeon"];
const popped = myFish.pop();
console.log(myFish); // ['angel', 'clown', 'mandarin' ]
console.log(popped); // 'sturgeon'

Array.push

The push() method adds the specified elements to the end of an array and returns the new length of the array.

const animals = ['pigs', 'goats', 'sheep'];
const count = animals.push('cows');
console.log(animals);// Expected output: Array ["pigs", "goats", "sheep", "cows"]
animals.push('chickens', 'cats', 'dogs');
console.log(animals);// Expected output: Array ["pigs", "goats", "sheep", "cows", "chickens", "cats", "dogs"]

Array.concat

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

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

console.log(array3);// Expected output: Array ["a", "b", "c", "d", "e", "f"]

Array.slice

The slice() method returns a shallow copy of a portion of an array into a new array object selected from start to end (end not included) where start and end represent the index of items in that array. The original array will not be modified.

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));// Expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));// Expected output: Array ["camel", "duck"]

console.log(animals.slice(2, -1));// Expected output: Array ["camel", "duck"]

Array.splice

The splice() method changes the contents of an array by removing or replacing existing elements and/or adding new elements in place.

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');// Inserts at index 1
console.log(months);// Expected output: Array ["Jan", "Feb", "March", "April", "June"]

Array.join

The join() method creates and returns a new string by concatenating all of the elements in an array (or an array-like object), separated by commas or a specified separator string. If the array has only one item, then that item will be returned without using the separator.
```
const elements = ['Fire', 'Air', 'Water'];

console.log(elements.join());// Expected output: "Fire,Air,Water"
console.log(elements.join(''));// Expected output: "FireAirWater"
```

Array.flat

The flat() method creates a new array with all sub-array elements concatenated into it recursively up to the specified depth.

const arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat());// Expected output: Array [0, 1, 2, 3, 4]

const arr2 = [0, 1, 2, [[[3, 4]]]];
console.log(arr2.flat(2));// Expected output: Array [0, 1, 2, Array [3, 4]]

Finding:
- Array.find
  
  The find() method returns the first element in the provided array that satisfies the provided testing function. If no values satisfy the testing function, undefined is returned.
```
const array1 = [5, 12, 8, 130, 44];
const found = array1.find(element => element > 10);

console.log(found);// Expected output: 12
```
- Array.indexOf
  
  The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
```
const beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];

console.log(beasts.indexOf('bison'));// Expected output: 1
console.log(beasts.indexOf('bison', 2));// Expected output: 4
console.log(beasts.indexOf('giraffe'));// Expected output: -1
```
- Array.includes
  
  The includes() method determines whether an array includes a certain value among its entries, returning true or false as appropriate.
```
const array1 = [1, 2, 3];

console.log(array1.includes(2));// Expected output: true
```
- Array.findIndex
  
  The findIndex() method returns the index of the first element in an array that satisfies the provided testing function. If no elements satisfy the testing function, -1 is returned.
```
const array1 = [5, 12, 8, 130, 44];
const isLargeNumber = (element) => element > 13;

console.log(array1.findIndex(isLargeNumber));// Expected output: 3
```

Higher Order Functions:
- Array.forEach
  
  The forEach() method executes a provided function once for each array element.
```
const array1 = ['a', 'b', 'c'];
array1.forEach(element => console.log(element));

// Expected output: "a"
// Expected output: "b"
// Expected output: "c"
```
- Array.filter
  
  The filter() method creates a shallow copy of a portion of a given array, filtered down to just the elements from the given array that pass the test implemented by the provided function.
```
const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);// Expected output: Array ["exuberant", "destruction", "present"]
```
- Array.map
  
  The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.
```
const array1 = [1, 4, 9, 16];

const map1 = array1.map(x => x * 2);

console.log(map1);// Expected output: Array [2, 8, 18, 32]
```
- Array.reduce
  
  The reduce() method executes a user-supplied "reducer" callback function on each element of the array, in order, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the array is a single value.
```
const array1 = [1, 2, 3, 4];

const initialValue = 0;

const sumWithInitial = array1.reduce((accumulator, currentValue) => accumulator + currentValue, initialValue);

console.log(sumWithInitial);// Expected output: 10
```
- Array.sort
  
  The sort() method sorts the elements of an array in place and returns the reference to the same array, now sorted. The default sort order is ascending, built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values.
```
const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);// Expected output: Array ["Dec", "Feb", "Jan", "March"]
```

Advanced:
- Array methods chaining
  
  It is a technique of applying multiple array methods one after another on the same array or the result of the previous method. This allows us to write more concise and readable code by avoiding intermediate variables and loops.
  
  To chain array methods, we use the dot (.) operator to call the next method on the return value of the previous method. However, not all array methods can be chained. Only those methods that return a new array can be chained, such as map(), filter(), slice(), concat(), sort(), etc. Methods that return a single value, such as reduce(), find(), indexOf(), etc. cannot be chained further².
  
  Here are some examples of array method chaining:
  - Suppose we have an array of numbers and we want to get a new array with only the even numbers multiplied by 10 and sorted in ascending order. We can chain filter(), map() and sort() methods to achieve this:
```
let numbers = [5, 2, 7, 9, 4, 6, 3];
let result = numbers
.filter((num) => num % 2 === 0) // filter out odd numbers
.map((num) => num * 10) // multiply each number by 10
.sort((a, b) => a - b); // sort in ascending order
console.log(result); // [20, 40, 60]
```

String methods

Common JavaScript string methods with example code snippets:

charAt (index)

This method returns the character at the given index. For example:
```
var str = "javascript";
console.log(str.charAt(2)); // prints "v"
```
slice (start, end)

This method extracts a part of a string and returns the extracted part in a new string. The start and end parameters specify the start and end positions of the slice (end not included). For example:
```
var str = "Apple, Banana, Kiwi";
console.log(str.slice(7, 13)); // prints "Banana"
console.log(str.slice(-12)); // prints "Banana, Kiwi"
```

substring (start, end)

This method is similar to slice (), but it treats negative values as 0. For example:

var str = "Apple, Banana, Kiwi";
console.log(str.substring(7, 13)); // prints "Banana"
console.log(str.substring(-12)); // prints "Apple, Banana, Kiwi"

substr (start, length)

This method is similar to slice (), but the second parameter specifies the length of the extracted part. For example:
```
var str = "Apple, Banana, Kiwi";
console.log(str.substr(7, 6)); // prints "Banana"
console.log(str.substr(-4)); // prints "Kiwi"
```
replace (oldValue, newValue)

This method replaces a specified value with another value in a string. By default, it replaces only the first match. To replace all matches, use a regular expression with the /g flag. For example:
```
var str = "Please visit Microsoft!";
console.log(str.replace("Microsoft", "Apple")); // prints "Please visit Apple!"
console.log(str.replace(/o/g, "*")); // prints "Please visit Micr*s*ft!"
```

toUpperCase ()

This method converts a string to upper case letters. For example:

var str = "Hello World!";
console.log(str.toUpperCase()); // prints "HELLO WORLD!"

toLowerCase ()

This method converts a string to lower case letters. For example:

var str = "Hello World!";
console.log(str.toLowerCase()); // prints "hello world!"

concat (string1, string2,...)

This method concatenates two or more strings and returns a new string. For example:

var str1 = "Hello";
var str2 = "World";
console.log(str1.concat(" ", str2)); // prints "Hello World"

trim ()

This method removes whitespace from both ends of a string. For example:

var str = "   Hello World!   ";
console.log(str.trim()); // prints "Hello World!"

split (separator)

This method splits a string into an array of substrings, using a specified separator string. For example:
```
var str = "Apple,Banana,Kiwi";
console.log(str.split(",")); // prints ["Apple", "Banana", "Kiwi"]
```
indexOf (value)

This method returns the index of the first occurrence of a specified value in a string, or -1 if the value is not found. For example:
```
var str = "HelloWorld";
console.log(str.indexOf("Hello")); // prints 0
```

Object methods and operations

Creating objects

Objects can be created using an object initializer (also called an object literal) or a constructor function. For example:

// Using an object initializer
const obj = {
name: "John",
age: 25,
greet: function() {
    console.log("Hello, " + this.name);
    }
};

// Using a constructor function
function Person(name, age) {
this.name = name;
this.age = age;
this.greet = function() {
    console.log("Hello, " + this.name);
};
}

const obj = new Person("John", 25);

Accessing properties

Properties can be accessed using dot notation or bracket notation. For example:

// Using dot notation
console.log(obj.name); // prints "John"
console.log(obj.age); // prints 25

// Using bracket notation
console.log(obj["name"]); // prints "John"
console.log(obj["age"]); // prints 25

Modifying properties

Properties can be modified by assigning a new value to them using dot notation or bracket notation. For example:

// Using dot notation
obj.name = "Jane";
console.log(obj.name); // prints "Jane"

// Using bracket notation
obj["age"] = 30;
console.log(obj.age); // prints 30

Deleting properties

Properties can be deleted using the delete operator. For example:
```
delete obj.name;
console.log(obj.name); // prints undefined
```

Iterating over properties

Properties can be iterated over using a for...in loop or the Object.keys() method. For example:

// Using a for...in loop
for (let key in obj) {
console.log(key + ": " + obj[key]);
}

// Using Object.keys()
let keys = Object.keys(obj);
for (let i = 0; i < keys.length; i++) {
    let key = keys[i];
    console.log(key + ": " + obj[key]);
}

Calling methods

Methods can be called using dot notation or bracket notation, followed by parentheses. For example:

// Using dot notation
obj.greet(); // prints "Hello, Jane"

// Using bracket notation
obj["greet"](); // prints "Hello, Jane"

Hoisting

It is special property of javscript where we can use the variables or functions without declaring first

console.log(b); //It will print undefined not error
var b

Hoisting is posible only with variables declared using var key word

Scopes

The current context of execution in which values and expressions are "visible" or can be referenced. If a variable or expression is not in the current scope, it will not be available for use. Scopes can also be layered in a hierarchy, so that child scopes have access to parent scopes, but not vice versa.

Types of scope
- Global scope
  
  The default scope for all code running in script mode. Variables declared outside of any function become global variables. Global variables can be accessed and modified from any function³⁴.
- Function scope
  
  The scope created with a function. Variables declared within a function become local to the function. Local variables can only be accessed from within the function or nested functions¹⁴.
- Block scope
  
  The scope created with a pair of curly braces (a block). Variables declared with let or const can have block scope. They can only be accessed from within the block¹ .

Some examples of JavaScript scopes are:

Global scope

In this example, x is a global variable that can be used anywhere in the code.

var x = 10; // global variable

function foo() {
    console.log(x); // prints 10
}

function bar() {
    var x = 20; // local variable
    console.log(x); // prints 20
}

foo(); // prints 10
bar(); // prints 20
console.log(x); // prints 10

Function scope

In this example, y is a local variable that can only be used inside the baz function.

function baz() {
    var y = 30; // local variable
    console.log(y); // prints 30
}

baz(); // prints 30
console.log(y); // causes error: y is not defined

Block scope

In this example, z is a block-scoped variable that can only be used inside the if block.

if (true) {
    let z = 40; // block-scoped variable
    console.log(z); // prints 40
}

console.log(z); // causes error: z is not defined

Closures

A closure is the combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment). In other words, a closure gives you access to an outer function's scope from an inner function. In JavaScript, closures are created every time a function is created, at function creation time.

Higher Order Functions

A higher order function is a function that either takes one or more functions as arguments, or returns a function as its result. This is possible because in JavaScript, functions are treated as first-class citizens, meaning they can be assigned to variables, passed as arguments, or returned from other functions.

The benefits of using higher order functions are:

They allow us to write more concise and readable code by avoiding repetition and boilerplate.
They enable us to implement common patterns such as map, filter, reduce, etc. that can operate on any type of data.

Some examples of higher order functions are:

forEach(): This is a built-in array method that takes a function as an argument and applies it to each element of the array. For example:
```
let arr = [1, 2, 3];
arr.forEach((element) => console.log(element * 2)); // logs 2, 4, 6
```
map(): This is another built-in array method that takes a function as an argument and returns a new array with the results of applying the function to each element of the array. For example:
```
let arr = [1, 2, 3];
let newArr = arr.map((element) => element * 2); // returns [2, 4, 6]
```
filter(): This is also a built-in array method that takes a function as an argument and returns a new array with only the elements that pass the test implemented by the function. For example:
```
let arr = [1, 2, 3, 4, 5];
let newArr = arr.filter((element) => element % 2 === 0); // returns [2, 4]
```
reduce(): This is yet another built-in array method that takes a function and an initial value as arguments and returns a single value that is the result of applying the function to each element of the array and accumulating the result. For example:
```
let arr = [1, 2, 3];
let sum = arr.reduce((acc, element) => acc + element, 0); // returns 6
```
setTimeout(): This is a built-in function that takes a function and a delay (in milliseconds) as arguments and executes the function after the specified delay. For example:
```
function greet() {
console.log("Hello");
}

setTimeout(greet, 1000); // logs "Hello" after 1 second
```
setInterval(): This is another built-in function that takes a function and a delay (in milliseconds) as arguments and executes the function repeatedly with the specified delay between each call. For example:
```
function greet() {
console.log("Hello");
}

setInterval(greet, 1000); // logs "Hello" every 1 second
```
addEventListener(): This is a built-in method that takes an event type (such as "click") and a function (called a callback) as arguments and registers the function to be executed when the event occurs on the target element. For example:
```
let button = document.getElementById("button");

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

button.addEventListener("click", greet); // logs "Hello" when the button is clicked
```

Reference

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of

https://victoriacheng15.hashnode.dev/javascript-mutable-array-methods

https://www.linkedin.com/pulse/javascript-mutable-immutable-bharath-kumar-murugan

https://www.scaler.com/topics/javascript/pass-by-value-and-pass-by-reference/

https://www.freecodecamp.org/news/higher-order-functions-in-javascript-explained/

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_Objects

https://www.tutorialsteacher.com/javascript/scope-in-javascript

HTML/CSS Concepts

Sagar Dutta — Wed, 24 May 2023 12:27:02 +0000

Box Model

The box model is a way of describing how the size and spacing of an element are calculated by the browser. The box model consists of four parts: content, padding, border and margin.

The content is the actual text or image that the element contains. The width and height properties of an element only affect the content area, not the padding, border or margin.
The padding is the space between the content and the border. It is transparent and can have different values for each side.
The border is the line that surrounds the padding and the content. It can have different styles, widths and colors.
The margin is the space outside the border. It is also transparent and can have different values for each side. It creates a gap between adjacent elements.

Inline versus Block Elements. Examples.

The difference between inline and block elements is how they behave in terms of page flow and layout. Here are some key points:

Block elements always start on a new line and take up the full width available. They respect the width, height, padding, margin and border properties. They create a vertical gap between adjacent elements. Some examples of block elements are <div>, <p>, <h1>-<h6>, <ul>, <ol>, <li>, <table> etc.
Inline elements do not start on a new line and only take up as much width as necessary. They do not respect the width, height, vertical padding, margin and border properties. They do not create a vertical gap between adjacent elements. Some examples of inline elements are <a>, <span>, <em>, <strong>, <img>, <input>, <button> etc.

Positioning: Relative/Absolute

An element with position: relative is positioned relative to its normal position. Setting the top, right, bottom, and left properties of a relatively-positioned element will cause it to be adjusted away from its normal position. Other content will not be adjusted to fit into any gap left by the element.
An element with position: absolute is positioned relative to the nearest positioned ancestor (instead of positioned relative to the viewport, like fixed). However; if an absolute positioned element has no positioned ancestors, it uses the document body and moves along with page scrolling. Note that absolute positioned elements are removed from the normal flow and can overlap elements.

Common CSS structural classes

Structural pseudo classes allow access to the child elements present within the hierarchy of parent elements. Commonly used ones are:

:first-child

Selects first child element under the parent element when first child element is a specified element.
:last-child

Selects last child element under the parent element when last child element is a specified element.
:hover

This pseudo-class is used to add a special effect to an element when the mouse pointer is over it.
:active

This pseudo-class is used to select an element that is activated when the user clicks on it.
:focus

This pseudo-class is used to select an element that is currently focused by the user. It works on user input elements used in forms and is triggered as soon as the user clicks on it.

CSS Specificity

Every CSS selector has its place in the specificity hierarchy.

There are four categories which define the specificity level of a selector:

Inline styles - Example: <h1 style="color: pink;">
IDs - Example: #navbar
Classes, pseudo-classes, attribute selectors - Example: .test, :hover, [href]
Elements and pseudo-elements - Example: h1, ::before

CSS Responsive Queries

CSS media queries are a way to apply CSS only when the browser and device environment matches a rule that we specify, for example "viewport is wider than 480 pixels". Media queries are a key part of responsive web design, as they allow us to create different layouts depending on the size of the viewport, but they can also be used to detect other things about the environment our site is running on, such as whether the user is using a touchscreen rather than a mouse.

The basic syntax of a media query looks like this:

@media media-type and (media-feature-rule) {
  /* CSS rules go here */
}

Flexbox

Flexbox is a CSS layout module that allows you to arrange elements in a flexible way. It is especially useful for creating responsive layouts that adapt to different screen sizes and orientations.

Flexbox is based on the concept of a flex container and flex items. A flex container is an element that has display: flex or display: inline-flex applied to it. A flex item is any direct child of a flex container.

Flexbox provides a set of properties that allow you to control the layout of the flex container and its items. Some properties apply to the flex container, and some apply to the flex items.

Common Flex Container Properties

flex-direction: This property defines the direction of the main axis. It can have one of these values: row, row-reverse, column, column-reverse. The default value is row.
flex-wrap: This property defines whether the flex items should wrap onto multiple lines or not. It can have one of these values: nowrap, wrap, wrap-reverse. The default value is nowrap.
flex-flow: This property is a shorthand for flex-direction and flex-wrap. It can have any combination of these values: row, row-reverse, column, column-reverse, nowrap, wrap, wrap-reverse. The default value is row nowrap.
justify-content: This property defines how the flex items are aligned along the main axis. It can have one of these values: flex-start, flex-end, center, space-between, space-around, space-evenly. The default value is flex-start.
align-items: This property defines how the flex items are aligned along the cross axis. It can have one of these values: stretch, flex-start, flex-end, center, baseline. The default value is stretch.
align-content: This property defines how the lines of flex items are aligned along the cross axis when there is extra space. It can have one of these values: stretch, flex-start, flex-end, center, space-between, space-around. The default value is stretch.

Common Flex Item Properties

order: This property defines the order in which the flex items appear in the flex container. It can have any integer value, positive or negative. The default value is 0.
flex-grow: This property defines how much a flex item can grow relative to the rest of the flex items in the same line. It can have any non-negative number value. The default value is 0.
flex-shrink: This property defines how much a flex item can shrink relative to the rest of the flex items in the same line. It can have any non-negative number value. The default value is 1.
flex-basis: This property defines the initial size of a flex item before any free space is distributed. It can have any length value, or a keyword value of auto or content. The default value is auto.
flex: This property is a shorthand for flex-grow, flex-shrink and flex-basis. It can have any combination of these values: a non-negative number for flex-grow, a non-negative number for
flex-shrink, a length or keyword value for flex-basis. The default value is 0 1 auto.
align-self: This property overrides the align-items property for a specific flex item. It can have one of these values: auto, stretch, flex-start, flex-end, center, baseline. The default value is auto.

Flexbox Examples

Example 1: A simple row layout

In this example, we create a simple row layout with three div elements inside a flex container. We use justify-content to align them to the center of the main axis.

.container {
  display: flex;
  justify-content: center;
}

.item {
  width: 100px;
  height: 100px;
  margin: 10px;
  background-color: coral;
}

<div class="container">
  <div class="item">1</div>
  <div class="item">2</div>
  <div class="item">3</div>
</div>

Example 2: A simple column layout

In this example, we create a simple column layout with three div elements inside a flex container. We use flex-direction to change the direction of the main axis to column, and align-items to align them to the center of the cross axis.

.container {
  display: flex;
  flex-direction: column;
  align-items: center;
}

.item {
  width: 100px;
  height: 100px;
  margin: 10px;
  background-color: coral;
}

<div class="container">
  <div class="item">1</div>
  <div class="item">2</div>
  <div class="item">3</div>
</div>

Grid

CSS grid is a CSS layout module that allows us to create two-dimensional grid layouts on the web. It is especially useful for creating complex and responsive layouts that are not possible with other layout methods.

CSS grid is based on the concept of a grid container and grid items. A grid container is an element that has display: grid or display: inline-grid applied to it. A grid item is any direct child of a grid container.

CSS grid provides a set of properties that allow you to control the layout of the grid container and its items. Some properties apply to the grid container, and some apply to the grid items.

Common Grid Container Properties

grid-template-columns: This property defines the size and number of columns in the grid. It can have a list of values separated by spaces, where each value represents the size of a column. The values can be lengths, percentages, fractions of the free space using the fr unit, or keywords such as auto or minmax. You can also use the repeat() function to repeat a pattern of values.
grid-template-rows: This property defines the size and number of rows in the grid. It can have a list of values separated by spaces, where each value represents the size of a row. The values can be lengths, percentages, fractions of the free space using the fr unit, or keywords such as auto or minmax. You can also use the repeat() function to repeat a pattern of values.
grid-template-areas: This property defines the layout of the grid by assigning names to grid areas and placing them in a grid template. It can have a list of strings separated by commas, where each string represents a row of the grid template. The strings can have names that match the names given to grid items using the grid-area property, or dots (.) to represent empty cells.
grid-auto-columns: This property defines the size of columns that are created implicitly when there are more grid items than columns defined by grid-template-columns. It can have a single value that applies to all implicit columns, or a list of values that apply to implicit columns in a cycle.
grid-auto-rows: This property defines the size of rows that are created implicitly when there are more grid items than rows defined by grid-template-rows. It can have a single value that applies to all implicit rows, or a list of values that apply to implicit rows in a cycle.
grid-auto-flow: This property defines how grid items are placed in the grid when they are not explicitly positioned using grid-column or grid-row. It can have one of these values: row, column, row dense, column dense. The default value is row.
grid: This property is a shorthand for setting all of the explicit and implicit grid properties in one declaration. It can have any combination of these values: a list of values for grid-template-columns, followed by a slash (/) and a list of values for grid-template-rows, followed by an optional list of strings for grid-template-areas; or one or more values for grid-auto-flow, followed by optional values for grid-auto-rows and/or grid-auto-columns.
justify-items: This property defines how grid items are aligned along the row axis within their grid area. It can have one of these values: start, end, center, stretch. The default value is stretch.
align-items: This property defines how grid items are aligned along the column axis within their grid area. It can have one of these values: start, end, center, stretch. The default value is stretch.
justify-content: This property defines how the entire grid is aligned along the row axis within its container. It can have one of these values: start, end, center, stretch, space-around, space-between, space-evenly. The default value is start.
align-content: This property defines how the entire grid is aligned along the column axis within its container. It can have one of these values: start, end, center, stretch, space-around, space-between, space-evenly. The default value is start.

Common Grid Item Properties

order: This property defines the order in which the grid items appear in the grid container. It can have any integer value, positive or negative. The default value is 0.
grid-column-start: This property defines the starting column line for
the grid item's placement in the grid. It can have any integer value that refers to a line number or name, or a keyword value such as
auto, span, or -n. The default value is auto.
grid-column-end: This property defines the ending column line for
the grid item's placement in the grid. It can have any integer value that refers to a line number or name, or a keyword value such as
auto, span, or -n. The default value is auto.
grid-row-start: This property defines the starting row line for
the grid item's placement in the grid. It can have any integer value that refers to a line number or name, or a keyword value such as
auto, span, or -n. The default value is auto.
grid-row-end: This property defines the ending row line for
the grid item's placement in the grid. It can have any integer value that refers to a line number or name, or a keyword value such as
auto, span, or -n. The default value is auto.
grid-column: This property is a shorthand for setting both
grid-column-start and grid-column-end in one declaration. It can have any combination of these values: an integer value or name for
grid-column-start, followed by a slash (/) and an integer value or name for grid-column-end; or a keyword value such as auto
or span n. The default value is 1 / -1.
grid-row: This property is a shorthand for setting both
grid-row-start and grid-row-end in one declaration. It can have any combination of these values: an integer value or name for grid-row-start, followed by a slash (/) and an integer value or name for grid-row-end; or a keyword value such as auto or span n.
The default value is 1 / -1.

Common header meta tags

Meta tags are snippets of HTML code that provide information about a web page to browsers, search engines and other web services. Meta tags are placed inside the <head> element of a web page, and have the following format:

<meta name="name" content="content">

<meta http-equiv="name" content="content">

The name attribute specifies the name of the meta tag, and the content attribute specifies the value of the meta tag. The http-equiv attribute can be used to simulate an HTTP response header.

Common header meta tags and their purposes:

<meta charset="UTF-8">: This meta tag specifies the character encoding of the web page. It is recommended to use UTF-8 as the universal character set for all web pages.
<meta name="description" content="Free Web tutorials">: This meta tag provides a brief description of the web page. It is often used by search engines to display a snippet of the page in the search results.
<meta name="keywords" content="HTML, CSS, JavaScript">: This meta tag provides a list of keywords that are relevant to the web page. It was once used by search engines to rank pages based on their keywords, but it is no longer considered a major ranking factor.
<meta name="author" content="John Doe">: This meta tag provides the name of the author of the web page. It can be used to give credit to the creator of the content.
<meta name="viewport" content="width=device-width, initial-scale=1.0">: This meta tag controls how the web page is displayed on different devices and screen sizes. It sets the width of the viewport (the visible area of the web page) to match the width of the device, and sets the initial zoom level to 1.0 (no zoom). This helps to create responsive web pages that adapt to different devices and orientations.
<meta http-equiv="refresh" content="30">: This meta tag instructs the browser to refresh the web page every 30 seconds. It can be used to update dynamic content or redirect users to another page after a certain time.
<meta http-equiv="content-type" content="text/html; charset=UTF-8">: This meta tag specifies the MIME type and character encoding of the web page. It is equivalent to sending an HTTP header with the same information. It is not necessary if you already have a <meta charset> tag.

References

https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Box_Model

https://developer.mozilla.org/en-US/docs/Learn/CSS/Building_blocks/The_box_model

https://www.w3schools.com/htmL/html_blocks.asp

https://www.w3schools.com/Css/css_positioning.asp

https://askanydifference.com/difference-between-relative-positioning-and-absolute-positioning-in-css/

https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries

https://css-tricks.com/snippets/css/a-guide-to-flexbox/

https://css-tricks.com/snippets/css/complete-guide-grid/

https://www.elated.com/common-html-meta-tags/

7 Layers of the OSI Model

Sagar Dutta — Mon, 15 May 2023 11:31:15 +0000

The OSI Model or the Open Systems Interconnection Model is a conceptual framework which describes the functions of a networking system. It is used for the transfer of data over a network which moves through different layers. The seven layers are:

1. Physical Layer

It is the bottom-most or the first layer of the OSI Model.
It comprises the raw data which is further transmitted to the higher layers of the structure.
Preparing the physical devices in the network and accepting the received data for transmission.
The termination of connection between two nodes of a network also takes place at this stage.
This layer converts the digital bits into electrical, radio, or optical signals.
Examples of hardware in the physical layer are network adapters, ethernet, repeaters, networking hubs, etc.

2. Data Link Layer

Access to get the data is achieved at this layer.
It breaks the input data into frames which makes analysing the data easier.
Ensures that the data received is free of any errors.
It controls the flow of data in the stipulated time duration and along with a set speed of transmission.
The data is sent to the next layer in the form of packets which are then reviewed for further processing.
The data link layer is subdivided into two types of sublayers:
- Media Access Control (MAC) layer- It is responsible for controlling how device in a network gain access to medium and permits to transmit data.
- Logical link control layer- This layer is responsible for identity and encapsulating network-layer protocols and allows you to find the error.

3. Network Layer

It acts as a network controller.
Transferring of variable data from one node to another, connected in a network, takes place at this layer.
Each node has a specific address and the network layer ensures that the data is sent to its destination address.
The data is sent in the form of fragments which are then connected to each other once the processing is done.

4. Transport Layer

The delivery of data packets is managed by the transport layer.
It manages the flow of data, segmentation and desegmentation and error control.
There are five classes of the transport protocol, starting from 0 and continuing till 4 (TP0 to TP4).
Fragmentation and reassembly of data packets occur that this stage.

5. Session Layer

The connection between the computers connected in a network is managed at this layer.
Establishment, management and termination between the remote and local application takes place here.
Authentication and authorisation happen at this layer.
This layer can also terminate or end any session or transmission which is complete.

6. Presentation Layer

The data is converted into the syntax or semantics which an application understands.
Before passing on the data any further, the data is formatted at this stage.
Functions including compression, encryption, compatible character code set, etc. are also done at this layer of the model.
It serves as a data translator for the network.

7. Application Layer

The interaction with the user or the user application takes place at this stage.
When identifying communication partners, the application layer determines the identity and availability of communication partners for an application with data to transmit.

Advantages of the OSI Model

It helps to standardize router, switch, motherboard, and other hardware.
Reduces complexity and standardizes interfaces.
Facilitates modular engineering.
Helps to ensure interoperable technology.
Helps to accelerate the evolution.
Protocols can be replaced by new protocols when technology changes.
Provide support for connection-oriented services as well as connectionless service.
It is a standard model in computer networking.
Supports connectionless and connection-oriented services.
Offers flexibility to adapt to various types of protocols.

Disadvantages of the OSI Model

Fitting of protocols is a tedious task.
We can only use it as a reference model.
Doesn’t define any specific protocol.
In the OSI network layer model, some services are duplicated in many layers such as the transport and data link layers.
Layers can’t work in parallel as each layer need to wait to obtain data from the previous layer.

Summary

Layer	Name	Function	Protocols
Layer 7	Application	To allow access to network resources.	SMTP, HTTP, FTP, POP3, SNMP
Layer 6	Presentation	To translate, encrypt and compress data.	MPEG, ASCH, SSL, TLS
Layer 5	Session	To establish, manage, and terminate the session	NetBIOS, SAP
Layer 4	Transport	The transport layer builds on the network layer to provide data transport from a process on a source machine to a process on a destination machine.	TCP, UDP
Layer 3	Network	To provide internetworking. To move packets from source to destination	IPV5, IPV6, ICMP, IPSEC, ARP, MPLS.
Layer 2	Data Link	To organize bits into frames. To provide hop-to-hop delivery	RAPA, PPP, Frame Relay, ATM, Fiber Cable, etc.
Layer 1	Physical	To transmit bits over a medium. To provide mechanical and electrical specifications	RS232, 100BaseTX, ISDN, 11.

Reference

SOLID Design Principles

Sagar Dutta — Mon, 15 May 2023 10:32:34 +0000

The SOLID Principles are five principles of Object-Oriented class design. They are a set of rules and best practices to follow while designing a class structure. These principles encourage us to create more maintainable, understandable, and flexible software.

SOLID stands for five key design principles:

Single responsibility principle

A class should have one and only one reason to change, meaning that a class should have only one job.
Open-closed principle

Objects or entities should be open for extension but closed for modification, meaning that a class should be easily extendable without modifying the class itself.
Liskov substitution principle

Every subclass or derived class should be substitutable for their base or parent class, meaning that a subclass should override the parent class methods in a way that does not break functionality or cause errors.
Interface segregation principle

A client should never be forced to implement an interface that it doesn’t use or clients shouldn’t be forced to depend on methods they do not use, meaning that interfaces should be fine-grained and specific rather than coarse-grained and generic.
Dependency inversion principle

Entities must depend on abstractions, not on concretions, meaning that the high-level module must not depend on the low-level module, but they should depend on abstractions.

Benefits of each principle

Principle	Description	Benefits
Single responsibility	A class should have only one job	Easier testing, lower coupling, better organization
Open-closed	A class should be extendable without modification	More flexibility, less code duplication, easier maintenance
Liskov substitution	A subclass should be substitutable for its parent class	More consistency, better code reuse
Interface segregation	Interfaces should be specific and not generic	Less coupling, more cohesion, easier testing
Dependency inversion	High-level modules should not depend on low-level modules	More modularity, more testability, more extensibility

Explanation with examples

Single responsibility principle

For example, let’s look at a class that handles both database operations and logging:

class Employee:
def __init__(self, name, salary):
    self.name = name
    self.salary = salary

#database operations
def save(self):
    #save employee to database

def delete(self):
    #delete employee from database

#logging operations
def log_error(self, message):
    #log error message

def log_info(self, message):
    #log info message

This class violates the single responsibility principle because it has more than one reason to change: it could change due to changes in the database logic or due to changes in the logging logic. A better approach would be to separate these responsibilities into different classes:

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

class EmployeeRepository:
    #database operations
    def save(self, employee):
        #save employee to database

    def delete(self, employee):
        #delete employee from database

class EmployeeLogger:
    #logging operations
    def log_error(self, message):
        #log error message

    def log_info(self, message):
        #log info message

Now we have three classes, each with a single responsibility. This makes them easier to test, maintain and reuse.

Open-closed principle

Let's understand this with an example:

class Person:
    def __init__(self, name):
        self.name = name

    def __repr__(self):
        return f'Person(name={self.name})'

class PersonStorage:
    def save_to_database(self, person):
        print(f'Save the {person} to database')

    def save_to_json(self, person):
        print(f'Save the {person} to a JSON file')

if __name__ == '__main__':
    person = Person('John Doe')
    storage = PersonStorage()
    storage.save_to_database(person)

In this example, the PersonStorage class has two methods:

The save_to_database() method saves a person to the database.
The save_to_json() method saves a person to a JSON file.

Later, if we want to save the Person’s object into a file, we must modify the PersonStorage class. It means that the PersonStorage class is not open for extension but modification. Hence, it violates the open-closed principle.

To make the PersonStorage class conforms with the open-closed principle; we need to design the classes so that when we need to save the Person’s object into a different file format, we don’t need to modify it.

First, define the PersonStorage abstract class that contains the save() abstract method:

from abc import ABC, abstractmethod

class PersonStorage(ABC):
    @abstractmethod
    def save(self, person):
        pass

Second, create two classes PersonDB and PersonJSON that save the Person object into the database and JSON file. These classes inherit from the PersonStorage class:

class PersonDB(PersonStorage):
    def save(self, person):
        print(f'Save the {person} to database')

class PersonJSON(PersonStorage):
    def save(self, person):
        print(f'Save the {person} to a JSON file')

To save the Person object into an XML file, we can define a new class PersonXML that inherits from the PersonStorage class like this:

class PersonXML(PersonStorage):
    def save(self, person):
        print(f'Save the {person} to an XML file')

And we can save the Person‘s object into an XML file using the PersonXML class:

if __name__ == '__main__':
    person = Person('John Doe')
    storage = PersonXML()
    storage.save(person)

Liskov substitution principle

Consider the following example:

from abc import ABC, abstractmethod

class Notification(ABC):
    @abstractmethod
    def notify(self, message, email):
        pass

class Email(Notification):
    def notify(self, message, email):
        print(f'Send {message} to {email}')

class SMS(Notification):
    def notify(self, message, phone):
        print(f'Send {message} to {phone}')

if __name__ == '__main__':
    notification = SMS()
    notification.notify('Hello', 'john@test.com')

In this example, we have three classes: Notification, Email, and SMS. The Email and SMS classes inherit from the Notification class.

The Notification abstract class has notify() method that sends a message to an email address.

The notify() method of the Email class sends a message to an email, which is fine.

However, the SMS class uses a phone number, not an email, for sending a message. Therefore, we need to change the signature of the notify() method of the SMS class to accept a phone number instead of an email.

The following NotificationManager class uses the Notification object to send a message to a Contact:

class Contact:
    def __init__(self, name, email, phone):
        self.name = name
        self.email = email
        self.phone = phone

class NotificationManager:
    def __init__(self, notification, contact):
        self.contact = contact
        self.notification = notification

    def send(self, message):
        if isinstance(self.notification, Email):
            self.notification.notify(message, contact.email)
        elif isinstance(self.notification, SMS):
            self.notification.notify(message, contact.phone)
        else:
            raise Exception('The notification is not supported')

if __name__ == '__main__':
    contact = Contact('John Doe', 'john@test.com', '(408)-888-9999')
    notification_manager = NotificationManager(SMS(), contact)
    notification_manager.send('Hello John')

The send() method of the NoticationManager class accepts a notification object. It checks whether the notification is an instance of the Email or SMS and passes the email and phone of contact to the notify() method respectively.

Conform with the Liskov substitution principle

First, redefine the notify() method of the Notification class so that it doesn’t include the email parameter:

class Notification(ABC):
    @abstractmethod
    def notify(self, message):
        pass

Second, add the email parameter to the init method of the Email class:

class Email(Notification):
    def __init__(self, email):
        self.email = email

    def notify(self, message):
        print(f'Send "{message}" to {self.email}')

Third, add the phone parameter to the init method of the SMS class:

class SMS(Notification):
    def __init__(self, phone):
        self.phone = phone

    def notify(self, message):
        print(f'Send "{message}" to {self.phone}')

Fourth, change the NotificationManager class:

class NotificationManager:
    def __init__(self, notification):
        self.notification = notification

    def send(self, message):
        self.notification.notify(message)

Interface segregation principle

Consider the following example:

First, define a Vehicle abstract class that has two abstract methods, go() and fly():
```
from abc import ABC, abstractmethod

class Vehicle(ABC):
    @abstractmethod
    def go(self):
        pass

    @abstractmethod
    def fly(self):
        pass
```
Second, define the Aircraft class that inherits from the Vehicle class and implement both go() and fly() methods:
```
class Aircraft(Vehicle):
    def go(self):
        print("Taxiing")

    def fly(self):
        print("Flying")
```
Third, define the Car class that inherits from the Vehicle class. Since a car cannot fly, we raise an exception in the fly() method:
```
class Car(Vehicle):
    def go(self):
        print("Going")

    def fly(self):
        raise Exception('The car cannot fly')
```
In this design the Car class must implement the fly() method from the Vehicle class that the Car class doesn’t use. Therefore, this design violates the interface segregation principle.

To fix this, we need to split the Vehicle class into small ones and inherits from these classes from the Aircraft and Car classes:

First, split the Vehicle interface into two smaller interfaces: Movable and Flyable, and inherits the Movable class from the Flyable class:
```
class Movable(ABC):
    @abstractmethod
    def go(self):
        pass

class Flyable(Movable):
    @abstractmethod
    def fly(self):
        pass
```
Second, inherits from the Flyable class from the Aircraft class:
```
class Aircraft(Flyable):
    def go(self):
        print("Taxiing")

    def fly(self):
        print("Flying")
```
Third, inherit the Movable class from the Car class:
```
class Car(Movable):
    def go(self):
        print("Going")
```
In this design, the Car only need to implement the go() method that it needs. It doesn’t need to implement the fly() method that it doesn’t use.
Dependency inversion principle
```
class FXConverter:
    def convert(self, from_currency, to_currency, amount):
        print(f'{amount} {from_currency} = {amount * 1.2} {to_currency}')
        return amount * 1.2

class App:
    def start(self):
        converter = FXConverter()
        converter.convert('EUR', 'USD', 100)

if __name__ == '__main__':
    app = App()
    app.start()
```
In this example, we have two classes FXConverter and App.

The FXConverter class uses an API from an imaginary FX third-party to convert an amount from one currency to another. For simplicity, we hardcoded the exchange rate as 1.2. In practice, we will need to make an API call to get the exchange rate.

The App class has a start() method that uses an instance of the FXconverter class to convert 100 EUR to USD.

The App is a high-level module. However, The App depends heavily on the FXConverter class that is dependent on the FX’s API.

In the future, if the FX’s API changes, it’ll break the code. Also, if we want to use a different API, we’ll need to change the App class.

To prevent this, we need to invert the dependency so that the FXConverter class needs to adapt to the App class.

To do that, we define an interface and make the App dependent on it instead of FXConverter class. And then we change the FXConverter to comply with the interface.

First, define an abstract class CurrencyConverter that acts as an interface. The CurrencyConverter class has the convert() method that all of its subclasses must implement:
```
from abc import ABC

class CurrencyConverter(ABC):
    def convert(self, from_currency, to_currency, amount) -> float:
        pass
```
Second, redefine the FXConverter class so that it inherits from the CurrencyConverter class and implement the convert() method:
```
class FXConverter(CurrencyConverter):
    def convert(self, from_currency, to_currency, amount) -> float:
        print('Converting currency using FX API')
        print(f'{amount} {from_currency} = {amount * 1.2} {to_currency}')
        return amount * 2
```
Third, add the init method to the App class and initialize the CurrencyConverter‘s object:
```
class App:
    def __init__(self, converter: CurrencyConverter):
        self.converter = converter

    def start(self):
        self.converter.convert('EUR', 'USD', 100)
```
Now, the App class depends on the CurrencyConverter interface, not the FXConverter class.

The following creates an instance of the FXConverter and pass it to the App:
```
if __name__ == '__main__':
    converter = FXConverter()
    app = App(converter)
    app.start()
```
In the future, we can support another currency converter API by subclassing the CurrencyConverter class. For example, the following defines the AlphaConverter class that inherits from the CurrencyConverter.
```
class AlphaConverter(CurrencyConverter):
    def convert(self, from_currency, to_currency, amount) -> float:
        print('Converting currency using Alpha API')
        print(f'{amount} {from_currency} = {amount * 1.2} {to_currency}')
        return amount * 1.15
```
Since the AlphaConvert class inherits from the CurrencyConverter class, you can use its object in the App class without changing the App class:
```
if __name__ == '__main__':
    converter = AlphaConverter()
    app = App(converter)
    app.start()
```

References

DBMS Concepts

Sagar Dutta — Fri, 12 May 2023 13:20:26 +0000

ACID

To ensure that the database is in a consistent state both before and after the transaction, one needs to follow certain properties and those properties are known as ACID properties. ACID is an acronym for Atomicity, Consistency, Isolation, and Durability. Much of the architecture of any modern relational database is founded on these properties.

Atomicity

The concept of atomicity describes how the data stays atomic. In other words, if an action is performed on the data, it should either be executed, completed, or not executed at all i.e. all the DML Statements (i.e. insert, update, delete) inside a transaction are completed successfully or all of them are rolled back. Additionally, it signifies that the process shouldn’t pause or run in segments. If an operation needs to be performed on the transaction, it should be carried out entirely and not in parts. It includes two operations in it and these are:
- Commit: Changes are shown after a transaction commits.
- Abort: Changes to the database are invisible if a transaction aborts.
Consistency

Consistency ensures that the database data is constantly maintained. The integrity of the data should be upheld in DBMS, which means that changes to the database should always be saved. When it comes to transactions, data integrity is crucial to ensuring that the database is consistent both before and after the transaction.
Isolation

Isolation guarantees that numerous transactions can take place simultaneously without causing the database state to become inconsistent. Transactions take place without interruption and independently. The Data modifications made by one transaction must be isolated from the data modifications made by all other transactions. This property guarantees that the state created by concurrently running transactions will be the same as the state created by serially running them in some order.
Durability

Durability guarantees that data remains in the database permanently once an operation has been successfully completed. Data stored in a database should be so perfectly durable that it can still function even in the event of a system failing, malfunctions, or crash. However, if it disappears, the recovery manager is now in charge of making sure the database is durable. Whenever changes are made in the database, we must use the COMMIT command to commit those changes and avoid the risk of losing that data.

CAP Theorem

The CAP theorem states that a distributed database system has to make a tradeoff between Consistency and Availability when a Partition occurs.

Consistency

Consistency means that the user should be able to see the same data no matter which node they connect to on the system. This data is the most recent data written to the system. So if a write operation has occurred on a node, it should be replicated to all its replicas. So that whenever a user connects to the system, they can see that same information.

However, having a system that maintains consistency instantaneously and globally is near impossible. Therefore, the goal is to make this transition fast enough so that it is hardly noticeable.
Availability

Availability means that every request from the user should elicit a response from the system. Whether the user wants to read or write, the user should get a response even if the operation was unsuccessful.

Availability is of importance when it is required that the client or user be able to access the data at all times, even if it is not consistent
Partition Tolerance

Partition refers to a communication break between nodes within a distributed system. Meaning, if a node cannot receive any messages from another node in the system, there is a partition between the two nodes. Partition could have been because of network failure, server crash, or any other reason.

So, if Partition means a break in communication then Partition tolerance would mean that the system should still be able to work even if there is a partition in the system. Meaning if a node fails to communicate, then one of the replicas of the node should be able to retrieve the data required by the user.

This is handled by keeping replicas of the records in multiple different nodes. So that even if a partition occurs, we are able to retrieve the data from its replica.

Joins

Lets understand Joins with an example. Consider these two tables:

Student

ROLL_NO	NAME	AGE
1	John	18
2	Amy	19
3	Bob	20
4	Eve	21

StudentCourse

COURSE_ID	ROLL_NO
C1	1
C2	2
C3	3
C4	4
C5	5

Inner Join

This join will return the records that have matching values in both tables. For example, this query will show the names and courses of students enrolled in different courses.
```
SELECT Student.NAME, StudentCourse.COURSE_ID
FROM Student
INNER JOIN StudentCourse
ON Student.ROLL_NO = StudentCourse.ROLL_NO;
```
NAME COURSE_ID

John C1

Amy C2

Bob C3

Eve C4
Left Join

This join will return all the records from the left table, and the matched records from the right table. If there is no match, the right side will contain null. For example, this query will show the names and courses of all students, even if they are not enrolled in any course.
```
SELECT Student.NAME, StudentCourse.COURSE_ID
FROM Student
LEFT JOIN StudentCourse
ON Student.ROLL_NO = StudentCourse.ROLL_NO;
```
NAME COURSE_ID

John C1

Amy C2

Bob C3

Eve C4

Tom null
Right Join

This join will return all the records from the right table, and the matched records from the left table. If there is no match, the left side will contain null. For example, this query will show the names and courses of all courses, even if they have no students enrolled.
```
SELECT Student.NAME, StudentCourse.COURSE_ID
FROM Student
RIGHT JOIN StudentCourse
ON Student.ROLL_NO = StudentCourse.ROLL_NO;
```
NAME COURSE_ID

John C1

Amy C2

Bob C3

Eve C4

null C5
Full Join

This join will return all the records when there is a match in either left or right table. If there is no match, both sides will contain null. For example, this query will show the names and courses of all students and all courses.
```
SELECT Student.NAME, StudentCourse.COURSE_ID
FROM Student
FULL JOIN StudentCourse
ON Student.ROLL_NO = StudentCourse.ROLL_NO;
```
NAME COURSE_ID

John C1

Amy C2

Bob C3

Eve C4

Tom null

null C5
Natural Join

This join will return the records that have matching values in all common columns. The common columns are determined by their names and data types. For example, this query will show the names and courses of students enrolled in different courses.
```
SELECT *
FROM Student
NATURAL JOIN StudentCourse;
```
ROLL_NO NAME AGE COURSE_ID

1 John 18 C1

2 Amy 19 C2

3 Bob 20 C3

4 Eve 21 C4

NAME	COURSE_ID
John	C1
Amy	C2
Bob	C3
Eve	C4

NAME	COURSE_ID
John	C1
Amy	C2
Bob	C3
Eve	C4
Tom	null

NAME	COURSE_ID
John	C1
Amy	C2
Bob	C3
Eve	C4
null	C5

NAME	COURSE_ID
John	C1
Amy	C2
Bob	C3
Eve	C4
Tom	null
null	C5

ROLL_NO	NAME	AGE	COURSE_ID
1	John	18	C1
2	Amy	19	C2
3	Bob	20	C3
4	Eve	21	C4

Aggregations, Filters in queries

Data aggregation is any process whereby data is gathered and expressed in a summary form. When data is aggregated, atomic data rows -- typically gathered from multiple sources -- are replaced with totals or summary statistics. Groups of observed aggregates are replaced with summary statistics based on those observations. Aggregate data is typically found in a data warehouse, as it can provide answers to analytical questions and also dramatically reduce the time to query large sets of data.

Data aggregation is often used to provide statistical analysis for groups of people and to create useful summary data for business analysis.

Data aggregators work by combining atomic data from multiple sources, processing the data for new insights and presenting the aggregate data in a summary view. Furthermore, data aggregators usually provide the ability to track data lineage and can trace back to the underlying atomic data that was aggregated.

A natural extension to aggregation scoping is filtering. Filters are applied to database indexes, filtering out data that does not match a predicate. Filters cannot do anything that could not be done directly with indexes, but they do allow us to separate some aspect of a query, reusing query logic across different filtered views.

Normalization

Database Normalization is a technique of organizing the data in the database to minimize redundancy and improve data integrity. It is a multi-step process that puts data into tabular form, removing duplicated data from the relation tables.

Normalization is used for mainly two purposes:

Eliminating redundant(useless) data.
Ensuring data dependencies make sense i.e data is logically stored.

There are different levels of normalization, called normal forms, that follow certain rules and constraints:

First Normal Form (1NF)

A relation is in 1NF if it contains only atomic values, i.e., each attribute has a single value for each tuple. There are no repeating groups or arrays in the relation.
Second Normal Form (2NF)

A relation is in 2NF if it is in 1NF and all non-key attributes are fully functionally dependent on the primary key, i.e., there are no partial dependencies. A partial dependency occurs when a non-key attribute depends on only a part of the primary key.
Third Normal Form (3NF)

A relation is in 3NF if it is in 2NF and there are no transitive dependencies, i.e., no non-key attribute depends on another non-key attribute. A transitive dependency occurs when a non-key attribute depends on another non-key attribute that depends on the primary key.
Boyce Codd Normal Form (BCNF)

Boyce Codd Normal Form (BCNF) is a stronger version of Third Normal Form (3NF) that eliminates more redundancy and anomalies. A relation is in BCNF if for every functional dependency X -> Y, X is a superkey or a candidate key. A superkey is a set of attributes that uniquely identifies a tuple, and a candidate key is a minimal superkey.

Indexes

Indexing is a data structure technique which allows us to quickly retrieve records from a database file. An Index is a small table having only two columns. The first column comprises a copy of the primary or candidate key of a table. Its second column contains a set of pointers for holding the address of the disk block where that specific key value stored.

An index:

Takes a search key as input
Efficiently returns a collection of matching records.

Syntax:

CREATE INDEX index_name ON table_name;

Transactions

A database transaction is a sequence of operations on a database that is treated as a single unit and they are executed by applying the principle “do everything or do nothing” and a successful transaction must pass the ACID test. Transactions may consist of a single read, write, delete, or update operations or a combination of these.

Locking mechanism

Locking mechanisms are a way for databases to produce sequential data output without the sequential steps. The locks provide a method for securing the data that is being used so no anomalies can occur like lost data or additional data that can be added because of the loss of a transaction.

Problems that Locks Solve:

Lost Update Problem

A lost update occurs when two different transactions are trying to update the same column on the same row within a database at the same time.
Temporary Update Problem

Temporary update or dirty read problem occurs when one transaction updates an item and fails.
Incorrect Summary Problem

Incorrect Summary issue occurs when one transaction takes summary over the value of all the instances of a repeated data-item, and second transaction update few instances of that specific data-item.
Phantom Reads

A lower isolation level increases the ability of many users to access the same data at the same time, but increases the number of concurrency effects (such as dirty reads or lost updates) users might encounter.

Different Types of Locks :

There are three primary types of locks that are used in a database.

Read Locks

These types of locks make it so that data can only be read. Depending on the database system and restrictions on the read lock, this can make it so only one user can read the data to allowing every user access to reading the data but not being able to modify anything. The read lock can be applied to a single row, a section of rows, or an entire table. This can also be dependent on the type of database system that is being used that could limit the amount of data that can be locked for reading.
Write Locks

This type of lock is used for updates in the database system. When this lock is applied it prevents any other transactions from changing the records that are being accessed. This does allow transactions to read the data before it is modified and the changes are made permanent.
Exclusive Write Locks

This type of lock is similar to a write lock. The only difference is that with an exclusive write lock, the only things that can look at the data or modify the data is the original transaction. No other transaction can read the data while this lock is applied.

There are also many other locks that signal intention to request another type of lock. These locks are called multi-level-locks. This is useful to show other transactions what types of locks the transaction has throughout the hierarchy of data levels.

Database Isolation Levels

Database isolation levels are used to define the degree to which one transaction must be isolated from the data modifications made by other concurrent transactions. Isolation levels prevent certain anomalies or side effects that can occur when transactions run concurrently, such as dirty reads, non-repeatable reads, and phantom reads.

The SQL standard defines four isolation levels: Read Uncommitted, Read Committed, Repeatable Read, and Serializable. However, different database systems may implement them differently or provide additional levels.

Read Uncommitted

It is the lowest isolation level. It allows a transaction to read uncommitted changes made by other transactions, which may lead to dirty reads. It does not provide any locking on the data being read or written.
Read Committed

It is a higher isolation level than Read Uncommitted. It guarantees that a transaction only reads data that has been committed by other transactions. It prevents dirty reads but not non-repeatable reads or phantom reads. It usually uses shared locks on the data being read and exclusive locks on the data being written.
Repeatable Read

It is a higher isolation level than Read Committed. It ensures that a transaction sees the same data when it reads the same row multiple times. It prevents dirty reads and non-repeatable reads but not phantom reads. It usually uses shared locks on all the rows read by the transaction and exclusive locks on the rows written by the transaction.
Serializable

It is the highest isolation level. It guarantees that a transaction sees a consistent snapshot of the database as if no other transactions were running concurrently. It prevents dirty reads, non-repeatable reads, and phantom reads. It usually uses range locks or predicate locks on the data accessed by the transaction.

Higher isolation levels provide more consistency but also more locking and less concurrency. Therefore, choosing an appropriate isolation level depends on the application requirements and trade-offs.

Triggers

A database trigger is a stored procedure that is automatically executed when a certain event occurs on a table or view in a database. For example, a trigger can be used to enforce data integrity, update another table, or audit changes.

Learning Process

Sagar Dutta — Fri, 12 May 2023 11:12:02 +0000

1. How to Learn Faster with the Feynman Technique

What is the Feynman Technique?

The Feynman Technique is named after Richard Feynman, a Nobel prize-winning physicist who was good at explaining things. It is a way of learning faster by pretending to teach someone else what you are learning. It involves explaining a topic in our own words as simple as possible. It has four steps: selection, research, writing, and refining. It helps us to understand and recall complex topics and simplify ideas. It forces us to actively think about the problem instead of passively reading. It also helps us to identify any gaps in our knowledge or understanding of a concept.

What are the different ways to implement this technique in your learning process?

We can use the Feynman Technique for any subject or topic that we want to learn. It can help us improve our comprehension, retention, and communication skills.

There are different ways to implement the Feynman Technique in your learning process, but they all follow the same basic steps:
- Choose a concept to learn.
  
  Pick a topic that you are interested in and want to understand better.
- Teach it to yourself or someone else
  
  Explain the concept in your own words as if you were teaching it to a child. Use simple language and examples.
- Identify knowledge gaps and return to the source material
  
  Review your explanation and see where you got stuck. Reffer the original sources to fill in the gaps in your understanding.
- Simplify explanation
  
  Try to make the explanation as clear and concise as possible.

2. Learning How to Learn TED talk by Barbara Oakley

Summary

How to Learn by Barbara Oakley teaches us powerful mental tools to help us master anything. She talks about four main topics: focused and diffuse modes of thinking, memory, procrastination and habits, and test-taking.
- Focused and diffuse modes are two different ways of thinking. Focused mode is when we concentrate on a specific problem or task, while diffuse mode is when we let our mind wander and make connections between different ideas. We need both modes to learn effectively, and we can switch between them by taking breaks or doing something relaxing or fun.
- We can improve our memory by using techniques such as spaced repetition, retrieval practice, interleaving, and elaboration. Spaced repetition is reviewing material at increasing intervals of time to strengthen our long-term memory. Retrieval practice is testing ourself on what we have learned to enhance our recall and comprehension. Interleaving is mixing up different topics or types of problems to improve our flexibility and transfer of skills. Elaboration is explaining what we have learned in our own words or to someone else, or asking ourself questions about the material to deepen our understanding.
- We can overcome procrastination by using strategies such as the Pomodoro technique, the 5-minute rule. The Pomodoro technique is breaking down our work into 25-minute sessions with 5-minute breaks in between.
- Test-taking and learning strategies are ways to optimize our performance. Some of these strategies are recalling (writing down what we remember), reviewing (going over the material again after recalling), self-explaining (verbalizing our thought process while solving problems) and self-testing (quizzing ourself on the material).

What are some of the steps that you can take to improve your learning process?

To apply these strategies to our own learning goals, we need to first identify what we want to learn and why. Then, we need to find the best resources and methods to learn that topic. We can use online courses, books, videos, podcasts, articles, or any other sources that suit our learning style and preferences. We also need to plan our time and schedule our learning sessions according to our availability and energy levels. We can use a calendar, a planner, a to-do list, or any other tool that helps us organize our tasks and deadlines. Finally, we need to monitor our progress and evaluate our results. We can use quizzes, tests, projects, portfolios, or any other assessments that measure our learning outcomes and feedback. We can also use self-reflection, peer review, or mentorship to improve our learning process and identify our strengths and weaknesses.

Here is an example on how we can apply these strategies to different learning goals:

If we want to learn how to code, we can use focused mode to learn the syntax and logic of a programming language, and diffuse mode to explore different applications and projects that use that language. We can chunk commands and functions into modules or classes, and use stories or examples to illustrate them. We can use spaced repetition and retrieval practice to recall the syntax rules and error messages. We can use self-explaining and self-testing to debug our code and check its output. We can use feedback and metacognition to optimize our code and enhance its functionality.

3. Learn Anything in 20 hours

Summary

Josh Kaufman challenges the popular notion that it takes 10,000 hours to master a new skill. He argues that we can learn the basics of any skill in just 20 hours of focused, deliberate practice. He outlines four-steps for rapid skill acquisition:
- Deconstruct the skill into the smallest possible subskills
  
  Decide exactly what you want to learn, and what you want to achieve when you are done. Then learn the most important and useful parts of the skill first.
- Learn enough to self-correct
  
  Learn enough about each subskill to be able to practice intelligently and self-correct during practice.
- Remove barriers to practice
  
  Remove distractions, physical, mental, and emotional barriers that can distract you from your practice. This means creating a conducive environment, setting clear goals and deadlines, and overcoming any fears or doubts that may hold you back.
- Practice
  
  This means dedicating enough time and effort to actually apply what you have learned and improve your performance.

What are some of the steps that you can while approaching a new topic?

Some of the steps that we can apply are:
- Break down the topic into smaller and simpler subtopics that we can learn one by one.
- Research the best sources and methods for learning each subtopic and avoid information overload or confusion.
- Set a clear and realistic goal for what we want to achieve by learning the topic and how much time we can devote to it.
- Eliminate any distractions or obstacles that may interfere with our learning process and motivation.
- Practice the most important and relevant aspects of the topic until we reach a satisfactory level of competence and confidence.
By following these steps, we can learn any new topic faster and more effectively.

Object Oriented Programming

Sagar Dutta — Thu, 11 May 2023 10:50:57 +0000

Introduction

OOPs stands for Object-Oriented Programming, which is a programming paradigm that uses objects and classes to represent real-world entities and their behaviors.

The main concept of OOPs is to bind the data and the functions that work on that together as a single unit so that no other part of the code can access this data.

Some of the major OOPs concepts are:

Class

A class is a blueprint or a prototype for creating objects. It defines the attributes and methods that an object can have. For example, a class named Parrot can have attributes like name, age, color and methods like fly, sing, etc.

# Class
class Parrot:
    # Class attribute
    species = "bird"

    # Instance attribute
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Instance method
    def sing(self, song):
        print(f"{self.name} sings {song}")

Object

An object is an instance of a class. It has a state (attributes) and a behavior (methods) associated with it. For example, an object named blu can be created from the Parrot class with specific values for its attributes and methods.

# Object
blu = Parrot("Blu", 10)
print(blu.species) # bird
print(blu.name) # Blu
print(blu.age) # 10
blu.sing("Happy") # Blu sings Happy

Inheritance

Inheritance is a way of creating a new class from an existing class without modifying it. The new class is called a derived class or a child class, and the existing class is called a base class or a parent class. The derived class inherits the attributes and methods of the base class and can also add its own features. For example, a class named Dog can inherit from a class named Animal and add its own method named bark.

# Inheritance
class Animal:
    def eat(self):
        print("I can eat")

    def sleep(self):
        print("I can sleep")

class Dog(Animal):
    def bark(self):
        print("I can bark")

dog1 = Dog()
dog1.eat() # I can eat
dog1.sleep() # I can sleep
dog1.bark() # I can bark

Polymorphism

Polymorphism means having many forms. In OOPs, it refers to the ability of an object to behave differently depending on the context. For example, a method named sound can have different implementations for different classes like Dog, Cat, Bird, etc. Polymorphism can be achieved by using method overriding (redefining a method in the derived class) or method overloading (defining multiple methods with the same name but different parameters).

# Polymorphism
class Bird:
    def sound(self):
        print("I make some sound")

class Duck(Bird):
    def sound(self): # Method overriding
        print("I quack")

class Owl(Bird):
    def sound(self): # Method overriding
        print("I hoot")

duck1 = Duck()
owl1 = Owl()
duck1.sound() # I quack
owl1.sound() # I hoot

Encapsulation

Encapsulation is the process of hiding the internal details of an object from the outside world. It prevents other classes from accessing and modifying the attributes and methods of a class. Encapsulation can be achieved by using private attributes (denoted by single _ or double __ prefix) and setter and getter methods (to access and modify private attributes). For example, a class named Computer can have a private attribute named __maxprice and a setter method named setMaxPrice to change its value.

Abstraction

Abstraction is the process of hiding the unnecessary details of an object and exposing only the essential features. It helps to reduce complexity and increase efficiency. Abstraction can be achieved by using abstract classes (classes that cannot be instantiated and have abstract methods that must be implemented by the derived classes) or interfaces (classes that only have abstract methods and constants). For example, an abstract class named Shape can have an abstract method named area that must be implemented by its subclasses like Circle, Square, Triangle, etc.

Some of the benefits of OOPs are:

Reusability

It means reusing some facilities rather than building them again and again. This is done with the use of classes and inheritance. We can use a class or a subclass ‘n’ number of times as per our need.
Data Redundancy

It is a condition where the same piece of data is held in two separate places. OOPs helps to prevent data redundancy by using classes and objects. If a user wants a similar functionality in multiple classes, he/she can write a common class definition for that functionality and inherit it.
Code Maintenance

This feature helps users to avoid re-work and save time. It is always easy and time-saving to maintain and modify the existing code by incorporating new changes into it. OOPs supports code maintenance by using encapsulation, polymorphism and abstraction mechanisms.
Security

With the use of data hiding and abstraction, we are filtering out limited data to exposure, which means we are maintaining security and providing necessary data to view. OOPs also helps to protect the data from unauthorized access by using private attributes and methods.
Design Benefits

OOPs forces the designers to have a long and extensive design phase, which results in better designs and fewer flaws. It also helps to reduce complexity and increase efficiency by using abstract classes and interfaces. OOPs makes it easier to program all the non-OOPs one separately.
Better Productivity

With the above-mentioned benefits, OOPs enhances the overall productivity of the users. It helps to develop faster, cheaper and quality software that meets the user requirements.

Some of the disadvantages of OOPs are:

Complexity

It can be challenging to design a program with an OOP concept. A program is developed in OOP if there is a plan for it. The programmer needs to have brilliant designing skill and programming skill along with proper planning. The thought process involved in OOP may not be natural for some people.
Size

The size of programs that have been developed with OOP is bigger than those that have a procedural approach. This is because OOP uses classes, objects, inheritance, polymorphism, etc. that add extra code and data to the program.
Execution time

Execution time for OOP programs is higher since they are bigger. They also involve more memory allocation and deallocation operations due to the use of objects. OOP programs may not be suitable for time-sensitive applications that require fast performance.
Applicability

OOP is not a universal language. It is applied only when it is required. It is not suitable for all types of problems. Some problems may be better solved by using other programming paradigms like functional, procedural, or logical programming.

Dictionary in Python and its methods

Sagar Dutta — Thu, 11 May 2023 09:56:34 +0000

A dictionary is a sequence of key-value pairs separated by commas and surrounded by curly braces.
To create a dictionary, we open up a curly brace and put the data in a key-value pair separated by commas.

The basic syntax of a dictionary looks like this:

demo_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

# Creating a Dictionary with dict() method
demo_dict = dict({"key1": "value1", "key2": "value2", "key3": "value3"})

# Creating a Dictionary with each item as a Pair
demo_dict = dict([("key1", "value1"), ("key2", "value2",)])

Adding elements to a Dictionary

Addition of elements can be done in multiple ways. One value at a time can be added to a Dictionary by defining value along with the key. While adding a value, if the key-value already exists, the value gets updated otherwise a new key with the value is added to the Dictionary.

demo_dict = {}
demo_dict["name"] = "Mike"
demo_dict["age"] = "54"
print(demo_dict) # {'name': 'Mike', 'age': '54'}

# Updating
demo_dict["age"] = "58"
print(demo_dict) # {'name': 'Mike', 'age': '58'}

# Adding multiple items
demo_dict={}
demo_dict['numbers'] = 2, 3, 4
print(demo_dict) # {'numbers': (2, 3, 4)}

Nested Dictionaries

Python lets us add a dictionary within another.

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
print(demo_dict) # {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}

Accessing an element

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
print(demo_dict["name"]) # John
print(demo_dict["props"]["phn"]) # 99999

Dictionary Methods

get()

Returns the value for the given key.

demo_dict={
    "name":"Jack",
    "age":"24"
}

print(demo_dict.get("age")) # 24

pop()

Returns and removes the element with the given key.

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
print(demo_dict.pop("name")) # John
print(demo_dict) # {'props': {'age': 34, 'phn': '99999'}}

popitem()

Returns and removes the last key-value pair from the dictionary

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
print(demo_dict.popitem()) # ('props', {'age': 34, 'phn': '99999'})
print(demo_dict) # {'name': 'John'}

copy()

Returns a shallow copy of the dictionary

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
test_dict=demo_dict.copy()
print(test_dict) # {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}

fromkeys()

Creates a dictionary from the given sequence
items()

Return the list with all dictionary keys with values

keys()

Returns a list containing dictionary’s keys.

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
print(demo_dict.keys()) # dict_keys(['name', 'props'])

values()

Returns a list of all the values available in a given dictionary.

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
print(demo_dict.values()) # dict_values(['John', {'age': 34, 'phn': '99999'}])

setdefault()

Returns the value of a key if the key is in the dictionary else inserts the key with a value to the dictionary

update()

Updates the dictionary with the elements from another dictionary

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
demo_dict.update({"name" : "Johnny"})
print(demo_dict) # {'name': 'Johnny', 'props': {'age': 34, 'phn': '99999'}}

del()

The del statement removes an element from the dictionary.

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
del demo_dict['name']
print(demo_dict)

sorted()

Returns a sorted list of keys.

demo_dict = {'6' : 'John', '3' : 'Mike', '5' : 'Jack'}
print(sorted(demo_dict)) # ['3', '5', '6']

clear()

Removes all items from the dictionary.

demo_dict = {'name': 'John', 'props': {'age': 34, 'phn': '99999'}}
demo_dict.clear()
print(demo_dict) # {}

References

String Methods in Python

Sagar Dutta — Thu, 11 May 2023 08:53:20 +0000

lower()

Converts all uppercase characters in a string into lowercase.

my_str="Hello World"
print(my_str.lower()) # hello world
print(my_str) # Hello World

islower()

Checks if all characters in the string are lowercase.

str = 'Hello World'
print(str.islower()) # False

str = 'hello world'
print(str.islower()) # True

casefold()

Returns a string where all the characters are lower case.
```
my_str="HeLLo World"
print(my_str.casefold()) # hello world
```

upper()

Converts all lowercase characters in a string into uppercase.

my_str="Hello World"
print(my_str.upper()) # HELLO WORLD
print(my_str) # Hello World

isupper()

Checks if all characters in the string are uppercase.

str = 'Hello World'
print(str.isupper()) # False

str = 'HELLO'
print(str.isupper()) # True

title()

Convert string to title case

my_str="hello world"
print(my_str.title()) # Hello World

istitle()

Returns “True” if the string is a title cased string.

str = 'Hello World'
print(str.istitle()) # True

str = 'hello world'
print(str.istitle()) # False

capitalize()

Convert the first character of a string to capital (uppercase) letter.
```
my_str="hello world"
print(my_str.capitalize()) # Hello world
```

swapcase()

Swap the cases of all characters in a string.

my_str="Hello World"
print(my_str.swapcase()) # hELLO wORLD

center()

Pad the string with the specified character upto specified length.

my_str="Hello World"
print(my_str.center(16,'a')) # aaHello Worldaaa
print(my_str.center(20,'a')) # aaaaHello Worldaaaaa

count()

Returns the number of occurrences of a substring in the string.

my_str="Hello World Hello Hello"
print(my_str.count("Hello")) # 3
print(my_str.count('l')) # 7

encode()

Encodes strings with the specified encoded scheme.
In case of failure, it raises a UnicodeDecodeError exception.
```
my_str="Hello World"
# change encoding to utf-8
print(my_str.encode()) # b'Hello World'
```
endswith()

Returns “True” if a string ends with the given suffix.
```
my_str="Hello World"
print(my_str.endswith("World")) # True
```

expandtabs()

Specifies the amount of space to be substituted with the “\t” symbol in the string. Default tabsize is 8.

str = 'Hello\tWorld'
print(str.expandtabs()) # Hello   World
print(str.expandtabs(20)) # Hello               World

find()

Returns the lowest index of the substring if it is found.

str = 'Hello World'
print(str.find("World")) # 6
print(str.find("Galaxy")) # -1

index()

Returns the position of the first occurrence of a substring in a string.
If substring doesn't exist inside the string, it raises a ValueError exception.
```
str = 'Hello World'
print(str.index("World")) # 6
```

format()

Formats the string for printing it to console.


name="Mike"

str = 'Hello {}!'
print(str.format(name)) # Hello Mike!

# We can also do it this way
str2= f"Hello {name}!"
print(str2) # Hello Mike!

format_map()

Formats specified values in a string using a dictionary.

coordinates = {'x':4,'y':-5, 'z': 0}
print('{x} {y} {z}'.format_map(coordinates)) # 4 -5 0

isalnum()

Checks whether all the characters in a given string is alphanumeric or not.

str = 'Hello World'
print(str.isalnum()) # False

str = 'HelloWorld'
print(str.isalnum()) # True

str = 'HelloWorld1100'
print(str.isalnum()) # True

isalpha()

Returns “True” if all characters in the string are alphabets.

str = 'Hello World'
print(str.isalpha()) # False

str = 'HelloWorld'
print(str.isalpha()) # True

str = 'HelloWorld1100'
print(str.isalpha()) # False

isnumeric()

Returns “True” if all characters in the string are numeric characters.

str = 'Hello World'
print(str.isnumeric()) # False

str = '12131'
print(str.isnumeric()) # True

isdecimal()

Returns true if all characters in a string are decimal.

str = 'Hello World'
print(str.isdecimal()) # False

str = '1234567'
print(str.isdecimal()) # True

str = '9866asdf3s'
print(str.isdecimal()) # False

isdigit()

Returns “True” if all characters in the string are digits.

str = '1234567'
print(str.isdigit()) # True

str = '9866asdf3s'
print(str.isdigit()) # False

isidentifier()

The isidentifier() method returns True if the string is a valid identifier in Python.

str = 'Hello World'
print(str.isidentifier()) # False

str = 'while'
print(str.isidentifier()) # True

str = 'Python'
print(str.isidentifier()) # True

isprintable()

Returns “True” if all characters in the string are printable or the string is empty.

str = 'Hello World'
print(str.isprintable()) # True

str = 'Hello World\n'
print(str.isprintable()) # False

isspace()

Returns “True” if all characters in the string are whitespace characters.

s = '   \t'
print(s.isspace()) # True

s = ' a '
print(s.isspace()) # False

s = ''
print(s.isspace()) # False

join()

The string join() method returns a string by joining all the elements of an iterable (list, string, tuple), separated by the given separator.

text = ['Python', 'is', 'a', 'fun', 'programming', 'language']
print(' '.join(text)) # Python is a fun programming language
print('_'.join(text)) # Python_is_a_fun_programming_language

ljust()

Left aligns the string according to the width specified
lstrip()

Returns the string with leading characters removed
maketrans()

Returns a translation table
partition()

Splits the string at the first occurrence of the separator
replace()

Replaces all occurrences of a substring with another substring
rfind()

Returns the highest index of the substring
rindex()

Returns the highest index of the substring inside the string
rjust()

Right aligns the string according to the width specified
rpartition()

Split the given string into three parts
rsplit()

Split the string from the right by the specified separator
rstrip()

Removes trailing characters
splitlines()

Split the lines at line boundaries
startswith()

Returns “True” if a string starts with the given prefix
strip()

Returns the string with both leading and trailing characters
translate()

Modify string according to given translation mappings
zfill()

Returns a copy of the string with ‘0’ characters padded to the left side of the string

Reference

Lists in Python and its methods

Sagar Dutta — Thu, 11 May 2023 06:51:49 +0000

Lists are mutable ordered and indexed collections of objects.
We can change, add, or remove items in a list after it has been created. Items can be of any data type, such as numbers, strings, or other objects.
Lists are formed by placing a comma-separated list of expressions in square brackets.

my_list = ["Hello", "World", 1, 2]

Accessing list items

We can access the items in a list by using their index values, which start from 0 for the first item. We can also use negative indexes to access the items from the end of the list.

For example:

print(my_list[0]) # prints "Hello"
print(my_list[-1]) # prints 2

Nested lists

We can also add lists within another list.

my_list = [ [0, 1, 3], ['a', 'b', 'c'], ['red', 'yellow', 'blue'] ]
print(new_list[2][1]) # prints yellow

Slicing of a List

Using slicing, we can print a specific range of elements from a list. The python list ‘Slice’ operation is used to print a specific range of elements; it is denoted by the ‘Colon (:)’. To print the elements from a specific range, use the start index tag (:index) to specify the last range element until which we want to specify (index:).

my_list = ['A', 'E', 'I', 'O', 'U']
print(my_list[1:4]) # prints ['E', 'I', 'O']

Looping through a list

We can loop through a list using the 'in' keyword:

my_list = ['red', 'blue', 'green', 'black']

for thing in my_list:
    print(thing)

List concatenation

We can join multiple lists using '+' operator:

a = [0, 1, 2, 3, 4]
b = [5, 6, 7, 8, 9]
c = a + b
print(c) # prints [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Multiple concatenation

We can return a sequence self-concatenated specified amount of times using '*' operator:

a = [0, 1]
b = a * 3
print(b) # prints [0, 1, 0, 1, 0, 1]

List Comprehension

A list comprehension consists of an expression followed by the for statement inside square brackets.

numbers = [n*n for n in range(1, 6)]
print(numbers) # prints [1, 4, 9, 16, 25]

Using Lists as Stacks

The list methods make it very easy to use a list as a stack, where the last element added is the first element retrieved (“last-in, first-out”). To add an item to the top of the stack, use append(). To retrieve an item from the top of the stack, use pop() without an explicit index. For example:

stack = [3, 4, 5]
stack.append(6)
stack.append(7)
print(stack) # prints [3, 4, 5, 6, 7]

stack.pop() # 7
stack.pop() # 6
stack.pop() # 5
print(stack) # prints[3, 4]

List methods

len(list)

It gives the overall length of the list.

my_list = ['A', 'E', 'I', 'O', 'U']
print(len(my_list)) # prints 5

append()

Adds one element to the end of the list.

my_list = ['A', 'E', 'I', 'O']
my_list.append('U')
print(my_list) # prints ['A', 'E', 'I', 'O', 'U']

insert()

Adds a component at the required position.

my_list = ['A', 'E', 'I', 'O']
my_list.insert(2,'U')
print(my_list) # prints ['A', 'E', 'U', 'I', 'O']

extend()

Adds multiple elements to a list from another list.

a=[1,2]
b=[3,4]
a.extend(b)
print(a) # prints [1, 2, 3, 4]

pop()

Removes the element at the required position.

my_list = ['A', 'E', 'I', 'O', 'U']
my_list.pop(2)
print(my_list) # prints ['A', 'E', 'O', 'U']

Without any argument passed, it will remove element from the end of the list

my_list = ['A', 'E', 'I', 'O', 'U']
my_list.pop()
print(my_list) # prints ['A', 'E', 'I', 'O']

remove()

Remove the first item from the list whose value is equal to given argument.
It raises a ValueError if there is no such item.
```
my_list = ['A', 'E', 'I', 'O', 'U']
my_list.remove('I')
print(my_list) # prints ['A', 'E', 'O', 'U']
```

del()

We can also use the del statement to remove one or more items from a list.

a = [3, 2, 3, 8, 3, 4, 5, 6, 1, 2]

del a[1] # deleting the second item
print(a) # prints [3, 3, 8, 3, 4, 5, 6, 1, 2]

del a[-1] # deleting the last item
print(a) # [3, 3, 8, 3, 4, 5, 6, 1]

del a[0 : 2] # delete first two items
print(a) # prints # [8, 3, 4, 5, 6, 1]

sort()

Sorts the list in ascending order.

my_list = [8, 1, 5, 3, 7]
my_list.sort()
print(my_list) # prints [1, 3, 5, 7, 8]

To sort descending order:

my_list = [8, 1, 5, 3, 7]
my_list.sort(reverse = True)
print(my_list) # prints [8, 7, 5, 3, 1]

reverse()

Reverses the order of the list.

my_list = ['A', 'E', 'I', 'O', 'U']
my_list.reverse()
print(my_list) # prints ['U', 'O', 'I', 'E', 'A']

index()

Returns the first appearance of a particular value.
It raises a ValueError if there is no such item.
```
my_list = ['A', 'E', 'I', 'O', 'U']
print(my_list.index('O')) # prints 3
```

count()

Returns the number of elements with the required value.

my_list = [3, 4, 4, 1, 2, 3, 8, 3]
print(my_list.count(4)) # prints 2
print(my_list.count(3)) # prints 3

max(list)

It returns an item from the list with a max value.
```
a = [3, 2, 3, 8, 3]
print(max(a)) # prints 8
```
min(list)

It returns an item from the list with a min value.
```
a = [3, 2, 3, 8, 3]
print(min(a)) # prints 2
```

copy()

Returns a duplicate (Shallow Copy) of the list.

a = [3, 2, 3, 8, 3]
b=a.copy()
print(b) # print [3, 2, 3, 8, 3]

We can also copy (Deep Copy) using '=':

a = [3, 2, 3, 8, 3]
b=a
print(b) # prints [3, 2, 3, 8, 3]
a.pop()
print(b) # prints [3, 2, 3, 8]

clear()

Removes all the elements from the list.

a = [3, 2, 3, 8, 3]
a.clear()
print(a) # prints []

DEV Community: Sagar Dutta

Django Concepts

What is secret key?

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

What is middleware? What are different kinds of middleware?

CSRF

XSS

Click Jacking

What is WSGI?

What is ondelete Cascade?

Model Field

Validators

Understanding the difference between Python module and Python class?

Using ORM queries in Django Shell

Turning ORM to SQL in Django Shell

What are Aggregations?

What are Annotations?

What is a migration file? Why is it needed?

What are SQL transactions? (non ORM concept)

What are atomic transactions?

References

Grit and Growth Mindset

Grit

Paraphrase

Key takeaways

Growth Mindset

Paraphrase

Key takeaways

Internal Locus of Control

What is the Internal Locus of Control?

What is the key point in the video?

Build a Growth Mindset

Paraphrase

Key takeaways

Important JavaScript Concepts

Loops

for

forEach

for .. in

for .. of

while

Mutable and Immutable Methods (in strings and arrays)

Pass by Reference and Pass by Value

Array methods

Basics:

Finding:

Higher Order Functions:

Advanced:

String methods

Object methods and operations

Hoisting

Scopes

Closures

Higher Order Functions

Reference

HTML/CSS Concepts

Box Model

Inline versus Block Elements. Examples.

Positioning: Relative/Absolute

Common CSS structural classes

CSS Specificity

CSS Responsive Queries

Flexbox

Common Flex Container Properties

Common Flex Item Properties

Flexbox Examples

Grid

Common Grid Container Properties

Common Grid Item Properties

Common header meta tags

Common header meta tags and their purposes:

References

7 Layers of the OSI Model

1. Physical Layer

2. Data Link Layer

3. Network Layer

4. Transport Layer

5. Session Layer

6. Presentation Layer

7. Application Layer

Understanding the difference between `Python module` and `Python class`?