Kvnbbg.fr

Who loves creating apps.

Tag: python

python & sqlite / Enhancing Library Databases !

24/05/2024 / / 0 Comments

Quels sont les effets personnels auxquels vous tenez le plus ?

Les effets personnels auxquels je tiens le plus sont généralement ceux qui ont une valeur sentimentale ou une importance particulière dans ma vie quotidienne.

  1. Photographies et souvenirs : Les photos de famille, d’amis et des moments importants de ma vie sont précieuses car elles capturent des souvenirs irremplaçables.
  2. Objets hérités : Des objets transmis de génération en génération, comme des bijoux, des montres, ou des meubles, ont souvent une grande valeur sentimentale.
  3. Livres et documents personnels : Les journaux intimes, les lettres et les livres qui ont marqué ma vie ont une signification personnelle profonde.
  4. Appareils électroniques : Mon téléphone, mon ordinateur portable, et d’autres appareils électroniques sont essentiels pour mon travail et ma communication quotidienne.
  5. Objets de passe-temps : Les instruments de musique, les équipements sportifs ou les jeux vidéo qui correspondent à mes loisirs et passions sont également très importants pour moi.

Ces objets, bien qu’ils aient une valeur matérielle, sont souvent chéris pour les souvenirs et les émotions qu’ils évoquent.

Using Python and SQLite to manage a library database, including realistic data and tracking updates, helps streamline the organization and retrieval of important personal collections, much like preserving and valuing sentimental personal effects.

The Importance of Realistic and Diverse Data

Click here to display content from YouTube.
Learn more in YouTube’s privacy policy.

Open "UML Diagrams Full Course (Unified Modeling Language)" directly

In the digital age, libraries have evolved from mere repositories of physical books to sophisticated hubs of information, accessible at the click of a button. One of the critical aspects of managing a modern library database is ensuring that the data it contains is both realistic and diverse. This not only enhances the usability of the database but also improves the overall user experience.

The Need for Realistic and Diverse Data

Realistic data provides users with a more accurate representation of the library’s contents, which is essential for efficient search and retrieval. Diverse data, on the other hand, ensures that the library caters to a wide range of interests and scholarly needs, promoting inclusivity and broadening the scope of knowledge accessible to users.

A library database with well-structured and comprehensive data can support various functions, from basic cataloging to advanced analytics. This data helps librarians make informed decisions about acquisitions, track book popularity, and even predict future trends.

Practical Example: Creating a Realistic Library Database

Consider a library database that stores information about books and authors. A simplistic dataset might suffice for basic operations, but it often falls short in real-world applications. To illustrate this, let’s look at an SQL script designed to create and populate a realistic and diverse library database.

— Create the Authors table
CREATE TABLE IF NOT EXISTS Authors (
id INTEGER PRIMARY KEY, — Unique identifier for each author
name TEXT — Name of the author
);

— Create the Books table
CREATE TABLE IF NOT EXISTS Books (
id INTEGER PRIMARY KEY, — Unique identifier for each book
name TEXT, — Name of the book
year INTEGER, — Year the book was published
author_id INTEGER, — ID of the author from the Authors table
FOREIGN KEY (author_id) REFERENCES Authors(id) — Establishes the foreign key relationship
);

— Insert sample data into the Authors table
INSERT INTO Authors (id, name) VALUES
(1, ‘Jane Austen’),
(2, ‘Charles Dickens’),
(3, ‘Mark Twain’),
(4, ‘Virginia Woolf’),
(5, ‘George Orwell’),
(6, ‘Agatha Christie’),
(7, ‘J.K. Rowling’);

— Insert sample data into the Books table
INSERT INTO Books (id, name, year, author_id) VALUES
(1, ‘Pride and Prejudice’, 1813, 1),
(2, ‘Sense and Sensibility’, 1811, 1),
(3, ‘Great Expectations’, 1861, 2),
(4, ‘A Tale of Two Cities’, 1859, 2),
(5, ‘Adventures of Huckleberry Finn’, 1884, 3),
(6, ‘The Adventures of Tom Sawyer’, 1876, 3),
(7, ‘Mrs Dalloway’, 1925, 4),
(8, ‘To the Lighthouse’, 1927, 4),
(9, ‘1984’, 1949, 5),
(10, ‘Animal Farm’, 1945, 5),
(11, ‘Murder on the Orient Express’, 1934, 6),
(12, ‘The Murder of Roger Ackroyd’, 1926, 6),
(13, ‘Harry Potter and the Philosopher\’s Stone’, 1997, 7),
(14, ‘Harry Potter and the Chamber of Secrets’, 1998, 7);

