DEV Community: Saravanan

Django

Saravanan — Tue, 04 Apr 2023 10:34:03 +0000

Secret key

In Django, the secret key is a string of random characters used for cryptographic signing and protection against attacks such as session hijacking, cross-site request forgery, and other malicious activities.

In a new Django project, a secret key is automatically generated and stored in the settings.py file. The key is secret and it should not be shared with others, as anyone with access to it could potentially impersonate site users or modify data on the site.

A new secret key can be generated using django-secret-key or any other application.

It can be saved as an environment variable to prevent it from getting uploaded from the settings file through VCS. Cloud-specific tools can also be used to save it. Using separate settings files for development and production can also be done.

Default Django apps

There are more apps than the default Django apps given in settings. They can be found in src. They are

django.contrib.admin: Provides a web administrative interface for managing the Django project's data.
django.contrib.auth: Provides user authentication and authorization mechanisms.
django.contrib.contenttypes: Provides a framework for associating metadata with models.
django.contrib.sessions: Provides session management functionality.
django.contrib.messages: Provides a way to display one-time messages to users.
django.contrib.staticfiles: Provides a framework for managing static files.
django.contrib.humanize: Provides a set of template filters for humanizing data.
django.contrib.redirects: Provides a way to redirect URLs.
django.contrib.sitemaps: Provides a framework for generating sitemaps.
django.contrib.sites: Provides a way to manage multiple sites using a single Django installation.
django.contrib.admindocs: Provides a way to automatically generate documentation for the project's models.
django.contrib.postgres: Provides support for PostgreSQL-specific functionality.
django.contrib.gis: Provides support for geographic data.
django.contrib.syndication: Provides a framework for generating RSS and Atom feeds.
django.contrib.webdesign: Provides a set of template tags for generating dummy data.

Middleware and different kinds of middleware

Middleware in Django is a component that sits between the web server and the view and provides a way to process requests and responses in a modular way.

Process Request Middleware: This middleware is executed at the beginning of the request cycle and can be used to perform tasks such as authentication, setting up the request, or modifying the request object.
View Middleware: This middleware is executed just before the view function is called and can be used to modify the view's context or perform additional processing on the request.
Template Middleware: This middleware is executed during the rendering of the template and can be used to add additional variables or processing to the template context.
Process Response Middleware: This middleware is executed at the end of the request cycle and can be used to modify the response object or perform any final processing before the response is sent back to the client.

CSRF

CSRF attacks let anyone use another person's website account without their permission. Django can stop this attack with its built-in protection. Django checks for a secret code in each form submission, so anyone needs to know the secret code to trick the website. This secret code is user-specific and stored in cookies. When using HTTPS, Django checks that the form is coming from the same place as the website. Using HTTPS helps make things more secure. The csrf_exempt decorator must be used only when it is necessary.

XSS

XSS attacks are when someone injects harmful scripts into a website that can affect other people's browsers. Django templates can help stop these attacks. Django templates can protect against certain dangerous characters, but not all.

ClickJacking

Clickjacking is when a bad website puts another website inside a frame, tricking people into doing things they didn't mean to do. Django has a way to protect against this called X-Frame-Options middleware, which can stop a website from being shown inside a frame in some browsers.

WSGI

WSGI stands for Web Server Gateway Interface. It is a specification that defines how a web server communicates with a Python web application.

In Django, WSGI is used to allow a web server to interact with a Django application. It acts as a bridge between the two, allowing the webserver to send requests to the Django application and receive responses. The WSGI specification provides a standard interface for web servers and Python web applications to communicate with each other.

Models

ondelete

on_delete is a parameter that can be used when defining a foreign key relationship in Django models. It specifies what should happen when the referenced object is deleted.

on_delete=CASCADE is one of the options available for the on_delete parameter. It specifies that when the referenced object is deleted, all objects that have a foreign key relationship to it should also be deleted.

Fields and Validators

A model field represents a database column and defines the type of data that can be stored in that column. Validators are functions that validate the data entered into a field according to some predefined rules.

Module and Class

A module is a file containing Python code that can be imported and used in other Python files or modules. A module can contain functions, variables, classes, and other objects. A class is a blueprint for creating objects that define a set of properties and methods that the objects will have.

Django ORM in shell

Django's Object-Relational Mapping (ORM) provides functionality to interact with a database using Python code instead of SQL queries. To use it in the shell import the model in the shell and use ORM functions on it.

ORM to SQL in Django shell

The ORM can be converted into SQL using .query from the queryset.

queryset = random_name.objects.filter(random_val=10)
print(queryset.query)

Aggregation and Annotation

Aggregate calculates values for the entire queryset. Annotate calculates summary values for each item in the queryset. Aggregate are functions such as Sum(), Avg() etc.

Migration file

A migration file is a script of instructions to modify the database schema. It is changed when a model is changed. It is needed to maintain schema in alignment with the models. makemigrations is used to generate the migration file and migrate is used to apply the changes to the database.

SQL Transactions

SQL transactions are a way of grouping together a set of database operations so that they can be executed as a single atomic unit. A transaction allows the performing of multiple database operations as a single, consistent unit, either all succeeding or no change. It prevents incomplete execution of queries.

Atomic transaction

Atomic transactions are used in Django to ensure all is completed or no change. It is the same as an SQL transaction. It is then done using SQL transactions depending upon the database used.

Revision 15-03-2023

Saravanan — Wed, 15 Mar 2023 07:48:31 +0000

1. How can you copy objects in JS?

There are three ways to copy an object in JS. They are

using spread syntax.
using Object.asssign() method.
using JSON.stringify() and JSON.parse() methods.

Example:

const person = {
    firstName: 'John',
    lastName: 'Doe'
};

// using spread ...
let p1 = {
    ...person
};

// using  Object.assign() method
let p2 = Object.assign({}, person);

// using JSON
let p3 = JSON.parse(JSON.stringify(person));

