DEV Community: Aniket Tiwari

🚀 Day 4: Mastering SQL 🚀

Aniket Tiwari — Sun, 07 Jul 2024 13:59:24 +0000

Today’s focus was on mastering the fundamentals of table creation and description in MySQL. Understanding these basics is crucial for efficiently managing and organizing data. Here’s a quick rundown:

📌 Creating Tables in MySQL

The CREATE TABLE statement is used to create a new table in the database.

Syntax:

CREATE TABLE table_name (
    column1 datatype constraints,
    column2 datatype constraints,
    ...
);

Example:

CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    BirthDate DATE,
    HireDate DATE,
    Salary DECIMAL(10, 2)
);

📌 Describing Tables in MySQL

The DESCRIBE statement provides a detailed structure of the table, including column names, data types, and constraints.

Syntax:

DESCRIBE table_name;

Example:

DESCRIBE Employees;

📌 Common Data Types in MySQL

INT: Integer values.
VARCHAR(size): Variable-length string with a maximum length of size.
DATE: Date values in YYYY-MM-DD format.
DECIMAL(p, s): Fixed-point numbers where p is the precision (total number of digits) and s is the scale (number of digits after the decimal point).

🌟 Key Takeaways:

CREATE TABLE is foundational for database structure.
DESCRIBE helps understand the schema and verify table structures.
Knowing data types ensures the right kind of data storage and efficient querying.

Excited to dive deeper into SQL and explore more advanced concepts in the coming days! Stay tuned for more updates. 🚀

🚀 Exciting News for Django Developers: Upgrade from Version 4 to 5! 🚀

Aniket Tiwari — Sat, 23 Dec 2023 19:32:59 +0000

Django 5 Unveiled: Streamlining Your Development Journey

Django, the popular Python web framework, has recently released its much-awaited version 5.0, bringing a host of exciting features and improvements to enhance developer productivity and code maintainability. Let's dive into some of the key highlights:

1. Simplified Form Field Rendering:

Rendering form fields in templates often involves repetitive code, making it tedious and prone to errors. Django 5 introduces field groups and field group templates, simplifying the process by encapsulating related elements like labels, widgets, help text, and errors within reusable templates.

Example:

Old way:

<label for="{{ field.id_for_label }}">{{ field.label }}</label>
{{ field }}
{% if field.help_text %}
<small class="form-text text-muted">{{ field.help_text }}</small>
{% endif %}
{% for error in field.errors %}
<p class="text-danger">{{ error }}</p>
{% endfor %}

New way (using field groups):

{{ field.as_field_group() }}

2. Enhanced Field Choices:

Defining choices for model and form fields was limited to iterables (like lists or tuples). Django 5 expands flexibility by allowing mappings (dictionaries) or callables (functions) for defining choices, enabling dynamic generation of choices based on external data or logic.

Example:

Old way:

SPORT_CHOICES = (
    ("judo", "Judo"),
    ("karate", "Karate"),
    # ...
)

New way:

SPORT_CHOICES = {
    "Martial Arts": {"judo": "Judo", "karate": "Karate"},
    "Racket": {"badminton": "Badminton", "tennis": "Tennis"},
    "unknown": "Unknown",
}

3. Model Fields for Computations and Generated Columns:

Developers often create custom logic for computed fields or rely on database-level features for generated columns. Django 5 introduces two new field types:

db_default allows setting database-computed default values for fields.
GeneratedField creates fields whose values are calculated from other fields, either stored in the database or computed on-the-fly.

Example:

Old way (using database-level default):

class Order(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)

New way:

class Order(models.Model):
    created_at = models.DateTimeField(db_default=django.db.models.functions.Now())
    total_price = models.DecimalField(max_digits=10, decimal_places=2)
    tax_amount = models.DecimalField(max_digits=10, decimal_places=2, generated=models.DecimalField.Expression("total_price * 0.07"))  # Generated field

4. Async View Decorators and Exception Handling:

Handling asynchronous views and potential disconnections required manual management. Django 5 expands its asynchronous support with:

Additional asynchronous view decorators (@sync_to_async and @async_to_sync).
AsyncClient improvements for asynchronous testing.
Exception handling for asynchronous disconnections.

5. Other Notable Improvements:

Streamlined choices for TextChoices and IntegerChoices.
More intuitive handling of choices in model forms.
Enhanced admin site with autocomplete for foreign keys.
Extended support for geospatial operations.
Improvements in messages handling.

Django 5 continues the framework's tradition of innovation and developer-centric design. These features promise to streamline development workflows, improve code readability, and embrace modern asynchronous patterns. Upgrade your projects to Django 5 and experience the benefits firsthand!

Building a Production-Ready Backend: Node.js, Express, and MongoDB Atlas Setup Guide (2023) - Part 1

Aniket Tiwari — Tue, 14 Nov 2023 21:55:57 +0000

Initializing a Project with Folder Structure and .env Configuration

Prerequisites

Before proceeding with the backend setup, ensure that you have Node.js and npm installed on your machine.

Step 1: Initialize the Project

Start by creating a new directory for your project:

mkdir your-backend-app-name

Navigate to the project directory in your terminal:

cd your-backend-app-name

Next generate npm project using following command:

npm init

Or to generate an empty npm project without going through an interactive process use:

npm init -y

To make the project compatible with ES6 import statements, add "type": "module" to your package.json file.

This sets up a new Node.js project with default settings.

Step 2: Folder Structure

Here is the recommended folder structure for your backend application:

Let's break down the folder structure:

public: This folder is typically used for static assets that your server will serve, such as images, stylesheets, or client-side JavaScript files.
src: The main source code folder for your application.
- controllers: Modules responsible for handling the logic of your application. Each route may have its own controller.
- db: Database-related files, such as database connection setup.
- middlewares: Middleware functions that can be used in your routes. Middleware functions have access to the request and response objects and can perform actions before the main handler is called.
- models: Used for defining the structure of your data, such as database models or other data-related structures.
- routes: Define the routes of your application. Each route typically has its own file or module within this folder, handling incoming requests, using controllers to process them, and sending responses.
- utils: Utility functions or modules that can be used across different parts of your application.
- app.js: The main application file where you set up your Express application, define middleware, and connect routes.
- constants.js: A file to store constants used throughout your application.
- index.js: The entry point of your application, typically responsible for starting your server.
.env: A configuration file for storing environment variables, which can include sensitive information or configuration settings for your application.
.env.sample: A template for the .env file, providing guidance on what variables need to be set and their expected values. This file can be committed to version control to assist other developers in setting up their environments.
.gitignore: Specifies files and folders that should be ignored by version control, commonly including node_modules (where Node.js packages are installed) and .env.
.prettierignore: Specifies files and folders that should be ignored by the Prettier code formatter.
.prettierrc: Configuration file for Prettier, defining code formatting rules.
package.json: Contains metadata about your project and the dependencies it uses, including scripts for common tasks such as starting the server or running tests.

Step 3: .env Configuration

Install the dotenv package to load environment variables from the .env file. Additionally, set up npm scripts for starting the server in both production and development environments.

Install the dotenv package and include it as a dependency:

   npm install dotenv

Install the nodemon package and include it as a devDependency:

   npm install -D nodemon

Update your package.json file with the following scripts:

   "scripts": {
     "start": "node src/index.js",
     "dev": "nodemon -r dotenv/config --experimental-json-modules src/index.js"
   }

The "dev" script uses nodemon with the dotenv configuration to enable automatic reloading during development.

Create a .env file in your project root and add your configuration variables:

   # .env

   KEY=VALUE

Replace KEY and VALUE with your actual environment variables and their values.

In conclusion, this structure provides a modular and organized foundation for building a Node.js backend application.

DEV Community: Aniket Tiwari

🚀 Day 4: Mastering SQL 🚀

📌 Creating Tables in MySQL

📌 Describing Tables in MySQL

📌 Common Data Types in MySQL

🌟 Key Takeaways:

🚀 Exciting News for Django Developers: Upgrade from Version 4 to 5! 🚀

Building a Production-Ready Backend: Node.js, Express, and MongoDB Atlas Setup Guide (2023) - Part 1

Initializing a Project with Folder Structure and .env Configuration

Prerequisites

Step 1: Initialize the Project

Step 2: Folder Structure

Step 3: .env Configuration

In next steps we are going to configure MongoDB Atlas and additional steps depending on your project requirements.