— Select the book name, year, and author’s name for all books,
— ordering the results first by the author’s name alphabetically,
— and then by the year of publication in ascending order.
SELECT
Books.name AS book_name,
Books.year,
Authors.name AS author
FROM
Books
JOIN
Authors ON Books.author_id = Authors.id
ORDER BY
Authors.name ASC,
Books.year ASC;

Benefits of a Realistic Dataset in Python !

# In python

import sqlite3
from datetime import datetime

# Function to initialize the database and create tables
def initialize_database():
conn = sqlite3.connect(‘library.db’)
cursor = conn.cursor()

cursor.execute(”’
CREATE TABLE IF NOT EXISTS Authors (
id INTEGER PRIMARY KEY,
name TEXT
)
”’)

cursor.execute(”’
CREATE TABLE IF NOT EXISTS Books (
id INTEGER PRIMARY KEY,
name TEXT,
year INTEGER,
author_id INTEGER,
FOREIGN KEY (author_id) REFERENCES Authors(id)
)
”’)

cursor.execute(”’
CREATE TABLE IF NOT EXISTS Updates (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT,
description TEXT
)
”’)

conn.commit()
conn.close()

# Function to insert sample data
def insert_sample_data():
conn = sqlite3.connect(‘library.db’)
cursor = conn.cursor()

authors = [
(1, ‘Jane Austen’),
(2, ‘Charles Dickens’),
(3, ‘Mark Twain’),
(4, ‘Virginia Woolf’),
(5, ‘George Orwell’),
(6, ‘Agatha Christie’),
(7, ‘J.K. Rowling’)
]

books = [
(1, ‘Pride and Prejudice’, 1813, 1),
(2, ‘Sense and Sensibility’, 1811, 1),
(3, ‘Great Expectations’, 1861, 2),
(4, ‘A Tale of Two Cities’, 1859, 2),
(5, ‘Adventures of Huckleberry Finn’, 1884, 3),
(6, ‘The Adventures of Tom Sawyer’, 1876, 3),
(7, ‘Mrs Dalloway’, 1925, 4),
(8, ‘To the Lighthouse’, 1927, 4),
(9, ‘1984’, 1949, 5),
(10, ‘Animal Farm’, 1945, 5),
(11, ‘Murder on the Orient Express’, 1934, 6),
(12, ‘The Murder of Roger Ackroyd’, 1926, 6),
(13, ‘Harry Potter and the Philosopher\’s Stone’, 1997, 7),
(14, ‘Harry Potter and the Chamber of Secrets’, 1998, 7)
]

cursor.executemany(‘INSERT OR IGNORE INTO Authors (id, name) VALUES (?, ?)’, authors)
cursor.executemany(‘INSERT OR IGNORE INTO Books (id, name, year, author_id) VALUES (?, ?, ?, ?)’, books)

log_update(cursor, “Inserted sample data into Authors and Books tables.”)

conn.commit()
conn.close()

# Function to log updates
def log_update(cursor, description):
timestamp = datetime.now().strftime(‘%Y-%m-%d %H:%M:%S’)
cursor.execute(‘INSERT INTO Updates (timestamp, description) VALUES (?, ?)’, (timestamp, description))

# Function to fetch updates
def fetch_updates():
conn = sqlite3.connect(‘library.db’)
cursor = conn.cursor()

cursor.execute(‘SELECT * FROM Updates ORDER BY timestamp DESC’)
updates = cursor.fetchall()

conn.close()
return updates

# Initialize the database and insert sample data
initialize_database()
insert_sample_data()

# Fetch and print the updates
updates = fetch_updates()
print(“Database Updates:”)
for update in updates:
print(f”ID: {update[0]}, Timestamp: {update[1]}, Description: {update[2]}”)