2. What is the difference between a named function and an anonymous function in JS?

A named function is a function declaration and an anonymous function is a function expression. The named function is hoisted but, anonymous functions are not. Anonymous functions are mostly used as a callback functions. Named function uses function keyword and anonymous function uses arrow syntax.

function my_function() {
    console.log("named function");
}

my_function(); // logs "named function"

(() => {
    console.log("anonymous function");
})(); // logs "anonymous function"

3. How to check if a string contains a substring in JS?

String.prototype.includes function returns a boolean value true if the substring is present.
String.prototype.indexOf function returns -1 if the substring is not present and a positive index value if present.

console.log("abcdefgh".includes("gh")); // logs true
console.log("abcdefgh".indexOf("zz")); // logs -1

4. What is the difference between indexOf() and lastIndex() methods in JS?

The indexOf() method returns the index within the calling String object of the first occurrence of the specified value, The lastIndexOf() method returns the index within the calling String object of the last occurrence of the specified value.

5. Is JS static or dynamically typed language?

JS is a dynamically typed language.

6. How can you iterate over elements of an array without using for and while loop in JS?

Using Array.prototype.forEach function helps to iterate over an array without using the traditional for and while loop.

[1, 2, 3, 4, 5].forEach((val) => {
    console.log(val);
}); // logs 1 2 3 4 5 in a newline.

7. What is a Cartesian product in SQL?

In SQL cartesian product is cross-join which gives the cross product of two tables.

SELECT *
FROM COLOR
CROSS JOIN SIZE;

COLOR
RED
BLUE

SIZE
LARGE
MEDIUM
SMALL

COLOR	SIZE
RED	SMALL
RED	MEDIUM
RED	LARGE
BLUE	SMALL
BLUE	MEDIUM
BLUE	LARGE

8. In which array methods can we use negative indexes and how can we use them?

JS does not support a negative index to access the item directly. The way to access the item using a negative index is Array.prototype.at method. All the array function which has an index as a parameter also accepts a negative index.

console.log([1, 2, 3, 4][-1]); // logs undefined
console.log([1, 2, 3, 4].at(-1)) // logs 4

9. What is destructuring in JS?

Destructuring is a feature introduced in ECMAScript 6 (ES6) that allows you to extract values from arrays or properties from objects and bind them to variables in a concise and readable way.

const obj = { a: 1, b: 2 };
const { a, b } = obj; // a is 1 and b is 2

10. What is the expected output when giving 'None' as a parameter while using the filter function on a list in Python?

When None is passed as a parameter to the filter() function it returns an iterator that filters out 'falsy' values such as empty list, string numerical zero, etc, or having the length as 0.

my_vals = [1, False, "", {}, 0, "word"]
my_vals = filter(my_vals) # my_vals is [1, "word"]

11. What is the actual use case of JSON.stringify() and JSON.parse()?

It helps to store objects in localStorage and sessionStorage.
Used while making API requests.
Store objects in a flat file.

HTML/CSS concepts

Saravanan — Thu, 02 Mar 2023 06:51:03 +0000

Box model

In HTML and CSS, the box model specifies how elements are presented on a webpage. It consists of four components: content, padding, border, and margin.

Content: refers to the text, images, or other media contained within the element.
Padding: the space between the content and the border.
Border: the visual boundary for the element.
Margin: the area outside the border, which separates the element from other neighboring elements on the page.

Example:

<div style="padding: 10px; border: 2px solid black; margin: 20px;">
    Text content.
</div>

In the above example, the div element has 10 pixels of padding, a 2-pixel black solid border, and 20 pixels of margin. The text "Text content." is the actual content of the element.

The default box model is content-box. In this model, the size of the element is determined by its content, and any padding, border, or margin is added to the outside of the element. The border-box is a model where the size of the element includes the padding and border, but not the margin. It means that the content area will be smaller than in the content-box model, but the overall size of the element will be the same.

Example:

<div style="box-sizing: border-box; width: 100px; padding: 10px; border: 1px solid black; margin: 10px;">
    Text content.
</div>

In the above example, for the div element border-box mode is specified using the box-sizing property with a width of 100 pixels. The content area will be 78 pixels wide because 10 pixels of padding and 1 pixel of the border are added to each side. However, the overall width of the element will be 120 pixels, because the margin is added to the outside of the element.

Inline vs Block elements

In HTML, elements can be classified as either inline or block-level. Block-level elements are those that take up the full width of their container and are separated from other elements by a line break. Inline elements are those that are part of a line of text and are surrounded by other inline elements or text.

Examples of block-level elements include div, p, and h1 to h6, while examples of inline elements include span, a, and img.

Example:

<div style="display: inline-block; border: 1px solid black;">
    block-level element inside an inline element.
</div>

In the above example, we have a div element with an inline-block display style. This means that the element will be displayed inline, but will also behave like a block-level element in terms of width and height.

Relative vs Absolute positioning

In CSS, positioning helps to control the layout of elements on a webpage. Two commonly used types of positioning are relative and absolute positioning. It can be set by giving the property position values relative and absolute.

Relative positioning allows an element to be moved relative to its normal position in the document flow. When an element is relatively positioned, it can be moved using the top, right, bottom, and left properties. These properties define the distance by how much the element is moved from its original position in the corresponding direction. For example, setting top: 10px will move the element 10 pixels down from its original position.

Absolute positioning allows an element to be placed in a specific location on the webpage, regardless of its position in the document flow. When an element is absolutely positioned, it is positioned relative to its closest-positioned ancestor. If no ancestor is positioned, the element is positioned relative to the initial containing block, which is the body element. An absolutely positioned element can be moved using the top, right, bottom, and left properties.

The difference between relative and absolute positioning is that absolutely positioned elements are taken out of the normal document flow, while relatively positioned elements remain in the flow. This means that absolutely positioned elements can overlap other elements, while relatively positioned elements cannot. The position of an absolutely positioned element does not affect the position of other elements on the page, while the position of a relatively positioned element can affect the position of other elements.

