Forem: Salma

Laravel Blueprint To built fast laravel app

Salma — Fri, 24 Jan 2025 17:44:07 +0000

Hey developers! Today, I want to share a personal story about how Laravel's Blueprint significantly streamlined my development process, especially when it came to handling migrations, models, and factories. It's a game-changer, and here's why.

Rapid Database Setup with Migrations
Blueprint in Laravel isn't just about creating tables; it's about setting up your entire database environment swiftly and efficiently. With a few lines of code, I was able to define my tables, columns, and relationships. No more manual SQL! Here’s a quick snippet:

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->decimal('price', 8, 2);
    $table->timestamps();
});

Effortless Model Creation
Once the migrations were in place, setting up Eloquent models was straightforward. Laravel's artisan command php artisan make:model Product instantly created a model based on my migration. This tight integration ensures consistency across your database and application logic.

Run and Relax
With all pieces in place – migrations, models, and factories – deploying changes and testing them became a matter of running a few commands. php artisan migrate, php artisan db:seed, and I was ready to test my application with a rich, well-structured database.

Absolutely! If you're starting a new project in Laravel and want to leverage Blueprint to streamline your development process, here's a step-by-step guide to get you up and running:

Step 1: Install Laravel

First, you need to create a new Laravel project. If you haven't already, you can do this using Composer:

composer create-project --prefer-dist laravel/laravel your-project-name

Navigate into your project directory:

cd your-project-name

Step 2: Set Up Your Database

Before you start using Blueprint, make sure your database is configured. Open the .env file in your project root and update the database configuration settings:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=your_database_name
DB_USERNAME=your_database_user
DB_PASSWORD=your_database_password

Step 3: Install Blueprint

Blueprint is a package that helps you generate migrations, models, controllers, and more from a single configuration file. You can install it via Composer:

composer require --dev laravel-shift/blueprint

Step 4: Create a Blueprint Configuration File

Blueprint uses a draft.yaml file to define your database schema and other configurations. Create this file in the root of your project:

touch draft.yaml

Step 5: Define Your Schema in `draft.yaml`

Open the draft.yaml file and define your database schema. Here’s an example of how you might define a products table:

models:
  Product:
    name: string
    price: decimal:8,2
    timestamps: ~

controllers:
  Product:
    resource: web

This configuration will generate a migration, model, and controller for the Product entity.

Step 6: Generate Migrations, Models, and Controllers

Once your draft.yaml file is ready, you can use Blueprint to generate the necessary files. Run the following command:

php artisan blueprint:build

This command will generate:

A migration file for the products table.
An Eloquent model for the Product entity.
A controller for handling web requests related to products.

Step 7: Run Migrations

Now that your migration files are generated, you can run them to create the tables in your database:

php artisan migrate

Step 8: Seed Your Database (Optional)

If you want to populate your database with test data, you can create seeders. Blueprint can also help with this. Add seeders to your draft.yaml:

seeders:
  Product:
    - name: 'Sample Product'
      price: 19.99

Then, generate the seeder:

php artisan blueprint:build

Finally, run the seeder:

php artisan db:seed

Step 9: Test Your Application

With everything set up, you can now test your application. Start the Laravel development server:

php artisan serve

Visit your application in the browser and verify that everything is working as expected.

Step 10: Iterate and Expand

As your project grows, you can continue to update your draft.yaml file and use Blueprint to generate new migrations, models, controllers, and more. This iterative process ensures that your database and application logic remain consistent and up-to-date.

Conclusion
Blueprint has transformed my Laravel development process. It's not just about building things right; it's about building them fast and with precision. Whether you're setting up a new project or maintaining an existing one, integrating migrations, models, and factories via Blueprint can save hours of work and potential headaches.

If you've been manually handling database changes or struggling with data consistency, give Blueprint a try – it might just change your development life!

MySQL: Using and Enhancing `DATETIME` and `TIMESTAMP`

Salma — Wed, 19 Jun 2024 18:48:49 +0000

Introduction

In MySQL, DATETIME and TIMESTAMP are commonly used data types for storing temporal values. Although both serve the purpose of storing date and time, there are fundamental differences between them that affect their usage. This article will explore the differences between DATETIME and TIMESTAMP, and how to overcome some limitations of DATETIME to leverage the advantages of TIMESTAMP.

Differences Between `DATETIME` and `TIMESTAMP`

Range:

DATETIME: Can store values from '1000-01-01 00:00:00' to '9999-12-31 23:59:59'.
TIMESTAMP: Can store values from '1970-01-01 00:00:01' to '2038-01-19 03:14:07'.

Storage:

DATETIME: Stored as is, in date and time format, without relying on the time zone. It requires 8 bytes of storage.
TIMESTAMP: Stored as an integer representing the number of seconds since 1970-01-01 00:00:00 UTC. It requires 4 bytes of storage.