By including a diverse range of authors and books, the database becomes a more accurate reflection of what one might find in a real library. This not only helps in better cataloging and retrieval but also enhances user engagement. Users are more likely to find what they are looking for when the database mirrors the diversity of real-world literature.

Side view of African American learner making math calculations on blackboard during lesson in classroom

Hash Tables : First Step (guide)

25/04/2024 / / 0 Comments

What is a Hash Table?

Click here to display content from YouTube.
Learn more in YouTube’s privacy policy.

Open "Learn Hash Tables in 13 minutes #️⃣" directly
This process allows for constant-time average case access to elements, making hash tables incredibly efficient for storing and retrieving data.

A hash table, also known as a hash map, is a data structure that stores key-value pairs. It uses a hash function to compute an index into an array of buckets or slots, where the corresponding value can be stored or retrieved quickly.

How Does a Hash Table Work? (Javascript)

class HashTable {
    constructor() {
        this.table = [];
    }

    // Fonction de hachage
    _hash(key) {
        // Implémentez votre propre fonction de hachage ici
        // Elle doit transformer la clé en un indice entier
        // Exemple simplifié :
        return key.length % 10;
    }

    // Méthode pour ajouter une paire clé/valeur
    set(key, value) {
        const index = this._hash(key);
        if (this.table[index]) {
            for (let i = 0; i < this.table[index].length; i++) {
                // Trouvez la paire clé/valeur dans la chaîne
                if (this.table[index][i][0] === key) {
                    this.table[index][i][1] = value;
                    return;
                }
            }
            // Non trouvé, ajoutez une nouvelle paire clé/valeur
            this.table[index].push([key, value]);
        } else {
            // Créez une nouvelle chaîne pour cette clé
            this.table[index] = [[key, value]];
        }
    }

    // Méthode pour récupérer une valeur à partir de la clé
    get(key) {
        const index = this._hash(key);
        if (this.table[index]) {
            for (let i = 0; i < this.table[index].length; i++) {
                if (this.table[index][i][0] === key) {
                    return this.table[index][i][1];
                }
            }
        }
        return undefined; // Clé non trouvée
    }
}

// Exemple d'utilisation
const myHashTable = new HashTable();
myHashTable.set("Nathan", "555-0182");
myHashTable.set("Jane", "315-0322");

console.log(myHashTable.get("Nathan")); // Affiche "555-0182"

When a key-value pair is inserted into a hash table, the hash function calculates the index where the value will be stored based on the key. This index is typically determined by taking the result of the hash function modulo the size of the array, ensuring that it falls within the range of available buckets. If there is a collision, where multiple keys map to the same index, various collision resolution techniques can be employed, such as chaining or open addressing.

Example:

Let’s consider a simple example in Python:

# Creating a hash table using dictionaries
hash_table = {}

# Inserting key-value pairs
hash_table['apple'] = 10
hash_table['banana'] = 20
hash_table['orange'] = 30

# Retrieving values
print(hash_table['banana'])  # Output: 20

In this example, we create a hash table using Python dictionaries. We insert key-value pairs representing fruits and their respective quantities. Finally, we retrieve the quantity of bananas stored in the hash table.

So, we are on a daily routine when practice regularly provide scalable competences and happiness. Let’s coding !

Benefits of Hash Tables:

  • Fast Access: Hash tables offer constant-time average case access to elements, making them ideal for applications requiring quick data retrieval.
  • Flexible Key Types: Hash tables can typically handle a wide range of key types, including strings, integers, and custom objects.
  • Dynamic Sizing: Many implementations of hash tables dynamically resize to accommodate a varying number of elements efficiently.

Conclusion:

A hash table (also known as a hashmap) is a data structure that allows you to create a collection of key-value pairs. It efficiently stores and retrieves values based on their associated keys.

  1. Hashing Function: A hash table uses a function (called a hash function) to transform a key into an integer index. This index determines where the key-value pair is stored in memory.
  2. Array Storage: The hash table revolves around an array, initially empty. Each element in the array has two properties: the data (the value associated with the key) and the key itself. For example, a list of zip codes and corresponding city names would be a key-value association.
  3. Insertion: When you insert a key-value pair, the hash function reduces the key to an index within the array. The data is then stored at that index. If multiple keys map to the same index (collision), the hash table handles it by comparing the actual keys directly.
  4. Retrieval: To retrieve a value, you run the key through the same hash function, get its hash-key, and access the corresponding place in the hash table to retrieve the associated data.