CSS Structural Classes

:first-child Selects the first child element from the parent.
:last-child Selects the last child element from the parent.
:nth-child(n) Selects the nth child element from the parent.
:nth-last-child(n) Selects the nth child element from the end of the parent.
:first-of-type Selects the first element of its type in the parent.
:last-of-type Selects the last element of its type in the parent.
:nth-of-type(n) Selects the nth element of its type in the parent.
:nth-last-of-type(n) Selects the nth element of its type from the end of the parent.
:only-child Selects an element that is the only child of the parent.
:only-of-type Selects an element that is the only element of its type within the parent.
:empty Selects an element that has no child elements or text content.
:root Selects the root element which is normally HTML.

Common CSS Styling Classes

In CSS, a styling class is a way to apply a specific set of styles to one or more elements on a webpage.

.container This class is used to create a container element that holds the content of a webpage. The container can be styled with a fixed or fluid width and can be centered on the page using margin or padding depending upon the content.
.button This class is used to create buttons on a webpage. Buttons can be styled with background colors, borders, and hover effects to make them stand out and provide visual feedback.
.navbar This class is used to create a navigation bar at the top of a webpage. The navbar can be styled with background colors, borders, and dropdown menus to provide easy access to different sections of the site.
.card This class is used to create a container element that displays information in a card-like format. Cards can be styled with borders, background colors, and shadows to create a visually appealing layout.
.form This class is used to create input forms on a webpage. Forms can be styled with input fields, labels, buttons, and validation messages.
.header This class is used to style the header section of a webpage. Headers can be styled with background images, logos, and navigation links.
.footer This class is used to style the footer section of a webpage. Footers can be styled with copyright information, contact links, and social media icons.

Styling classes help to maintain the same look throughout the website and easier to manage changes to the style of the website.

CSS Specificity

In CSS, specificity is a way of determining which styles should be applied to an element when there are conflicting styles. Each CSS selector has a specificity value, which is based on the number of ID, class, and element selectors used in the selector.

ID selectors have the highest specificity value and are calculated as 1-0-0. For example, #my-id has a specificity value of 1-0-0.
Class and attribute selectors have the next highest specificity value, and are calculated as 0-1-0. For example, .my-class or [type="text"] has a specificity value of 0-1-0.
Element selectors have the lowest specificity value and are calculated as 0-0-1. For example, p or div has a specificity value of 0-0-1.
When multiple selectors are used in a single selector, the specificity value is calculated by adding up the values for each selector. For example, the selector #my-id .my-class would have a specificity value of 1-1-0, because it contains one ID selector and one class selector.
If two selectors have the same specificity value, the one that appears later in the CSS code will be applied.

CSS responsive queries

CSS responsive queries, also known as media queries, are used to adjust the presentation of a webpage based on the characteristics of the device that it is being viewed on. This allows webpages that are optimized for different screen sizes, orientations, and device types.

Example:

@media only screen and (max-width: 600px) {
  body {
    font-size: 14px;
  }
}

In the above example, a media query is used to adjust the font size of the body element on devices with a screen width of 600 pixels or less. When the device's screen width is greater than 600 pixels, the default font size will be used. Media queries are used to create webpages that are flexible and adaptable to different screen sizes.

Flexbox and Grid

Flexbox and Grid are layout tools in CSS that allows the creation of flexible and responsive layouts for web pages. Both of them can be used depending on the situation.

Flexbox

Flexbox is a layout module in CSS that helps to arrange elements within a container. To use Flexbox, we first define a container element with the display: flex property. This creates a flex container, and all child elements of the container become flex items. Some of the key properties of Flexbox are:

flex-direction: Determines the direction of the main axis of the Flexbox. It can be set to row, row-reverse, column, or column-reverse.
justify-content: Determines how flex items are distributed along the main axis of the Flexbox. It can be set to flex-start, flex-end, center, space-between, space-around, or space-evenly.
align-items: Determines how flex items are aligned along the cross-axis of the Flexbox. It can be set to flex-start, flex-end, center, baseline, or stretch.
flex-wrap: Determines whether flex items should wrap onto multiple lines if they cannot fit within the Flexbox. It can be set to nowrap, wrap, or wrap-reverse.

Grid

CSS Grid is a layout system that provides a two-dimensional grid-based layout for the placement and sizing of elements. To use Grid, we first define a container element with the display: grid property. This creates a grid container, and child elements of the container become grid items. Some of the key properties of Grid are:

grid-template-columns and grid-template-rows: To define the columns and rows of the grid respectively. We can specify the size and position of each column and row using % fr px etc, as well as keywords like auto and minmax.
grid-template-areas: It is to define named areas within the grid, which we can be assigned to specific grid items using the grid-area property.
grid-gap: It is to add spacing between grid items horizontally and vertically.
grid-auto-columns and grid-auto-rows: It helps determine the size of grid tracks that are not explicitly defined by the grid-template-columns or grid-template-rows properties.

Common meta tags in the header

<meta charset="utf-8">: Specifies the character encoding of the document. "utf-8" is the common character encoding.
<meta name="viewport" content="width=device-width, initial-scale=1.0">: Sets the viewport width to the device width and specifies the initial zoom level when the page is first loaded.
<meta name="description" content="description of the page">: It is to mention a brief description of the page content. It is used by search engines to display site descriptions in search results.
<meta name="keywords" content="comma-separated list of keywords">: It specifies a list of keywords related to the page content. It is used in SEO and to help index the page.
<meta name="author" content="name of the author">: It specifies the author of the page.
<meta name="robots" content="index">: It specifies whether search engines should index the links on the page or not.
<meta name="theme-color" content="black">: It specifies the theme color of the page. It is used to customize the browser UI.