Time Zone:

DATETIME: Does not depend on the time zone and stores the value as is.
TIMESTAMP: Affected by the current time zone of the MySQL server. When inserting or retrieving values, they are automatically converted between the local time and UTC.

Automatic Updates:

DATETIME: Does not support automatic updates directly when a row is modified.
TIMESTAMP: Can be set to automatically update the value when a row is modified using the options DEFAULT CURRENT_TIMESTAMP and ON UPDATE CURRENT_TIMESTAMP.

Enhancing `DATETIME` Usage

To overcome some limitations of the DATETIME data type, you can follow these strategies:

1. Standardizing Time Zone

To solve the issue of DATETIME not adhering to the time zone, you can standardize all temporal operations at the database and application level to use UTC.

Setting the Database to Work in UTC:

SET GLOBAL time_zone = '+00:00';
SET time_zone = '+00:00';

Converting Values to UTC on Insertion:

INSERT INTO example_table (event_time) VALUES (CONVERT_TZ('2024-06-19 12:30:00', 'Your/Timezone', '+00:00'));

Converting Values from UTC to Local Time on Retrieval:

SELECT CONVERT_TZ(event_time, '+00:00', 'Your/Timezone') as local_event_time FROM example_table;

2. Automatic Updates

To automatically update DATETIME values when a row is modified, you can use triggers.

Creating a Trigger to Update the Field on Modification:

CREATE TRIGGER before_update_example_table
BEFORE UPDATE ON example_table
FOR EACH ROW
BEGIN
  SET NEW.updated_at = NOW();
END;

3. Using Default Values

To set DATETIME values automatically on insertion, you can assign default values using the NOW() function.

Setting Default Fields:

CREATE TABLE example_table (
    id INT PRIMARY KEY AUTO_INCREMENT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

4. Handling Precision

If higher precision for times is needed, you can use DATETIME(6) or TIMESTAMP(6) to store times up to microsecond precision.

Creating a Table with Microsecond Precision:

CREATE TABLE example_table (
    id INT PRIMARY KEY AUTO_INCREMENT,
    created_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6),
    updated_at DATETIME(6) DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6)
);

5. Handling Times in the Application

Ensure your application handles times correctly by converting all times to UTC before storing them and converting them back to local time when displaying them to the user.

Example in PHP:

// Setting the application time zone to UTC
date_default_timezone_set('UTC');

// Storing the current time as UTC
$current_time_utc = date('Y-m-d H:i:s');
$query = "INSERT INTO example_table (event_time) VALUES ('$current_time_utc')";

// Retrieving the time and converting it to local time
$event_time_utc = '2024-06-19 12:30:00';
$event_time_local = new DateTime($event_time_utc, new DateTimeZone('UTC'));
$event_time_local->setTimezone(new DateTimeZone('Your/Timezone'));
echo $event_time_local->format('Y-m-d H:i:s');

Summary

DATETIME: Used for storing dates and times without time zone dependencies. Suitable for future events or fixed scheduling.
TIMESTAMP: Used for tracking time relative to the current time zone. Suitable for logging the time when data is inserted or updated.

Enhancing `DATETIME`

Standardizing Time Zone: Use UTC to standardize times.
Automatic Updates: Use triggers to update fields automatically.
Default Values: Set default values for the DATETIME field.
Precision: Use DATETIME(6) for higher precision.
Handling Times in the Application: Correctly convert times between UTC and local time.

By following these strategies, you can leverage the benefits of TIMESTAMP while using DATETIME, making it easier to handle temporal values efficiently and effectively.

What I Should know About Logging In PHP

Salma — Sat, 23 Mar 2024 13:17:18 +0000

To effectively utilize PHP logging, there are several key concepts and practices you should be familiar with. These include understanding the purpose of logging, knowing the different logging levels, understanding how to configure and use PHP's built-in logging functions, and being aware of popular logging libraries like Monolog. Here's a breakdown of what you should know:

1. Purpose of Logging

Debugging: Logging helps in identifying and fixing bugs by recording events that happen during the execution of a program.
Monitoring: It allows you to monitor the performance and behavior of your application in real time.
Audit Trails: Logs can serve as a record of what happened, when, and in what order.

2. Logging Levels

Different Severities: PHP supports various error levels, from E_ERROR (fatal run-time errors) to E_NOTICE (non-critical errors), E_WARNING (run-time warnings), and others.
Custom Error Levels: You can also define custom error levels using E_USER_* constants.

3. Built-in PHP Logging Functions

error_log(): The primary function to log errors. It can send errors to the server's error log, a custom file, or a remote destination.
trigger_error(): Useful for generating user-level error messages, allowing you to specify an error level.
syslog(): For sending messages to the system logger.