Use Cases:

  • Caching: Hash tables are commonly used for caching. For instance, if you need to hold records for thousands of students in a university, a hash table can efficiently store and retrieve this data.
  • Databases (Indexing): Hash tables are essential for indexing in databases, allowing fast retrieval of data based on keys.

Further Reading:

Python-Django backend for data processing and an Angular front-end for the user interface

27/03/2024 / / 0 Comments

Code Algorithm with Comments

process.

# Django backend part

# models.py
from django.db import models

# Define the Article model to store the article data
class Article(models.Model):
    title = models.CharField(max_length=255)
    introduction = models.TextField()
    early_days = models.TextField()
    rise_of_frameworks = models.TextField()
    modern_era = models.TextField()
    emerging_technologies = models.TextField()
    conclusion = models.TextField()

    def __str__(self):
        return self.title  # Representation of the model instance

# views.py
from django.views.generic import CreateView
from .models import Article
from .forms import ArticleForm  # Import the form for Article

# View to handle the creation of an Article
class ArticleCreateView(CreateView):
    model = Article
    form_class = ArticleForm
    template_name = 'article_create.html'
    success_url = '/articles/'

    # Example method to handle form submission
    def form_valid(self, form):
        # Logic to process input data and generate article content
        # This is where you can integrate the article generation logic
        return super().form_valid(form)

# Angular frontend part

# article.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({
  providedIn: 'root'
})
export class ArticleService {
  constructor(private http: HttpClient) {}

  // Method to submit user data to the backend and get the article
  submitData(userData: any): Observable<any> {
    return this.http.post('/api/articles/', userData);
  }
}

# article.component.ts (simplified for clarity)
import { Component } from '@angular/core';
import { FormGroup, FormControl } from '@angular/forms';
import { ArticleService } from './article.service';

@Component({
  selector: 'app-article-form',
  templateUrl: './article-form.component.html'
})
export class ArticleFormComponent {
  articleForm = new FormGroup({
    userData: new FormControl('')
  });

  constructor(private articleService: ArticleService) {}

  onSubmit() {
    // Call the service to submit the form data
    this.articleService.submitData(this.articleForm.value).subscribe(response => {
      // Handle the response here, such as displaying the generated article
    });
  }
}

Signature

For more insights and updates on web development, feel free to check my projects and thoughts at github.com/kvnbbg.

web development, php, java

Angular for the frontend, Python and Flask for the backend, and a SQL database to anchor our data.

25/03/2024 / / 0 Comments

Setting Up the Project 🛠️

Angular Setup

ng new task-app
cd task-app
ng serve

Python & Flask Backend

python -m venv venv
source venv/bin/activate

With our environment consecrated, Flask stands ready to breathe life into our server-side logic.

Integrating SQL Database 🗃️

The heart of our application—a SQL database—is next. Here, Flask SQLAlchemy weaves together our data model:

from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tasks.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)

@app.before_first_request
def create_tables():
    db.create_all()

@app.route('/task', methods=['POST'])
def add_task():
    data = request.get_json()
    new_task = Task(title=data['title'])
    db.session.add(new_task)
    db.session.commit()
    return jsonify({'message': 'Task created successfully'}), 201

@app.route('/tasks', methods=['GET'])
def get_tasks():
    tasks_query = Task.query.all()
    tasks = [{"id": task.id, "title": task.title} for task in tasks_query]
    return jsonify({'tasks': tasks})

@app.route('/task/<int:id>', methods=['PUT'])
def update_task(id):
    data = request.get_json()
    task = Task.query.filter_by(id=id).first()
    if not task:
        return jsonify({'message': 'Task not found'}), 404
    task.title = data['title']
    db.session.commit()
    return jsonify({'message': 'Task updated successfully'})

@app.route('/task/<int:id>', methods=['DELETE'])
def delete_task(id):
    task = Task.query.filter_by(id=id).first()
    if not task:
        return jsonify({'message': 'Task not found'}), 404
    db.session.delete(task)
    db.session.commit()
    return jsonify({'message': 'Task deleted successfully'})