Passing by Assignment, References, Shallow and Deep Copy - Python

Saravanan — Mon, 27 Feb 2023 12:39:12 +0000

Passing by Assignment

In Python, the concept of pass-by-value and pass-by-reference in functions does not exist. Instead, Python implements pass by assignment. This means that neither the values nor the names associated with them are transferred. Rather, every value is associated with the parameter through an assignment.

def find_lowest(numbers):
    numbers.sort()
    return numbers[0]

nums = [3, 7, 2, 4, 0, 9]
print(nums) # prints [3, 7, 2, 4, 0, 9]
print(find_lowest(nums)) # prints 0
print(nums) # prints [0, 2, 3, 4, 7, 9]

References

In lists and collections, each item is a reference. Similar to how a name is associated with a value, items within collections are associated with values through references. This association is known as reference binding.

Let us look at the references with an example and how it works.

# tic-tac-toe board matrix
board = [["-"] * 3] * 3
for i in board:
    print(*i) # prints 3 X 3 matrix with hyphen.

# make an X mark in the center 
board[1][1] = "X"
for i in board:
    print(*i)

#Above print prints the below
# - X -
# - X -
# - X -

In the above code the default expectation is to change only the index [1][1] to "X" but, all the rows with index 1 become "X". This is because all three lists are aliases for a single list. To get the normally expected tic-tac-toe board where every list is not aliased below list comprehension can be used.

board = [["-"] * 3 for _ in range(3)]

When the value of any index is changed in the board, it does not affect other values as in the previous example.

Shallow copy and Deep copy

A shallow copy creates a new object and copies the references to the original object's elements. It means that if the original object contains mutable objects, both the original and the copied objects will refer to the same mutable objects in memory.

A deep copy creates a new object and recursively copies the contents of the original object and all of its nested objects. In other words, a deep copy creates a new copy of the objects within the original object.

# shallow copy

original_list = [1, 2, [3, 4]]
new_list = list(original_list)
new_list[2].append(5)
print(original_list)  # prints [1, 2, [3, 4, 5]]
print(new_list)       # prints [1, 2, [3, 4, 5]]

# deep copy

original_list = [1, 2, [3, 4]]
new_list = copy.deepcopy(original_list)
new_list[2].append(5)
print(original_list)  # prints [1, 2, [3, 4]]
print(new_list)       # prints [1, 2, [3, 4, 5]]

Copying is the most common way to solve the problem of passing around mutable objects in python in functions. Using id to check if the values have been modified does not work in python as shown below example.

a = [1, 2, 3]
b = [4, 5, 6]
c = (a, b)
print(id(c)) # prints id of tuple c
a.append(0)
print(c) # prints ([1, 2, 3, 0], [4, 5, 6])
print(id(c))# prints the same id as before for c as c has only reference of a and b as its value.

SQL Concepts

Saravanan — Wed, 22 Feb 2023 06:41:57 +0000

SQL(Structured Query Language) is a domain-specific language that is used for managing data in a relational database. We will look at some of the concepts of SQL in detail below.

ACID

ACID¹ - Atomicity, Consistency, Isolation, and Durability.

Atomicity

Atomicity guarantees that a transaction, which consists of one or multiple SQL statements, is either entirely executed or not executed at all. A transaction can be committed, making all its changes permanent, or rolled back, undoing all of its changes. As a result, the database has only two states - one before the transaction is executed and one after it is completed - with no intermediate states.

Consistency

Consistency ensures that the database is in a uniform state both before and after the execution of a transaction. This encompasses all rules, constraints, and triggers, and any deviations from this state of uniformity will result in the transaction being aborted.

Isolation

In situations where multiple transactions are executed simultaneously in parallel, the final state of the database must be identical to the state that would result from sequentially executing those transactions.

Durability

Durability ensures that the modifications made to the database persist once a transaction is committed. Such changes should only result from SQL transactions, and external factors should not impact them.

CAP Theorem

Eric Brewer proposed the CAP theorem², which states that any distributed data store can provide only two out of the three following properties: consistency, availability, and partition tolerance.

Consistency - At any given moment, all users view identical data, and any alterations made are instantaneously reflected everywhere.
Availability - The database responds to every request, regardless of whether or not the response is consistent.
Partition tolerance - A partition occurs when one or more nodes of a database become unavailable. Partition tolerance refers to the system's ability to continue functioning despite such partitions.

When a node fails, the system must choose whether to prioritize consistency or availability. If consistency is prioritized, transactions are rolled back to synchronize the non-failed nodes with the failed ones. On the other hand, if availability is prioritized, transactions proceed, but the nodes may become inconsistent.

Joins

A join is a keyword in SQL that joins two or more tables to form a single table based upon a condition on matching fields. Five common types of joins are used.

JOIN/INNER JOIN - returns rows from both tables where matching values are found in the joined columns of both tables.
LEFT JOIN - returns every row from the left table. When a row is found with a matching value in the right table, values from that row are included in the results.
RIGHT JOIN - returns every row from the right table. When a row is found with a matching value in the left table, values from that row are included in the results.
FULL OUTER JOIN - returns every row from both tables and joins the rows where values in the joined columns match. If there's no match for a value in either the left or right table, the query result contains no values for that table.
CROSS JOIN - return every possible combination of rows from both tables.

Aggregations

Aggregate functions combine values from multiple rows, perform an operation on those values, and return a single result. Some of the commonly used aggregate functions are given below.

count - returns a count of the column with values that are not null. To count all rows with null values use * instead of a column name.
max - returns the maximum value of a given column.
min - returns the minimum value of a given column.
sum - returns the sum value of a given column.
avg - returns the average of the given numeric column.

Aggregate functions are often used with GROUP BY to group the result by one or more columns. The aggregate function works on the set of values based on group by and not by the whole column.

Filter in queries

Filtering the result based on any condition is done using the WHERE clause in SQL. The filtering is done by comparison and matching of values from selected data.