4. PHP Configuration for Logging

php.ini Settings: PHP's behavior with errors and logging is configured in the php.ini file. Key settings include error_reporting, display_errors, log_errors, and error_log.
Dynamic Configuration: You can also set error reporting levels dynamically using the error_reporting() function in your scripts.

5. Logging Best Practices

Granular Control: Use different logging levels to control the granularity of the information logged.
Sensitive Data: Be cautious not to log sensitive information such as passwords or personal data.
Performance: Excessive logging can impact performance; ensure logging is appropriately balanced.

6. Using Logging Libraries (like Monolog)

Monolog: A popular PHP logging library that offers advanced features like multiple handlers (e.g., to send logs to files, sockets, inboxes, databases, etc.) and processors.
Integration: Monolog can be easily integrated with various PHP frameworks, including Laravel and Symfony.

7. Logging in Different Environments

Development vs. Production: In a development environment, you might want more verbose logging, while in production, you would typically restrict this to critical errors only.

8. Analyzing and Managing Logs

Log Analysis: Regularly analyze logs for any signs of errors or unusual activity.
Log Rotation: Implement log rotation to manage log file sizes and archival.

9. Security Considerations

Access Control: Ensure logs are securely stored and only accessible to authorized personnel.
Error Disclosure: Be cautious about revealing too much information in error messages that could be seen by end users.

By understanding these aspects of PHP logging, you can more effectively monitor and troubleshoot your PHP applications, leading to improved reliability and performance.

How Tables and indexes stored on Disk

Salma — Mon, 04 Mar 2024 18:11:01 +0000

Introduction

This article delves into the structured manner in which tables and indexes are stored on disks in database systems. This understanding is pivotal for database optimization, impacting the efficiency of data access and manipulation.

Tables Storage

Data Pages

Definition: Tables are stored in units known as "data pages" or "blocks."
Content: Each page typically holds a fixed number of rows. The exact number depends on the row size and page size, which is often 4 KB or 8 KB.
Organization: These pages are systematically arranged into a file or a set of files on the disk.

Example:

Consider a table with rows of 1 KB each. On a 4 KB page, up to four rows can be stored. If the table has 1000 rows, it would occupy at least 250 pages.

Row Format

Storage Types: Rows can be stored in fixed-length or variable-length formats.
Detail: Each row consists of its column values.

Table Metadata

Information Stored: Details about the table structure, including column names, data types, and constraints.
Location: This information is usually stored in a system catalog or a metadata table.

File Organization

Types:
1. Heap: An unordered storage of rows.
2. Clustered Index: Rows are stored in the order of the primary key.
3. Partitioned: The table is divided into smaller, more manageable segments.

Indexes Storage

B-tree Indexes

Structure: A balanced tree consisting of root, internal, and leaf nodes.
Function: Leaf nodes contain index entries with a key value and a pointer to the corresponding row.
Commonality: This is the most commonly used index structure.

Bitmap Indexes

Mechanism: Uses a bitmap for each key to indicate the presence or absence of a value.
Efficiency: Particularly effective for columns with a low number of distinct values.

Hash Indexes

Function: Utilizes a hash function to create a hash value for each key.
Purpose: These hash values facilitate quick data location during searches.

Index Metadata

Content: Information about the index, like indexed columns and index type.
Storage: Stored in the system catalog, similar to table metadata.

Storage

Separation: Indexes are stored separately from the table data.
Extent: They may cover multiple pages and files, varying in size.

Physical Storage

Disk Files

Medium: Both tables and indexes are stored as files on the disk.

File System or Raw Devices

Management: These files might be managed by the file system or stored on raw devices, depending on the DBMS.

I/O Operations

DBMS Role: The DBMS handles read/write operations, focusing on minimizing disk I/O, caching, and maintaining ACID properties.

Conclusion

Understanding the storage mechanisms of tables and indexes on disk is critical for optimizing database performance. This knowledge aids in making informed decisions about data organization and access strategies.

Beyond the Basics: Leveraging ACID for Advanced Database Management

Salma — Sat, 24 Feb 2024 15:01:52 +0000

In the heart of every database lies a set of principles known as ACID. These principles, standing for Atomicity, Consistency, Isolation, and Durability, act as the guardians of data integrity and reliability, ensuring that your transactions are executed seamlessly and accurately. Whether it's a financial transfer, an online purchase, or a simple data update, ACID ensures the smooth flow of information while safeguarding its consistency and security.

Atomicity: All or Nothing

Imagine transferring funds between accounts. ACID's atomicity principle dictates that either the entire transaction (debiting one account and crediting another) happens successfully, or none of it does. This prevents incomplete transactions and ensures data consistency.

Consistency: Maintaining Harmony