if __name__ == '__main__':
    app.run(debug=True)

CSRF Protection with Angular

Angular, with its built-in CSRF defenses, ensures our application is fortified against cross-site request forgery:

import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root'
})
export class TaskService {
  constructor(private http: HttpClient) {}

  addTask(taskData: any) {
    return this.http.post('/api/tasks', taskData);
  }
}

This service acts as a conduit between our Angular frontend and Flask backend, ensuring tasks are managed with grace and efficiency.

CSRF Configuration in Flask

Ensuring Flask is prepared to parry CSRF attempts is paramount. Flask-WTF lends its strength to our defenses:

import os
from flask import Flask, render_template_string
from flask_wtf.csrf import CSRFProtect

app = Flask(__name__)
app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', os.urandom(24))

csrf = CSRFProtect(app)

@app.route('/', methods=['GET', 'POST'])
def index():
    return render_template_string("...")

if __name__ == '__main__':
    app.run(debug=True)

With CSRFProtect invoked, our application is shielded, allowing us to focus on crafting user experiences without fear.

PHP, Python, and AJAX

22/03/2024 / / 0 Comments

In the development of web applications, particularly those requiring dynamic user interactions without reloading the page, AJAX (Asynchronous JavaScript and XML) plays a pivotal role.

📖 Backend Powerhouses

PHP and Python are two of the most popular server-side scripting languages, each with its unique strengths in web development. PHP is widely known for its ease of use and deep integration with HTML, making it a go-to for web developers looking to quickly deploy dynamic web applications. On the other hand, Python’s simplicity, readability, and the powerful Django and Flask frameworks make it a formidable choice for building robust web applications.

🛠 Database Management systems

When it comes to database operations, both PHP and Python offer extensive support for various database management systems (DBMS) that make interactions more secure, efficient, and less prone to SQL injection.

  • PHP’s PDO (PHP Data Objects)
  • Python’s ORM (Object-Relational Mapping) tools like Django’s

💻 Implementing

AJAX allows web applications to send and retrieve data from a server asynchronously, without interfering with the display and behavior of the existing page. By using AJAX, a Task Application can perform CRUD (Create, Read, Update, Delete) operations seamlessly.

This JavaScript function could interact with a PHP script that updates a task’s status in the database. Similarly, a Python backend using Flask or Django can be set up to handle such requests.

🎨 Semantic HTML and Bootstrap:

Semantic HTML tags like <header>, <footer>, <nav>, and <article> improve the structure and readability of web content, making it more accessible and SEO-friendly. In a Task Application, using these tags can help define the structure of the app, making it easier for users and search engines to understand the content.

Conclusion

Integrating PHP or Python with AJAX for database operations in a Task Application not only enhances functionality but also improves user experience by making the application more interactive and responsive.

Database Management

22/03/2024 / / 0 Comments

At its core, a database is a systematic collection of data that supports the storage, manipulation, and retrieval of information. Databases can be relational (SQL) or non-relational (NoSQL), each serving different needs based on the structure and scalability requirements of your application.

from Sololearn

Best Practices :

  • Data Sanitization : Always sanitize user inputs to prevent SQL injection attacks. This involves escaping potentially harmful characters before they’re processed by the database.
  • Privilege : Operate your database under the principle of least privilege, meaning users and applications should have only the minimum permissions necessary to perform their tasks.

Secure Requests and Authorization

HTTPS : Use HTTPS (Hypertext Transfer Protocol Secure) for all communications between the client and server. HTTPS encrypts data in transit, preventing attackers from intercepting sensitive information.

Authorization Tokens : Implement token-based authorization, such as JWT (JSON Web Tokens), to manage user sessions. Tokens should be securely stored (in HTTP-only cookies) and validated with each request to verify a user’s identity and permissions.

Click here to display content from YouTube.
Learn more in YouTube’s privacy policy.

Open "Does Storing JWT’s In HTTP Only Cookies Stop XSS Attacks" directly

Safeguarding Your Environment

Application and server configurations play a significant role in security. A misconfigured server or application can serve as an entry point for attackers.