= equal to(case sensitive)
!= not equal to(case sensitive)
/> greater than
< lesser than
/>= greater than or equal to
<= lesser than or equal to
~ matches with a regular expression
BETWEEN - passes value only within the range
IN - if the column value in the given set
LIKE - match the column value with the pattern
ILIKE - same as LIKE with case insensitive match
NOT - prefix to a match to negate it

Data normalization³

Normalization involves organizing data in a database to increase its flexibility by removing redundancy and inconsistent dependency. There are several forms of normalization, but databases are typically designed up to the third normal form, despite the existence of higher levels of normalization.

First normal form
- Eliminate repeating groups in individual tables.
- Create a separate table for each set of related data.
- Identify each set of related data with a primary key.
Second normal form
- Create separate tables for sets of values that apply to multiple records.
- Relate these tables with a foreign key.
Third normal form
- Eliminate fields that do not depend on the key.

Indexes⁴

An index is a data structure that provides search results fast for a particular column in a database. Generating an index on a table's field produces another data structure that holds the field's value and a pointer to its corresponding record. This index structure is then sorted, enabling Binary Searches to be conducted on it.

The data of the database are stored as data blocks. These data blocks are accessed entirely, making them the atomic disk access operation. Sorting these data blocks helps the database to access the data using binary search, which has a significant performance improvement over searching for the data in unsorted and randomly places data blocks.

Transactions

A transaction in a database consists of a sequence of data manipulation statements that must execute either completely or not at all, resulting in the database being in a consistent state. The main purpose of a transaction is to group several steps into a single, all-or-nothing operation. The intermediate states of a transaction are not observable by other concurrent transactions, and if an error prevents the transaction from completing, none of its steps will affect the database. Transactions are designed to support the ACID principles and provide concurrent access to multiple users and systems that are resistant to failures.

Locking mechanism⁵

Locking enables concurrent access to a database by multiple users. To access a data item for reading or writing, a lock is placed on it. A user requests a lock on the part of the data they need to access, and no conflicting lock is granted on the same data until the current lock is released. Two types of locks are shared and exclusive.

A shared lock allows reading from the locked row or table, hence also called a read lock. Multiple transactions can hold a shared lock on the same resource and read from it. However, no transaction is permitted to update the resource while a shared lock is held on it.

An exclusive lock completely locks the row or table and enables the transaction to update the row in isolation. Only one transaction can obtain an exclusive lock on a particular resource at a time. Other processes that wish to acquire the lock on the same resource must wait until the lock is released. Once released, the remaining processes can acquire the lock and make modifications.

Database isolation⁶

The level of isolation in a database determines how much a transaction should be separated from the data changes made by other transactions. It is to avoid the retrieval or storage of temporary, aborted, or inconsistent data written by simultaneous transactions. There are four various levels of database isolation.

Read Uncommitted - no transaction can update a database row if another transaction has already updated it and not committed but, allows dirty reads.
Read Committed - does not allow any other transaction to write or read a row to which another transaction has written but not yet committed.
Repeatable Read - a transaction that reads data from a row blocks any other writing transactions from accessing the same row.
Serializable - locks the whole table to prevent any other transactions from inserting or reading data from it.
Snapshot - transaction for modifying data works on a copy of committed data with a lock. Parallel read transactions are given the snapshot of the committed data.

Triggers

A trigger is a special type of stored procedure that automatically runs when an event occurs in the database such as INSERT, UPDATE, DELETE, and TRUNCATE.

CREATE TRIGGER my_trigger
BEFORE INSERT ON my_table
FOR EACH ROW
EXECUTE FUNCTION my_function();

The above example is to create a trigger in postgres named my_trigger which gets executes my_function for every insert in the my_table.

SOLID concepts

Saravanan — Mon, 20 Feb 2023 07:12:32 +0000

The SOLID principles¹ are principles that help in designing the structure of a program that uses object-oriented programming. SOLID principles are a subset of principles of Object-oriented design by Robert C. Martin². SOLID is an acronym for the following

S - Single Responsibility Principle
O - Open-Closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

Why SOLID and other software design principles?

When software reaches its first release it is clean and elegant. The issue arises when there is any change in requirements and that change causes the software to not be clean and elegant which then results in redesign after a few releases down the road. Robert C. Martin calls this software rot and there are 4 symptoms of rotting. They are:

Rigidity - The software becomes too hard to implement changes. Each change causes cascading changes.
Fragility - When a part of the software is changed, another part breaks which has no relation.
Immobility - When it's too hard to reuse part of software leading to rewriting it again.
Viscosity(design) - When multiple ways are present to implement change, the design preserving change being the hard one to implement.
Viscosity(environment) - The implementation of change is slow and inefficient.

SOLID principles are some of the principles that will help design better software from start.

Single Responsibility Principle³

The Single Responsibility Principle states that each software module should have one and only one reason to change. The 'only one reason to change' means that whenever there is a change request from a person/department/team on software when done should result in a new version of the software with a change in only one particular part of the software. No change request from another person/department/team should result in changes in the same part of the software.

It essentially means that software should be separated into different classes or modules depending upon from which stakeholder the request arises, therefore meaning that the class or module has a single responsibility.

Example:

class Employee():
    def calculate_pay():
        pass
    def save():
        pass
    def report_hours():
        pass

For this example, consider an organization with CFO, CTO, and COO at the top. Here the calculate_pay method is allocated to CFO, the report_hours method is allocated to the COO, save method which saves all data would be allocated to CTO inside the Employee class. Whenever there is any change by any C-level person, it would not affect other parts of the employee which are allocated to other C-level persons.

Open-Closed Principle

The Open-Closed Principle states that a module should be open for extension but closed for modification. It means that when we want to change the modules, we should be able to change them without changing the code of the modules. This is achieved through the use of abstraction and polymorphism.

Example:

class Modem(ABC):
    @abstractmethod
    def dial(self, phoneNumber):
        pass

class AnalogModem(Modem):
    def dial(self, phoneNumber):
        print(f"Dialing {phoneNumber} using an analog modem.")

class DigitalModem(Modem):
    def dial(self, phoneNumber):
        print(f"Dialing {phoneNumber} using a digital modem.")

def logOn(modem: Modem, phoneNumber, username, password):
    modem.dial(phoneNumber)

analog_modem = AnalogModem()
digital_modem = DigitalModem()

logOn(analog_modem, "12345", "user", "pass")
logOn(digital_modem, "67890", "user", "pass")

Here in the above example, the logOn function is open for modification by implementing analog and digital modems but, is closed from the logOn function. When a new type of modem is created in the future there is no need to modify logOn code but the logOn can be changed.

Liskov Substitution Principle

The Liskov Substitution Principle states that subclasses should be suitable for their base classes. When using inheritance the derived class must be able to substitute the base class in usage. If there is any significant change between the base class and the derived class then there shouldn't be inheritance.

Example:

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("bark")

class Cat(Animal):
    def make_sound(self):
        print("meow")

def make_animal_sound(animal: Animal):
    animal.make_sound()

# Usage:
dog = Dog()
cat = Cat()

make_animal_sound(dog)  # bark
make_animal_sound(cat)  # meow

In the above example, we can pass both cat and dog instances with the Animal base class as an argument to the function and it still works as expected.

Interface Segregation Principle

The Interface Segregation Principle states that many client interfaces are better than one general-purpose interface. It means that if a class has several clients, rather than loading the class with all the methods that the clients need, having specific interfaces for each client and multiplying inherit them into class. This will help the client to inherit a class where they don't need to know the parts of the interface that they won't use.

Example:

class Printer(ABC):
    @abstractmethod
    def print(self, document):
        pass

class Fax(ABC):
    @abstractmethod
    def fax(self, document):
        pass

class Scanner(ABC):
    @abstractmethod
    def scan(self, document):
        pass

class MultiFunctionDevice(Printer, Fax, Scanner):
    def print(self, document):
        print(f"Printer")

    def fax(self, document):
        print(f"Fax")

    def scan(self, document):
        print(f"Scanner")

class SimplePrinter(Printer):
    def print(self, document):
        print(f"modern printer")

Here the interfaces Printer, Fax, and Scanner are implemented in all or separately instead of one big fat PrintFaxScan class even though they are closely related in the real world. The person implementing only one interface does not know the others.

Dependency Inversion Principle

The Interface Segregation Principle states "Depend upon Abstractions. Do not depend upon concretions.". When a class depends upon other classes, it can result in repeated code. Every dependency in design should target an interface or abstract class. No dependency should target the concrete class. This is to ensure that a change in one part of the code won't result in a break in another of the code.

Example:

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

    def drive(self, vehicle):
        vehicle.drive()

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

    def drive(self):
        pass

class Car(Vehicle):
    def drive(self):
        print(f"Driving {self.name}")

class Boat(Vehicle):
    def drive(self):
        print(f"Sailing {self.name}")

In the above example, if the Driver is created by extending Car and Boat, it'll result in repeated code and will require cascading changes to implement change to Driver. Having the Driver target the class Vehicle will help it to automatically use the Car and Boat class.

Objects and Object-Oriented Programming - Python

Saravanan — Thu, 16 Feb 2023 06:35:05 +0000

An object is an instance of a class in python. A class is like a blueprint for the instances. Objects have member variables and member functions which are known as attributes and methods in python. The main aim of OOP is the encapsulation of data and functions that work on those data.

class ClassNameCamelCase(AnotherClass):
    # class def

There are two main relationships in OOP, they are composition and inheritance. Composition is where an object contains another object and inheritance is where one class builds on top of another class.

Constructors, Initializer, and Finalizer

A class has a built-in initializer __init__() method to define the initial values of the instance attributes and it should not have a return in it.

The constructor in python can be defined by using __new__(). The constructor allocates memory for objects and is the only function called before creating the instance. For the constructor, the class is passed as an argument instead of the self like other class functions. In most cases, constructors are not defined.

The finalizer __del__() is called when the instance is at the end of the scope and its lifetime is complete. The garbage collector is run when the finalizer is run. Post-processing on instances depends upon the python implementation and instance attributes may not be available inside the finalizer at all times.

Attributes - Python

There are no private or public labels in python to control the access of the instance attributes. A normal attribute has no preceding underscores and it is meant to be accessed using the instance name and dot operator.

The attributes that are not meant to be accessed by the public are preceded with an underscore like _random_name. Even though they can be accessed by using the dot operator, it is there to say that they should not be accessed.

Using name mangling for an attribute or member function can prevent it from being used by a dot operator. It can still be accessed using a class name surrounded by an underscore like obj_instance._ClassName___mangledname.

Class attributes are attributes that are available to all instances. It exists for the class and not for every instance. It is usually defined before all member functions inside the class definition.

Methods - Python

Instance methods are methods that can access the instance attributes and class attributes. These are normal functions that work on instance attributes.

Class methods are methods that only work on class attributes and are declared as such using the @classmethod decorator on top of the function. This can be called from both the class and instance.

Static methods are methods that can't access both instance and class attributes. A static method is there to add any function or business logic such as an algorithm that is being used by an instance of a class.

Property methods are methods to provide neat getters and setters in Python. A property method for the attribute members can be defined by using the below code.

property(fget=None, fset=None, fdel=None, doc=None)

fget argument is for the function that returns the attribute value, fset is for the function assigning the value, fdel is for the function that runs when an instance is deleted, and the doc is for docstring. Property methods can also be set using decorators as below.

random_name = property()

@random_name.getter
def randon_fn(self):

@random_name.setter
def randon_fn(self):

@random_name.deleter
def randon_fn(self):