Think of a database as a symphony. ACID's consistency principle ensures that the data within the database adheres to its predefined rules and constraints before and after each transaction. This keeps the information accurate and reliable, like a well-tuned orchestra playing in perfect harmony.

Isolation: No Interference Allowed

Imagine two users simultaneously editing the same document. ACID's isolation principle guarantees that each user operates in their own independent space, unaffected by the other's actions. This prevents conflicting changes and maintains data integrity.

Durability: The Imprint of Change

Picture a power outage during a crucial transaction. ACID's durability principle ensures that even in case of system failures, the changes made to the database are permanently recorded. This protects valuable data from being lost in the digital ether.

Why ACID Matters:

ACID principles are the foundation of secure and reliable database systems. They guarantee:

Data Integrity: Eliminates inconsistencies and corruption, ensuring accurate information.

Transaction Reliability: Ensures transactions are completed successfully or not at all, preventing data loss.

System Resilience: Protects data from system failures and ensures its continued availability.

Applications of ACID:

ACID plays a vital role in various applications, including:

Financial Transactions: Guaranteeing secure and accurate money transfers.
Inventory Management: Maintaining accurate stock levels and preventing overselling.
E-commerce Platforms: Ensuring smooth and reliable online purchases.

Conclusion:

ACID principles are the unsung heroes of the database world, silently ensuring the integrity and reliability of your data. By understanding these principles, you gain a deeper appreciation for the intricate mechanisms safeguarding the valuable information at the heart of your digital systems.

Navigating Web Server Technologies: Apache, Nginx

Salma — Wed, 21 Feb 2024 20:21:56 +0000

Understanding Web Server Technologies: A Developer's Guide to Apache, Nginx, and Hosting Solutions

Web server technologies are a cornerstone of web development and understanding them is crucial for developers. This guide explores Apache, Nginx, and various hosting options, providing insights that can help developers make informed decisions.

Web Servers Demystified

Web servers are essential for serving web content over the internet. They handle requests from clients, typically web browsers, and deliver content like HTML, images, and files. Key players in this domain include Apache HTTP Server, Nginx, Microsoft IIS, LiteSpeed, Apache Tomcat, and Node.js.

Selecting a Web Server for PHP Laravel

For PHP Laravel applications, Apache and Nginx stand out. Apache offers ease of configuration and is widely supported, making it a favorite for PHP applications. Nginx is ideal for handling high traffic efficiently but requires PHP-FPM for processing PHP scripts.

Web Server Setup on Mac and Windows

For Mac Users:

Built-in Apache Server: A convenient option for PHP projects.
MAMP: User-friendly with Apache, MySQL, and PHP.
Docker: Ideal for creating isolated environments.
Homebrew: Offers flexibility in installing various web servers.
Valet: Specifically designed for Laravel development.
XAMPP: A cross-platform solution for a local server environment.

For Windows Users:

XAMPP and WAMP: Simple setups for Apache, MySQL, and PHP.
MAMP: A straightforward, cross-platform option.
Docker: For advanced, customizable environments.
IIS: Windows’ native web server.
Laragon and Homestead: Excellent for Laravel development.

Learning Apache and Nginx in Detail

Mastering Apache:

Official Documentation: Start with Apache's comprehensive guides.
Online Resources: Utilize tutorials and courses for practical learning.
Books: Dive deep with resources like "Apache Cookbook."
Practice: Set up and experiment with Apache locally.
Community Engagement: Join forums and discussions for real-world insights.

Understanding Nginx:

Official Documentation: Essential for foundational knowledge.
Online Learning: Explore tutorials and courses.
Hands-On Experience: Practice with a local Nginx setup.
Stay Informed: Follow blogs and articles for advanced tips.

Tips for Both:

Project-Based Learning: Implement your skills in real projects.
Networking Basics: Complement your knowledge with networking fundamentals.
Continuous Learning: Stay updated with the latest developments.

Conclusion

This guide provides a comprehensive overview of web server technologies, focusing on Apache, Nginx, and hosting platforms. The journey in mastering these technologies lies in balancing theoretical knowledge with practical application, and adapting to the evolving web landscape. Whether you're setting up a server, choosing a hosting solution, or diving deep into server configurations, this guide aims to empower developers with the knowledge to make informed decisions.

Understanding Laravel Collections: `reject` vs. `map`

Salma — Sun, 10 Dec 2023 13:31:36 +0000

*Laravel Collections * provide a powerful and expressive way to work with arrays or sets of data. In this post, we'll explore two fundamental functions: reject and map. While both are essential tools in your Laravel toolkit, they serve distinct purposes in data manipulation.

The `reject` Function:

The reject function is your go-to tool for filtering out items from a collection based on a specified condition. It creates a new collection that excludes items for which the callback returns true. Let's look at an example:

$collection = collect([1, 2, 3, 4, 5]);

$filtered = $collection->reject(function ($item) {
    return $item % 2 == 0; // Exclude even numbers
});

dd($filtered->all()); // Output: [1, 3, 5]

In this example, we use reject to create a new collection that excludes even numbers from the original collection.

The `map` Function:

On the flip side, the map function is your ally when you need to transform each item in a collection using a callback. It creates a new collection with the results of applying the callback to each item. Here's an illustration:

$collection = collect([1, 2, 3, 4, 5]);

$squared = $collection->map(function ($item) {
    return $item * $item; // Square each number
});

dd($squared->all()); // Output: [1, 4, 9, 16, 25]

In this example, we use map to create a new collection where each item is squared.

Key Differences:

Purpose:
- reject: Filters items based on a condition, excluding items that satisfy it.
- map: Transforms items based on a callback, creating a new collection with the transformed values.
Result:
- reject: Returns a new collection with items that did not meet the specified condition.
- map: Returns a new collection with items transformed according to the provided callback.
Callback Return Value:
- reject: Includes items for which the callback returns false.
- map: Includes the results of applying the callback to each item.

In summary, while reject is your tool for excluding items, map is your friend for transforming them. Choose the right function based on your data manipulation needs.

Happy coding! 🚀

Breaking Down SQL Syntax Guide to Using Quotes

Salma — Sun, 12 Nov 2023 19:56:03 +0000

In SQL, the use of quotes can vary based on the context and the specific SQL database system you are using. Here's a general guideline:

Double Quotes ("): Typically used to enclose identifiers like table and column names. They are necessary if the identifier is a reserved keyword or contains special characters or spaces. For instance, "Customers" or "Order ID". However, not all SQL databases require or allow double quotes for identifiers. For example, MySQL often uses backticks (`) instead of double quotes for this purpose.
Single Quotes ('): Used for enclosing string literals, such as values you might insert into a table. For example, in a query like INSERT INTO Customers (Name) VALUES ('John Doe');, 'John Doe' is a string literal.
Backticks (`): Primarily used in MySQL to enclose table or column names. They serve a similar purpose to double quotes in other SQL databases.
No Quotes: If your identifiers (like table or column names) do not contain special characters, spaces, or are not reserved keywords, you often don't need to use any quotes. For example, SELECT * FROM Customers is perfectly valid if "Customers" is a simple, non-reserved identifier.

Here are some examples to illustrate the use of quotes in SQL queries across different scenarios and database systems:

1. Using Double Quotes for Identifiers

PostgreSQL / Standard SQL

  SELECT "name", "age" FROM "Users";

In this case, "name" and "age" might be the column names and "Users" the table name. Double quotes are used because PostgreSQL adheres closely to the SQL standard, which recommends double quotes for identifiers.

2. Using Single Quotes for String Literals

General Example (Applicable to Most SQL Databases)

  INSERT INTO Customers (Name, City) VALUES ('John Doe', 'New York');

Here, 'John Doe' and 'New York' are string literals representing values to be inserted into the columns Name and City of the Customers table.

3. Using Backticks for Identifiers (MySQL Specific)

MySQL

  SELECT `name`, `age` FROM `Users`;

MySQL uses backticks to quote identifiers like table and column names. This is particularly useful if the identifier names are also reserved keywords or if they contain special characters.

4. No Quotes for Simple Identifiers

General Example

  SELECT name, age FROM Users;

If the table and column names don’t contain any special characters, spaces, or aren’t reserved keywords, you can use them without any quotes.

5. Mixed Usage

General Example

  SELECT "Employee Name", age FROM Employees WHERE "Employee Name" = 'John Doe';

In this query, "Employee Name" (an identifier) uses double quotes because it contains a space, while 'John Doe' (a string literal) uses single quotes.

Always remember to check the documentation for the specific SQL database you are using, as these conventions can vary. For example, what works in PostgreSQL might not work exactly the same way in MySQL or Microsoft SQL Server.

Decoding PHP's Empty Value Functions: When to Use Which

Salma — Tue, 07 Nov 2023 18:32:46 +0000

In PHP, checking for empty values is a common operation, and there are several ways to do this. Understanding the differences between using !, is_null(), and isset() is important, as they each check for different conditions:

Using `!` (Not Operator)

The not operator ! is used to check if a value is false. In PHP, several types of values are considered as "falsy" when used in a boolean context:

The boolean false itself
The integer 0
The float 0.0
The empty string '' and the string "0"
An array with zero elements
The special type NULL
SimpleXML objects created from empty tags

Example:

$value = '';
if (!$value) {
    echo 'The value is considered empty.';
}
// This will output: The value is considered empty.

Using `is_null()`

The is_null() function checks if a variable is exactly NULL. It does not check for any other "empty" values like '' (empty string) or 0 (zero as an integer or float), it only returns true if the variable is NULL.

Example:

$value = NULL;
if (is_null($value)) {
    echo 'The value is NULL.';
}
// This will output: The value is NULL.

Using `isset()`

The isset() function checks if a variable is set and is not NULL. If a variable has been unset using unset(), has not been assigned a value, or is assigned the value NULL, then isset() will return false. It is often used to check if array keys or object properties exist and are not NULL.

Example:

$value = NULL;
if (isset($value)) {
    echo 'This will not be printed.';
} else {
    echo 'The variable is not set or is NULL.';
}
// This will output: The variable is not set or is NULL.

isset() also returns true for variables set to any value other than NULL, including false, 0, or an empty string ''. However, isset() can be used to check for the existence of a variable while is_null() and the not operator can only be used on variables that are already set.
The empty() function in PHP is used to determine whether a variable is considered to be empty. A variable is considered empty if it does not exist or if its value is one of the following:

"" (an empty string)
0 (0 as an integer)
0.0 (0 as a float)
"0" (0 as a string)
null
false
An array with zero elements

It's important to note that empty() is a bit more comprehensive in its checks compared to using the ! operator. While the ! operator will return true for any falsy value, empty() will also return true for unset variables (variables that have not been declared), which the ! operator will not do, since using ! on an unset variable will raise a notice.

Here's an example illustrating the use of empty():

$value = 0;

if (empty($value)) {
    echo 'The value is considered empty by empty().';
}
// This will output: The value is considered empty by empty().

if (!$value) {
    echo 'The value is considered empty by ! operator.';
}
// This will also output: The value is considered empty by ! operator.

It's important to use empty() when you expect the variable might not be set at all, as it won't generate a warning or notice, whereas ! will if you use it on a variable that hasn't been declared.

empty() is particularly useful when you need to check for the presence and non-empty value of a variable (like user input or a potentially missing array key) in a single operation.

Here's a comparison example with isset():

$value = "";

// This will return true because $value is an empty string.
if (empty($value)) {
    echo 'The value is empty.';
}

// This will return false because $value is set.
if (!isset($value)) {
    echo 'The variable is not set.';
} else {
    echo 'The variable is set.';
}

In the above example, even though $value is an empty string and considered "empty", it is still set, so isset() will return true.

More Examples :

**
Here are four examples each for empty(), ! (Not operator), is_null(), and isset():

`empty()`

// Example 1: Variable is an empty string
$var1 = "";
echo empty($var1) ? 'empty' : 'not empty'; // Outputs 'empty'

// Example 2: Variable is zero as an integer
$var2 = 0;
echo empty($var2) ? 'empty' : 'not empty'; // Outputs 'empty'

// Example 3: Variable is false
$var3 = false;
echo empty($var3) ? 'empty' : 'not empty'; // Outputs 'empty'

// Example 4: Variable is an empty array
$var4 = array();
echo empty($var4) ? 'empty' : 'not empty'; // Outputs 'empty'

`!` (Not operator)

// Example 1: Variable is an empty string
$var1 = "";
echo !$var1 ? 'true' : 'false'; // Outputs 'true'

// Example 2: Variable is zero as an integer
$var2 = 0;
echo !$var2 ? 'true' : 'false'; // Outputs 'true'

// Example 3: Variable is false
$var3 = false;
echo !$var3 ? 'true' : 'false'; // Outputs 'true'

// Example 4: Variable is null
$var4 = null;
echo !$var4 ? 'true' : 'false'; // Outputs 'true'

`is_null()`

// Example 1: Variable is explicitly set to null
$var1 = null;
echo is_null($var1) ? 'null' : 'not null'; // Outputs 'null'

// Example 2: Variable has not been set at all
unset($var2); // Assuming $var2 was set before
echo is_null($var2) ? 'null' : 'not null'; // Outputs 'null'

// Example 3: Variable is an empty string (not null)
$var3 = "";
echo is_null($var3) ? 'null' : 'not null'; // Outputs 'not null'

// Example 4: Variable is zero (not null)
$var4 = 0;
echo is_null($var4) ? 'null' : 'not null'; // Outputs 'not null'

`isset()`

// Example 1: Variable is set to non-null value
$var1 = "Hello, World!";
echo isset($var1) ? 'set' : 'not set'; // Outputs 'set'

// Example 2: Variable is set to null (therefore not set)
$var2 = null;
echo isset($var2) ? 'set' : 'not set'; // Outputs 'not set'

// Example 3: Variable is set to an empty array
$var3 = array();
echo isset($var3) ? 'set' : 'not set'; // Outputs 'set'

// Example 4: Variable has not been set at all
echo isset($var4) ? 'set' : 'not set'; // Outputs 'not set'

In summary:
Each function has its specific use case: empty() checks if the variable is considered "empty" in a broader sense; ! checks for "falsey" values; is_null() checks if the variable is null; and isset() checks if a variable is set and not null.

Docker , Docker Compose Docker Swarm Vs Kubernetes

Salma — Sun, 25 Dec 2022 20:51:41 +0000

Docker is the core technology used for containers and can deploy single containerized applications.

When do we use docker ?

when you want to deploy a single (network accessible) container.

Docker Compose is used for configuring and starting multiple Docker containers on the same host a single host machine.
so you don't have to start each container separately.

And Used for running multiple containers as a single service. Each Of the containers here run in isolation but can interact with each other when required.

When do we use docker compose?

when you want to deploy multiple containers to a single host from within a single YAML .

Docker swarm is a container orchestration tool that allows you to run and connect containers on multiple hosts.

Docker swarm can do tasks like :

Scaling
Start a new container when one crashes
Networking containers and many more

When do we use docker swarm ?

when you want to deploy a cluster of docker nodes (multiple hosts for a simple , scalable application

Kubernetes known as "K8s" is a container orchestration tool that is similar to Docker swarm, but has a wider appeal due to its ease of automation and ability to handle higher demand.

And Also our usual question

When do we use Kubernetes ?

when you need to manage a large deployment of scalable , automated containers.

In The end, it is just a definition for beginners and when u want to make a quick review before the interview hope it is useful!

Wait for me for new Posts

VS Code Extensions for PHP Laravel Developer

Salma — Sat, 16 Apr 2022 04:02:18 +0000

Hola Developers !

VS code is the free alternative to *phpstorm * and there is more than one extension that facilitates the code process and is characterized by being light, fast and flexible

Laravel Blade Snippet

Laravel blade snippets and syntax highlight support for Visual Studio Code.

Laravel Snippets

Laravel snippets extension for Visual Studio Code (Support Laravel 5 and above version).

Laravel goto view

Click into to the name of the view in the controller

Laravel Extra Intellisense

This extension provides Laravel routes, views and ... autocomplete for VSCode.

Laravel Model Snippets

Improve your workflow with Laravel Model Snippets. Start with Model:: then the shortcut of what you are looking for within your model.

For example, Model::d will return the muted dates attribute:

PHP Intelephense

PHP code intelligence for Visual Studio Code.

Intelephense is a high performance PHP language server packed full of essential features for productive PHP development.

PHP Namespace Resolver

PHP Namespace Resolver can import and expand your class. You can also sort your imported classes by line length or in alphabetical order.

PHP Constructor

PHP Constructor can initialize constructor properties like insert_php_constructor_property command of SublimePHPCompanion.

Tools To front end what interact with php laravel :

Vetur

Vue tooling for VS Code.

Tailwind CSS IntelliSense Preview

Intelligent Tailwind CSS tooling for VS Code

Extension to make our code more beautiful and easier :

Rainbow Brackets

Provide rainbow colors for the round brackets, the square brackets and the squiggly brackets. This is particularly useful for Lisp or Clojure programmers, and of course, JavaScript, and other programmers.

Auto Close Tag

Automatically add HTML/XML close tag, same as Visual Studio IDE or Sublime Text does.

Nice Themes !

Aura Theme

A beautiful dark theme with four variants for Visual Studio Code. Two of these variants are focused on long-term work without
causing any discomfort to the eyes.

In the end, I gave all the additions I know and considered useful. If there is more, you can add them in the comments. Thank you

Laravel With dynamic columns Translatable and Multi Lang in slug

Salma — Fri, 04 Feb 2022 01:30:23 +0000

Aloha There !

in this tutorial
Use this package to make transtable columns dynamic and make slug transtable because it so useful in SEO
We are using this two packages :

This package provides to us To make the column contain many lang without need to make 3 or 4 columns to one lang
as example If we have title in arabic , english and Spanish
we will have
title_ar
title_en
title_es
another columns if we make have column called description
it is not good to performance , more data in db and not perfectly when get data

install this package with this
composer require spatie/laravel-translatable
If you want to have another fallback_locale than the app fallback locale (see config/app.php), you could publish the config file:

php artisan vendor:publish --provider="Spatie\Translatable\TranslatableServiceProvider"

in our modal add this trait
use HasTranslations;
then make install to sluggable package
from there
composer require spatie/laravel-sluggable

and add this trait in modal

HasTranslatableSlug

and put every column who have translate in this variable in this like it

public $translatable = ['name', 'slug'];

Add This function in modal
this function create slug and when we reterive the slug with two langague
put
usingLanguage(false)

/**
     * Get the options for generating the slug.
     */
    public function getSlugOptions() : SlugOptions
    {
        return SlugOptions::createWithLocales(['en', 'ar'])
            ->generateSlugsFrom(function($model, $locale) {
                return "{$model->name}";
            })
            ->saveSlugsTo('slug')
            ->usingLanguage(false);
    }

*the final view for modal
*

in the migration we create the column in this way
$table->json('name'); $table->json('slug');
*in create form
*

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<a href="{{route('posts.create')}}">Create</a>
<form action="{{route('posts.store')}}" method="post">
    @csrf
    <input type="text" name="name[ar]">
    <input type="text" name="name[en]">

    <input type="submit" value="Save">
</form>

</body>
</html>

*in web.php
*

Route::group(['prefix' => LaravelLocalization::setLocale()], function()
{
    Route::get('/', function () {
        return view('welcome');
    });

       Route::resource('/posts',PostController::class)->except('delete','update');

});

*in Post Controller
*

/**
     * 
     * Get All posts
     * @return \Illuminate\Contracts\Foundation\Application|\Illuminate\Contracts\View\Factory|\Illuminate\Contracts\View\View
     */
    public function index()
    {
        $posts = Post::all();
        return view('index', compact('posts'));
    }


    /**
     * Create new post 
     * 
     * @return \Illuminate\Contracts\Foundation\Application|\Illuminate\Contracts\View\Factory|\Illuminate\Contracts\View\View
     */
    public function create()
    {
        return view('create');
    }

    /**
     * Store new post 
     * 
     * @param Request $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function store(Request $request)
    {
        $post = Post::create($request->all());
        return redirect()->route('posts.index');
    }

    /**
     * Show post
     * @param $slug
     * @return \Illuminate\Http\JsonResponse
     */
    public function show($slug)
    {
        $post = Post::where('slug','like','%"'.$slug.'"%')->first();
        return response()->json($post);
    }

You Can see all of this code in this repo
https://github.com/salmazz/Multi-Langague-Example-Laravel-

If u have any question please contact to me !
hope it will be useful thank u

Forem: Salma

Laravel Blueprint To built fast laravel app

Step 1: Install Laravel

Step 2: Set Up Your Database

Step 3: Install Blueprint

Step 4: Create a Blueprint Configuration File

Step 5: Define Your Schema in draft.yaml

Step 6: Generate Migrations, Models, and Controllers

Step 7: Run Migrations

Step 8: Seed Your Database (Optional)

Step 9: Test Your Application

Step 10: Iterate and Expand

MySQL: Using and Enhancing `DATETIME` and `TIMESTAMP`

Introduction

Differences Between DATETIME and TIMESTAMP

Range:

Storage:

Time Zone:

Automatic Updates:

Enhancing DATETIME Usage

1. Standardizing Time Zone

Setting the Database to Work in UTC:

Converting Values to UTC on Insertion:

Converting Values from UTC to Local Time on Retrieval:

2. Automatic Updates

Creating a Trigger to Update the Field on Modification:

3. Using Default Values

Setting Default Fields:

4. Handling Precision

Creating a Table with Microsecond Precision:

5. Handling Times in the Application

Example in PHP:

Summary

Enhancing DATETIME

What I Should know About Logging In PHP

1. Purpose of Logging

2. Logging Levels

3. Built-in PHP Logging Functions

4. PHP Configuration for Logging

5. Logging Best Practices

6. Using Logging Libraries (like Monolog)

7. Logging in Different Environments

8. Analyzing and Managing Logs

9. Security Considerations

How Tables and indexes stored on Disk

Introduction

Tables Storage

Data Pages

Example:

Row Format

Table Metadata

File Organization

Indexes Storage

B-tree Indexes

Bitmap Indexes

Hash Indexes

Index Metadata

Storage

Physical Storage

Disk Files

File System or Raw Devices

I/O Operations

Conclusion

Beyond the Basics: Leveraging ACID for Advanced Database Management

Atomicity: All or Nothing

Consistency: Maintaining Harmony

Isolation: No Interference Allowed

Durability: The Imprint of Change

Why ACID Matters:

Applications of ACID:

Conclusion:

Navigating Web Server Technologies: Apache, Nginx

Understanding Web Server Technologies: A Developer's Guide to Apache, Nginx, and Hosting Solutions

Web Servers Demystified

Selecting a Web Server for PHP Laravel

Web Server Setup on Mac and Windows

For Mac Users:

For Windows Users:

Learning Apache and Nginx in Detail

Mastering Apache:

Step 5: Define Your Schema in `draft.yaml`

Differences Between `DATETIME` and `TIMESTAMP`

Enhancing `DATETIME` Usage

Enhancing `DATETIME`

The `reject` Function:

The `map` Function:

Using `!` (Not Operator)

Using `is_null()`

Using `isset()`

`empty()`

`!` (Not operator)

`is_null()`

`isset()`