Secure Configuration Practices:

  • Update Regularly: Keep your server software and dependencies up to date to protect against known vulnerabilities.
  • Minimal Exposure: Disable unnecessary services and features on your server to reduce potential attack surfaces.
  • Environment Variables: Store sensitive configuration options such as API keys and database credentials in environment variables, not in your codebase.

A Shield Against Cross-Site Request Forgery

Cross-Site Request Forgery (CSRF) is an attack that tricks the victim into submitting a malicious request. It exploits the trust that a site has in a user’s browser.

How CSRF Protection Works :

  1. Token Generation : The server generates a unique, unpredictable token and sends it to the client’s browser as part of a form or an AJAX request.
  2. Token Validation : When the client submits the form or makes a request, it must include this token. The server then validates the token before processing the request.
  3. Token Invalidation : Tokens are invalidated after being used or after a certain period, requiring new tokens for subsequent requests.

Implementing CSRF tokens in forms and AJAX requests is a standard practice in modern web frameworks. This mechanism ensures that every state-changing request originates from your application, not an attacker.

Without Ajax (simplified)

Conclusion : Keeping Data Secure

Remember, security isn’t a one-time task but a continuous process of learning, implementing, and evolving with the digital landscape.

What i need to know. Into a developer road map.

22/03/2024 / / 0 Comments

Continue with Python with more advanced topics such as object-oriented programming, data structures, algorithms, and asynchronous programming. Resources like Automate the Boring Stuff with Python and Python.org are excellent places to start.

Click here to display content from YouTube.
Learn more in YouTube’s privacy policy.

Open "Learn Python – Full Course for Beginners [Tutorial]" directly

Step 1 : Python Skills

Step 2 : Front-End Technologies & librairies

Step 3: Back-End Development

Database Management: A full-stack developer must handle data efficiently. NOSQL (Mongo DB), SQL (SGBDR).

RESTful API Development: APIs are crucial for the communication between front-end and back-end.

Authentication & Security: Understand the importance of securing your applications against common security threats.

Step 4 : DevOps Practices

Version Control with Git: Mastering Git is essential for every developer. Learn how to manage your codebase using version control, collaborate with other developers, and use platforms like GitHub or GitLab.

Continuous Integration/Continuous Deployment (CI/CD): CI/CD pipelines to automate the testing and deployment of your applications. Tools like Jenkins, Travis CI, or GitHub Actions can help streamline these processes.

Step 5 : Building and Deploying a Full-Stack Application

Docker ! How to get started ?

22/03/2024 / / 0 Comments

Docker revolutionizes the way developers build, ship, and run applications by using containers. This technology ensures that applications work seamlessly in any environment by packaging them with all their dependencies.

What is Docker ?

Docker is a platform that enables you to create, deploy, and run applications in containers. Containers package an application with all its dependencies into a single unit, ensuring that it runs uniformly across any computing environment. This method significantly reduces the “it works on my machine” syndrome, promoting more reliable development and deployment processes.

Why Use Docker ?

1. Consistency: Docker ensures your application runs the same way in development, testing, and production environments, eliminating discrepancies across different stages of the software lifecycle.

2. Isolation: Containers are isolated from each other and the host system. If one application fails, it doesn’t affect others.

3. Efficiency: Docker enables more efficient use of system resources. Containers share the host system’s kernel and start up significantly faster than traditional virtual machines.

Getting Started with Docker

Installation:
Firstly, install Docker Desktop for Windows or Mac from the official Docker website, or Docker Engine for Linux distributions Docker Engine on Linux.

Building Your First Docker Container:

  1. Create a Dockerfile: This configuration file, named Dockerfile, outlines the steps to create the Docker image.

# Dockerfile for a Python-based application

FROM python:3.8 WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD [“python”, “./app.py”]

  1. Build the Container: Execute the command to build your Docker image, substituting my-app with your app’s name.

docker build -t my-app .

  1. Run the Container: Launch your container, making the application available on a specified port.

docker run -p 4000:80 my-app

Docker Compose for Multi-Container Apps

For complex applications requiring multiple services: docker-compose.yml

Execute docker-compose up to start all services.

Use Case : Task App

Users can add, view, and complete tasks with stunning 3D visualizations for task categories using Three.js.

Backend : Choose between Python with Django for a dynamic, robust backend or PHP with Symfony for a modular, enterprise-level application.

  • Django Backend (views.py) :
  • Symfony Backend (TaskController.php) :