Special methods or dunder(double underscore) methods add special functionality such as __str__() is used when the object is converted to a string. There are many different dunder methods in python each having its use case.

Inheritance

Inheritance is a concept that allows the creation of a class that shares a common code with another class. In an inherited class some of the attributes and methods are overridden and additional attributes and methods are added.

class InheritedClass(ParentClass):
    #class definition

A class can also inherit from multiple class but, resolution for functions must be made whenever there is conflicting functions or attributes are there in parent classes. By default, python uses C3 Method Resolution Order to resolve attribute and method lookup conflicts when a class has multiple inheritance or multilevel inheritance. If a class has a local attribute or method it comes first. In other cases, the order is followed as per the inheritance graph.

Mixin is a class that is inherited by different unrelated classes that requires common functionality.

Abstract class and Virtual subclasses

An abstract class is a class that only has methods without any definition. Any class that inherits an abstract class needs to implement all the methods in the abstract base class. It helps to provide a structure for all inheriting classes to conform to a structure.

Virtual subclasses are classes that implement the interface defined by the abstract base class without explicitly inheriting it. It is mainly used to decouple the interface from the class hierarchy and make it easier to extend. To register a class as a virtual subclass of an abstract class register method is used.

RandAbstractClass.register(VirtualSubClass)

String Methods

Saravanan — Thu, 16 Feb 2023 04:27:34 +0000

There are three different types of strings in python. They are

string literals
raw strings
formatted strings

String literals - String literals can be defined using single quotes ', double quotes " and triple quotes """. The escape characters are mentioned inside using a backslash \ for example a new line would be \n.

Raw strings - In raw string a backslash is treated as a literal character. A string is treated as a raw string of its prefixed with an r in front. Raw strings are used for regular expressions.

Formatted strings - Also called f-strings allows us to insert values of variables into a string. The value of the variable or expression inside curly braces will replace the curly brace section inside the f-string. Placing the semicolon : after the variable inside the curly brace will help change the format specification.

String concatenation

String concatenation can be done by both the + operator and the join function and f-string. In terms of performance, the f-string is the fastest one, followed by the join and plus operators the last.

Common String methods

capitalize() - capitalizes the first character of a string and all others in lowercase.

"first Second".capitalize() # returns "First second"

center(width[, fillchar]) - returns a string in the center within a specified width.

"word".center(10, "-") # returns "---word---"

count(sub[, start[, end]]) - returns the number of occurrences of a substring within a string.

"hello".count("l") # returns 2

find(sub[, start[, end]]) - returns the lowest index of the substring within the string.

"hello world".find("o") # returns 4

format(*args, **kwargs) - performs string formatting operation.

"Hi {}, It's {} now.".format("name", 1 + 1) # returns "Hi name, It's 2 now."

format_map(mapping) - formats a string using a dictionary.

"Hi {name}, It's {time} now.".format_map({"name": "Batman", "time": 12}) # returns "Hi Batman, It's 12 now."

index(sub[, start[, end]]) - returns the lowest index of the substring within the string.

"hello".index("o") # returns 4

isalnum() - returns True if all characters in the string are alphanumeric.

"a1".isalnum() # returns True

isalpha() - returns True if all characters in the string are alphabetic.

"hello".isalpha() # returns True

isdecimal() - returns True if all characters in the string are decimal. Decimal characters are those that can be used to form numbers in base 10.

 "123".isdecimal() # returns True

isdigit() - returns True if all characters in the string are digits. Digits include decimal characters and digits that need special handling, such as the compatibility superscript digits.

"¹²³".isdigit() # returns True

isnumeric() - returns True if all characters in the string are numeric. Numeric characters include digit characters, and all characters that have the Unicode numeric value property.

"ⅠⅩⅤⅬⅭⅮⅯ".isnumeric() # returns True

islower() - returns True if all characters in the string are lowercase.

"hello".islower() # returns True

isupper() - returns True if all characters in the string are uppercase.

"HELLO".isupper() # returns True

join(iterable) - returns a string concatenated with the elements of an iterable.

" ".join(["Hello", "World"]) # returns "Hello World"

lower() - converts the string to lowercase.

"Hello".lower() # returns "hello"

replace(old, new[, count]) - returns a string with all occurrences of the old string replaced with the new string.

"Hi First".replace("First", "New") # returns "Hello New"

split([sep[, maxsplit]]) - returns a list of the words in the string.

"Hello World".split() # returns ["Hello", "World"]

strip() - returns string with leading and trailing whitespace removed.

"hello  ".strip() # returns "hello"

upper() - converts the string to uppercase.

"hello".upper() # returns "HELLO"

Array Methods - Python

Saravanan — Thu, 16 Feb 2023 04:21:34 +0000

Python doesn't have a built-in array data type. The array module is used to work with the array. An array can be created as shown below.

import array

arr = array.array("i", [1, 2, 3, 4, 5])

The above line creates an array of elements 1 to 5 of type signed integer. Here the array() function is used to create an array. The first "i" is to mention that the type code of the array is a signed integer.

The list of type codes can be obtained by running below

array.typecodes

which returns bBuhHiIlLqQfd.

b - signed char
B - unsigned char
u - unicode char
h - signed short
H - unsigned short
i - signed int
I - unsigned int
l - signed long
L - unsigned long
q - signed long long
Q - unsigned long long
f - float
d - double

All the type code has a corresponding C Type. The byte size of the type depends upon the machine running the program. The byte size of arr can be checked below

arr.itemsize

The array can be created from the list and converted to the list as below.

arr.fromlist([1, 2, 3, 4, 5])
arr.tolist() # returns python list [1, 2, 3, 4, 5]

New items can be added to the array by appending or inserting a value at a position.

arr.append(6)
arr.insert(2, 2)

New items can be appended from strings or files also.

arr.append("word")
arr.append(file_source, 10) # reads 10 lines from file and appends it