Frontend: Implement the UI with HTML, CSS for styling, and JavaScript for dynamic content loading. Three.js adds 3D visualizations.

  • HTML (index.html) :
  • CSS (style.css) :
  • JavaScript with Three.js (app.js) :

Unit Testing : Ensure functionality with unit tests for both backend choices.

  • Django Test :
  • Symfony Test :

Conclusion

Docker serves as a powerful tool in modern development environments, facilitating consistency across development, testing, and production stages. Our Task App showcases how Docker can be an instrument. To explore more about containerization : Docker’s comprehensive guide.

🧭 Navigating through the process

22/03/2024 / / 0 Comments

Understanding the Task of iterating over arrays fetched from a SQL database

The goal is to iterate through an array of elements fetched from a SQL database, with each subsequent iteration covering fewer elements than the previous one.

Python Implementation

Python offers a straightforward syntax for handling database operations and iterating over arrays. Here’s how you can accomplish the task using Python:

PHP Implementation

PHP uses PDO for database interactions. Here’s how you can iterate through a fetched array with decreasing length:

JavaScript Implementation

In JavaScript, you might fetch data from a backend API and then process it. Here’s an example using fetch and async/await:

Unit Testing

Ensuring the reliability of your code through unit testing is essential. Here’s an example using Python’s unittest framework:

Conclusion

For junior developers, mastering array iteration and manipulation based on SQL data is a valuable skill across Python, PHP, and JavaScript. The ability to dynamically adjust the iteration based on the data set’s size introduces flexibility in data processing. Coupled with the practice of writing unit tests, this skill set ensures not only the functionality of your code but also its reliability and maintainability in the long term.

URL Parameters, and CSRF Protection in PHP Web Development

21/03/2024 / / 0 Comments

Understanding the $ Symbol in PHP

The $ symbol in PHP plays a pivotal role—it signifies the beginning of a variable name. Variables are fundamental in any programming language, acting as containers for storing data values. In PHP, the $ symbol precedes the variable’s name, indicating that what follows is a variable identifier. For example:$name = "John Doe";

Here, $name is a variable that stores the string “John Doe”. The $ symbol makes variables easily identifiable within the script, enhancing readability and maintaining a clean code structure.

Working with URL Parameters in PHP

URL parameters are a method of passing data from the client-side to the server-side in a web application. They are appended to the URL following a ? and separated by &. PHP can access these parameters via the superglobal arrays $_GET and $_POST, depending on the form submission method.

To capture a user’s name entered into a form and submitted via GET, the URL might look like this:http://example.com/form.php?name=John+Doe

In form.php, the PHP script retrieves the name using:$name = $_GET['name'];

Implementing CSRF Protection

Cross-Site Request Forgery (CSRF) is a security threat where unauthorized commands are transmitted from a user that the web application trusts. To mitigate this, web applications often use tokens that validate user requests. These tokens ensure that the incoming request originates from the application’s form.

In PHP, CSRF protection can be manually implemented by generating a token and including it in the form as a hidden input. This token is then validated upon form submission. This concept is similar to Python Flask’s {% csrf_token %} tag.

Example of generating a CSRF token in PHP:

session_start();

if (empty($_SESSION['csrf_token'])) {

$_SESSION['csrf_token'] = bin2hex(random_bytes(32));

}

Including the CSRF token in a form:

echo '<form method="post">';

echo '<input type="hidden" name="csrf_token" value="' . $_SESSION['csrf_token'] . '">';

// form fields here echo

'</form>';

Validating the CSRF token upon form submission:

if ($_POST['csrf_token'] === $_SESSION['csrf_token']) {

// Process form

}

else {

// Invalid CSRF token

}

Conclusion

Understanding the use of the $ symbol, managing URL parameters, and implementing CSRF protection are crucial components of PHP web development. By grasively these concepts, developers can enhance both the functionality and security of their web applications. Similar to practices in other frameworks like Flask, CSRF protection in PHP safeguards applications against unauthorized actions, ensuring a trustworthy environment for users to interact with.

© 2024 Kvnbbg.fr

Theme by Anders Norén — Up ↑

Verified by MonsterInsights