Elements can be removed by using the index or value of the element. The pop is to remove from an element by passing the index and the remove is by passing a value of the element.

arr.pop(1)
arr.remove(4)

The array can also be reversed by calling the reverse function. This does not reverse the array in memory but, changes the access order.

arr.reverse()

Process management in GNU/Linux

Saravanan — Thu, 02 Feb 2023 06:45:41 +0000

Kill

Kill is a program that is used to send signals to a process or process groups. By default TERM is sent to the process if no signal is specified. We can send any signal to the process as below

$kill -SIGNAL PID

The signal can be a name or number. the list of signals with number and name is listed with the below command

$kill -l

By default, kill will send SIGTERM or 15 to the process. This will send the signal to the process and it is handled as per the process. It can be blocked, handled, or ignored by the process.

$kill -9 PID
$kill -KILL PID

The above sends SIGKILL causes the process and its child processes to terminate immediately. The process can't block or ignore this.

$kill -HUP PID

The above signal also terminates the program but, the difference is it is sent by the system when a terminal is closed and all the processes started from the terminal will receive SIGHUP which means a hang-up signal.

$kill -STOP PID

The above command sends SIGSTOP to the process which suspends the process immediately. It can then be resumed by sending the SIGCONT signal.

For the most common use, killall is used. It kills a process by its name. For example, to kill chrome below command can be used. The -w flag is to wait till all signaled processes die.

$killall -w chromium-browser

PS - process status

The ps shows which processes are running currently running. There are 3 styles to the arguments for ps. GNU with long names and double dash, BSD usually without any dash, and UNIX with dashes. The below commands are essentially the same

$ps -ef
$ps aux

All default columns are self-explanatory except the STAT which shows the status of the process. The meaning of each letter for this column is given below.

R: running
Z: zombie
D/S: sleep
T: stopped
N: low priority
l: multithreading
s: session leader
+: foreground process group
<: high priority

$ps auxf
$ps auxwww
$ps auxe

The f is forest, which is used to show process trees in ASCII art. www is to expand the width and shows processes with all of its arguments. e will display with environment variables.

TOP

TOP is a cli task manager program. It gives a live update of top users of the system's resources.

$top

The load average with 3 numbers gives average CPU use in the last 1, 5, and 15 minutes. Each column is described below.

%CPU: shows percent use of single-core, for the 12-core processor it can be up to 1200%
%MEM: use of disk space
COMMAND: command line used to start the process
RES: the amount of RAM used
USER: owner of the process

GNU/Linux utilities for system info

Saravanan — Thu, 02 Feb 2023 06:43:47 +0000

df

Disk free or df is used to find the free space under each partition.

$df -h

Above command displays the free space in a human-readable format. We can also check if we can create new files with the below command.

$df -ih

It displays inodes in each partition. If there is none then, new files cannot be created.

free

Free is similar to disk free. It is used the check the free and used amount of RAM/memory.

$free -h

The above command displays the usage of memory in a human-readable format.

lspci

lspci lists all PCI devices in the system.

$lspci

Above command lists all PCI devices. The first column has data in the format of domain : bus : slot . func followed by the device description.

$lspci -t

Above command displays in ASCII tree format to show how devices are connected to buses.

#lspci -vvvs $ID

To display complete information about the device -vvv is used. A decrease in character v count reduces the detail of information. -s is used to specify a device by its id without which it displays all device information.

$lspci -k

To get the kernel module for each device using the -k flag.

uname

uname is used to print the system information. The -a flag is to display all the information.

$uname -a

Particular information can be printed with the flags. They are

o: operating system name, not the distro name
i: the hardware platform
p: processor architecture
v: kernel version
s: kernel name
m: machine hardware name
n: system's name/node network hostname

DEV Community: Saravanan

Django

Secret key

Default Django apps

Middleware and different kinds of middleware

CSRF

XSS

ClickJacking

WSGI

Models

ondelete

Fields and Validators

Module and Class

Django ORM in shell

ORM to SQL in Django shell

Aggregation and Annotation

Migration file

SQL Transactions

Atomic transaction

Revision 15-03-2023

1. How can you copy objects in JS?

2. What is the difference between a named function and an anonymous function in JS?

3. How to check if a string contains a substring in JS?

4. What is the difference between indexOf() and lastIndex() methods in JS?

5. Is JS static or dynamically typed language?

6. How can you iterate over elements of an array without using for and while loop in JS?

7. What is a Cartesian product in SQL?

8. In which array methods can we use negative indexes and how can we use them?

9. What is destructuring in JS?

10. What is the expected output when giving 'None' as a parameter while using the filter function on a list in Python?

11. What is the actual use case of JSON.stringify() and JSON.parse()?

HTML/CSS concepts

Box model

Inline vs Block elements

Relative vs Absolute positioning

CSS Structural Classes

Common CSS Styling Classes

CSS Specificity

CSS responsive queries

Flexbox and Grid

Flexbox

Grid

Common meta tags in the header

Passing by Assignment, References, Shallow and Deep Copy - Python

Passing by Assignment

References

Shallow copy and Deep copy

SQL Concepts

ACID

Atomicity

Consistency

Isolation

Durability

CAP Theorem

Joins

Aggregations

Filter in queries

Data normalization3

Indexes4

Transactions

Locking mechanism5

Database isolation6

Triggers

SOLID concepts

Why SOLID and other software design principles?

Single Responsibility Principle3

Open-Closed Principle

Liskov Substitution Principle

Interface Segregation Principle

Dependency Inversion Principle

Objects and Object-Oriented Programming - Python

Constructors, Initializer, and Finalizer

Attributes - Python

Methods - Python

Inheritance

Abstract class and Virtual subclasses

String Methods

String concatenation

Common String methods

Array Methods - Python

Data normalization³

Indexes⁴

Locking mechanism⁵

Database isolation⁶

Single Responsibility Principle³