Conferences offer different session formats, such as lightning talks, workshops, panels, and full-length sessions. Organizers look for clear, relevant, and valuable topics for their audience. A strong proposal aligns with the event's topic and clearly demonstrates its significance to reviewers.

I have been selected to speak at conferences such as API World, API Specification Conference, PyCon Italia, and PHP Day Italy, and I co-organize API Conf Lagos. From both sides of the table, when submitting and reviewing CFPs, I have seen what works and what does not.

In this guide, I’d like to share what makes a good CFP and offer tips on creating a standout proposal. Whether you are submitting for the first time or looking to refine your approach, these insights will help you craft a compelling proposal that gets noticed.

In this article, you’ll learn the following:

• Understanding the CFP Criteria

• Key Components of a CFP Submission

• How to Choose the Right Topic

• How to Craft a Strong Title and Abstract

• How to Structure the Proposal

• Submission Best Practices

• Where to Find CFP Opportunities

Understanding the CFP Criteria

CFP requirements vary from conference to conference, so understanding the specific criteria before submitting your application is crucial to increasing your chances of selection. Most conferences provide a criteria page outlining key details. When you’re writing a CFP submission, some criteria are more crucial than others in shaping a strong proposal.

The most relevant criteria include:

• Topic – Areas of interest that the conference aims to cover.

• Session format and duration – This indicates the available sessions for the conference. It could be a session, workshop, or lightning talk, along with the time allocated.

• Audience expectations – This is used to gauge the audience's level of expertise (beginner, intermediate, advanced) and what attendees hope to gain from the event.

Keeping an eye on the core criteria, topic, audience, and format will help ensure your CFP submission aligns well with the conference expectations. And this can help increase your chances of acceptance.

While necessary for planning, other logistical aspects play a less direct role in crafting the proposal. These include:

• Speaker logistics and support – Information on travel, accommodation, and benefits for speakers, such as honorariums or reimbursements.

• Event fees and scholarships – Whether speakers receive free entry or if financial aid options are available.

• Code of conduct – The conference sets the ethical and behavioral guidelines for speakers and attendees.

• Conference duration – Whether the event lasts for one day, two days, or multiple days, which may affect scheduling and availability.

Elements of a CFP

Talk Title

First, you’ll need to decide on a clear, compelling title that makes it obvious what the talk is about in an easy-to-understand way. Clarity and simplicity always win.

You should avoid overly verbose or clickbait-style titles like: “Harnessing the Ultimate Power of Next-Gen APIs to Revolutionize Your Tech Stack”. Instead, you could say something friendlier and clearer: “How to Design Scalable APIs That Align With Your Product.”

Abstract

The abstract is a brief description of your talk. In this section, you should provide a summary that generally explains what your talk is about, how the audience would benefit from it, and why the conference organizers should value and select your talk.

It’s acceptable to discuss example scenarios you plan to cover and the tools or libraries you’ll be using, as this will help promote your idea more effectively than a simple sentence or two with no technical info.

Detailed Description/Proposal

I would like to note that not all conferences offer this section, but for those that do, it is a more in-depth and detailed explanation of your abstract, which sometimes can exceed 1000 words. This will enable you to explain the value, structure, areas of focus, and key takeaways of your talk.

In both the abstract and proposal, you should discuss the problems you’re addressing in your talk and what the audience stands to learn, which are both very important.

Speaker Bio

This is just as important as the talk title itself, as it informs the organizers about who you are, where you work, your relevant experience, and how the conference can benefit from having you at the event. Include a recent picture of yourself and, if possible, provide your social media profiles like LinkedIn, so they can connect with you.

Alright, now that you know the various parts involved in creating a CFP, let's look at each component in more detail – and how you can actually craft each part.

How to Choose the Right Topic

Most CFP pages showcase topics that interest conference organizers. As a prospective speaker, your goal is to select a topic that aligns with these subjects. You’ll also want to make sure that you have a deep enough knowledge on the topic you choose to speak and answer questions about it confidently.

For example, if a conference emphasizes specific topics such as PHP, Continuous Delivery, DevOps, Security, Testing, or APIs, proposals that align with those subjects are more likely to be accepted. Submitting a topic outside the listed themes the conference plans to cover may reduce your chances unless it provides exceptional value to the audience.

Here are some practical examples:

• If a conference is focused on DevOps, your proposal is more likely to be accepted if it covers continuous delivery pipelines, performance and monitoring, infrastructure automation, or incident response practices. Submitting a topic outside the listed subject, such as frontend design, may reduce your chances unless it offers exceptional value to the audience.

• If a conference is focused on APIs, your proposal is more likely to be accepted if it covers how to design versioned APIs, securing API endpoints with Authentication and Authorization, scaling API-first applications, compliance and governance, Api performance and observability, Api documentation, or managing third-party integrations.

• For a PHP conference, you should submit a proposal that cover performance improvements in PHP 8+, real-world security use cases in Laravel applications such as OWASP, PHP architecture patterns, scaling large PHP applications, writing extensions in PHP, highlighting important libraries you use daily, or guiding attendees on how to contribute to such PHP libraries.

When selecting your topics, ask yourself:

• What’s the value I’m bringing to attendees?

• Is the topic something I’m passionate about and knowledgeable about?

• Does it align with the needs and interests of the target audience?

To improve your chances, tailor your proposal to fit the conference’s focus. Pay close attention to the wording of your topic and ensure it directly connects with the event’s goals.

How to Craft a Strong Title and Abstract

Once you've chosen a relevant topic, you’ll need to create your talk title and abstract. For instance, you might focus on addressing security concerns using a particular programming language or tackle modern security challenges within a niche area.

It’s important to remember that while tools like AI models (for example, ChatGPT) can be helpful, relying too heavily on them to craft your title and abstract can work against you. The key is to use clear, simple language that speaks directly to your audience. Avoid overly technical jargon or convoluted phrasing, as this may hinder understanding.

Here are some key things to keep in mind when choosing a title and writing your abstract:

Select a Friendly Title

Your title is the first thing conference organizers see, and keeping it simple, engaging, and clear should be the goal.

Examples of strong titles might include:

• Moving Beyond CRUD: Designing More Scalable APIs with TDD

• How to Keep Your Application Secure with the Zero Trust Principle

• Why You Should Care About the Risk and Rewards of Feature Flags

• How to Orchestrate Effective Releases with CI/CD with Practical Tips for Teams

You may be wondering why these are examples of strong titles. Well, it’s because:

• They are clear and accessible, and at a glance, you already know what the topic is about. The topics are also approachable even if you’re not an expert.

• The topics also highlight values or possible outcomes: either the audience will learn about risk and rewards with feature flags, or they will equip themselves with knowledge of securing their applications using the Zero Trust principle, or learn how to design scalable APIs in a test-driven manner.

• The topic targets those directly involved in the software delivery lifecycle, including developers, DevOps engineers, engineering teams, and managers.

Writing a Compelling Abstract

When writing your abstract, it’s essential to provide a thorough overview of what your talk will cover. A one or two-sentence summary likely won’t be enough to give conference organizers the deeper insight they need into what your session offers.

Your abstract expands on the talk title, providing a more detailed description of the topic. This includes what your talk will cover (if it’s a workshop, mention the language or tools used, along with any expected outcomes or builds), the attendees who would benefit most from the talk, and possible learning outcomes.

Spending most of your time crafting your abstract is crucial to your talk getting accepted. From experience, here’s what a good abstract should include:

• Start with a sentence or two introducing the subject. So if you’re talking about the Zero-trust principle, explain what it means and discuss why it matters. Then talk about the problem it helps stakeholders involved in software delivery solve.

• Describe what the talk will cover. Mention tools, frameworks, or case studies you’ll use here to deliver the talk if selected. For example, “We’ll cover core concepts like 'Never trust, always verify,' least privilege, and continuous monitoring, along with practical steps such as using OAuth2, MFA, RBAC, JWTs, and encryption”.

• Explain who the target audience is. Are they beginners, intermediates, or experts? This will help organizers place your talk on the right track for the identified audience.

• End your abstract with 2-3 clear learning outcomes. What will attendees be able to do, understand, or think differently about after your session? For example, attendees will learn about Zero Trust architecture, enforcing strong authentication and authorization, as well as tools for continuous monitoring and auditing to detect threats.

Don’t rush through the process of writing your abstract. Allow yourself time to develop it gradually as ideas come to mind. It’s perfectly fine to keep your proposal open and pinned, updating and refining it over time. This approach will give you the bandwidth to ensure your abstract is clear, comprehensive, and engaging, ultimately leading to a stronger proposal.

Remember, your abstract should be written in simple, clear language and be free from grammatical errors. Keep in mind that some conferences have word limits for abstracts, so ensure your description fits these constraints.

How to Structure the Proposal

Once you’ve identified a topic and written the abstract, it’s crucial to structure your proposal in a way that is easy to read and provides clarity regarding your target audience and the learning outcomes. A well-structured proposal makes it easier for conference organizers to understand the value of your session and decide whether it’s a good fit.

To illustrate this, we’ll look at two proposal examples: one that can be improved and one with a strong structure that’s likely to be accepted.

❌ Weaker Proposal

Topic: Security in Software Development

Abstract:
Security in software development is important. This session will cover security practices and techniques in code.

Why this proposal is weak:

• The title is too vague and doesn’t specify the talk's focus.

• The abstract lacks depth and does not clearly describe what the attendees will learn.

• The audience is unclear, and no specific learning outcomes are mentioned.

✅ Strong Proposal

Topic: Building Secure Web Applications with Modern [Programming Language 1] Frameworks

Abstract:

It’s important to think security first when trying to build applications for the web, regardless of what programming language or framework you’re using. In today’s world, securing your application will protect you from data breaches, prevent fraudulent transactions, and help you avoid common vulnerabilities, ultimately improving the performance of your system.

In this talk, we will discuss the key security practices that developers should follow when building web applications with modern JavaScript frameworks, such as [Framework 1] and [Framework 2]. We’ll cover concepts such as input validation, securing APIs, handling authentication, and best practices to prevent common security vulnerabilities, including cross-site scripting (XSS) and SQL injection.

At the end of this session, developers will gain actionable insights on implementing security measures, explore common vulnerabilities, and build a demo app using [Framework 1] or [Framework 2] to address the security concept listed above, along with secure coding practices and tools to safeguard their apps.

This talk is designed for intermediate and advanced JavaScript developers who want to enhance the security of their web applications.

Why this proposal is strong:

• The title is clear and specific, highlighting the session's main focus.

• The abstract provides an introduction, a detailed description of the content that will be covered, ensuring organizers know exactly what to expect.

• The target audience is defined as "intermediate and advanced JavaScript developers."

• Learning outcomes are clearly outlined, including actionable takeaways and specific skills attendees will gain.

Here are two samples of my proposals that have been accepted in the past.

• PHPDAY ITALY ‘25: Securing PHP Applications with Zero Trust Principles

• API SPECIFICATION CONFERENCE ‘21: ABC of GRAPHQL

Submission Best Practices

Once you've completed your proposal, it's essential to take a step back and reflect on your topic and abstract. Review your submission carefully for any areas that need refining, check for typos, and ensure the message is clear and well-structured.

Sometimes, sharing your proposal with colleagues or peers for feedback can be invaluable. They might catch things you overlooked or offer suggestions to improve clarity or focus.

This reflection and review process acts as a safety net, ensuring you haven’t missed anything important before submitting. Keep in mind that conference organizers receive hundreds of CFPs, so taking the extra time to polish your submission can significantly improve your chances of standing out in a competitive pool.

The submission process typically looks like this:

1. Call for Paper (CFP) Announcement

The conference announces its call for papers (CFP) information, including details such as the deadline, topics, venue, session types, and submission guidelines.

2. Submission Platform

Conferences use tools like Typeform, Sessionize, Papercall, and even Google Docs, based on preference, and you’ll be asked to provide information about your talk proposal. This information includes:

• Talk title

• Abstract

• Talk format (Workshop, Session, Keynote)

• Target audience

• Speaker bio

• [Optional] Past speaking experience, like YouTube links to previous talks, and so on

Review Phase

After the CFP closes, panels begin reviewing submissions and deciding who will speak at the conference. They select speakers based on their own checklist and determine the lineup of speakers.

Notification and Follow-up

Successful speakers will receive congratulatory emails notifying them to confirm their participation in the conference and may need to submit additional information, such as a slide deck or session outline.

Speakers who don’t make the cut will typically get a rejection email, and often some organizers extend free or discounted event tickets to those speakers who have invested their time in submitting a proposal.

Conference schedule

Once selected, speakers will have their bio, talk title, and abstract published on the conference website. The schedule will also include the date, time, and room where each session will take place, helping attendees plan which talks to attend.

Where to Find CFP Opportunities

If you're looking for conferences to submit your proposal to, several platforms and resources regularly list open calls for papers (CFPs). Instead of waiting to stumble upon a CFP announcement, you can actively search for speaking opportunities that align with your expertise.

Popular CFP Platforms:

• Sessionize – A widely used platform where conferences post CFPs, allowing speakers to submit proposals easily.

• PaperCall.io – A hub for discovering CFPs across different industries, including tech and open-source events.

Other Ways to Discover CFPs:

• Conference websites: Many conferences post their CFPs directly under a "Call for Papers" or "Call for Speakers" section.

• Tech communities and newsletters: Platforms like Dev.to, Hashnode, and newsletters often share open CFPs.

• Social media: Following conference organizers and speakers on LinkedIn and Twitter can help you stay updated about new CFP openings.

• Local and virtual meetups: Many meetup groups are seeking speakers, and these smaller events can be a great way to gain experience before applying to larger conferences.

Conclusion

In this article, you learned what makes a good conference talk proposal, how to structure your proposal with examples, and submission best practices.

Keep improving your proposal, and good luck with your submissions!

You can find me on LinkedIn and Twitter.

Nodes are connected through references, forming the linked structure. One advantage of linked lists is that insertion and deletion of elements at the beginning of the list can be done in constant time, denoted as O(1).

This efficiency stems from the ability to directly manipulate references without needing to shift elements as required in arrays. Data types in a linked list can be any of the available data types supported by a programming language.

In this tutorial, you'll learn the following:

• Understanding Linked list
• Types of Linked List
• Summary of operations with their respective time and space complexities in tabular format.
• Differences Between Array and Linked list.
• Algorithm: Solve the Remove Duplicates from Sorted list in PHP and JavaScript.

Understanding Linked list

head => Points to the first box in the list
tail => Points to the last box in the list

To access the data in the first box

head.data => 6

To access the data in the second box, we first need to set the pointer (arrow) to point to the box. Hence we need the (next)
head.next => This points to the next item on the list
head.next.data => 4

To access the data in the third box, we first need to set the pointer (arrow) to point to the box. Hence we need the (next.next)
head.next.next => This points to the next > next item on the list
head.next.next.data => 5

What is a node ?

A node in a linked list is an example of a self-referential structure in programming. This structure is comprised of elements called nodes, where each node contains both data and a reference to another node of the same type. This reference, often termed a 'pointer,' facilitates the creation of a chain-like structure, where nodes are interconnected, forming the linked list.

The self-referential nature of nodes allows for efficient traversal and manipulation of data within the linked list. The structure can be implemented using classes or arrays

How to Implement a Linked List Using classes

class Node {
    public function __construct(
        public $data,
        public ?Node $next = null
    ) {}
}

// Creating nodes

$node1 = new Node(10);
$node2 = new Node(20);
$node3 = new Node(30);

// Linking nodes

$node1->next = $node2;
$node2->next = $node3;

// Traversing linked list

$current = $node1;
while ($current != null) {
    echo $current->data . " ";
    $current = $current->next;
}

How to Implement a Linked List Using Using arrays

// creating nodes as an associative array

$node1 = ['data' => 10, 'next' => null];
$node2 = ['data' => 20, 'next' => null];
$node3 = ['data' => 30, 'next' => null];

// linking nodes

$node1['next'] = &$node2;
$node2['next'] = &$node3;

// Traversing linked list

$current = $node1;
while ($current != null) {
  echo $current["data"] . " ";
  $current = &$current["next"];
}

In both cases, we create a structure where each element (node) contains data and a reference (next) to another element of the same type. This creates a self-referential structure. We then link these elements together to form a data structure like a linked list. Finally, we traverse the structure to access and manipulate its elements.

Unlike an array, a linked list doesn't provide constant time access to a particular index within the list. This means that if you'd like to find the nth element in the list, you'll need to traverse through to the nth element.

Traversing a linked list means iterating through each node of the list until the end node is reached.

Types of Linked list

We'll discuss the types under the Traversal, Memory and Complexity categories.

Singly Linked List

Each node has data and a reference to the next node.

Non-code explanation

Imagine taking a journey by train, where each train represents a part of your trip, and each station represents a point where you need to make a change.

• Train A represents the first part of your journey, taking you from Station A to Station B. When you arrive at Station B, there's a sign directing you to switch trains to continue your journey.
• Train B represents the second part of your journey, taking you from Station B to Station C. Again, when you arrive at Station C, there's no sign for another train because you've reached your final destination.

In this analogy:

• Each train segment (Train A, Train B, and Train C) represent a node in the singly linked list.
• The task of each train is analogous to the data stored in each node, representing a segment of your journey.
• The transition between trains at each station is analogous to the "next" pointer in a linked list, indicating the next segment of your journey.
• At the final destination (Station C), there's no need for a pointer or sign to another train because it's the end of your journey.

In simpler terms, a singly linked list is like a train journey with different segments, where each train (node) has the task of taking you from one station to the next until you reach your final destination. The transitions between trains are like pointers, guiding you through each segment of your journey.

Performance Characteristics of Singly Linked List

1. Traversal: Traversal is allowed only in one direction (that is, forward only). You can move forward through the list, but you cannot easily move backward.
2. Memory Efficiency: Singly linked list is generally more memory-efficient because it requires only one reference per node.
3. Complexity: Insertion and Deletion operation is easier as you only need to update references in one direction.

Time and Space Complexity

I wrote about constant and linear time complexity here, and we'll be using that to discuss the general time and space complexities for some common operations:

Traversal

Time complexity O(n), where n is the number of nodes in the list. Space complexity O(1), it doesn't require additional space proportional to the input size.

Insertion at the Beginning

Time complexity O(1), it involves updating references at the head. Space complexity O(1), it doesn't require additional space proportional to the input size.

Insertion at the End

Time complexity O(n), it may require traversing the entire list to reach the end. Space complexity O(1), it doesn't require additional space proportional to the input size.

Deletion at the Beginning

Time complexity O(1), it involves updating references at the head. Space complexity O(1), constant.

Deletion at the End

Time complexity O(n), it may require traversing the entire list to reach the end. Space complexity O(1), constant.

Doubly Linked List

In a doubly linked list, the head node typically does not have a prev reference because it is the first node and therefore has no previous node.

However, the head node does have a next reference pointing to the next node in the list. Each node has data and references to both the next and previous nodes.

Non-code explanation

Imagine that you have a book where each page represents a task you need to complete, just like items on your to-do list.

Each page does not only contain information about the task written on it but also has connections to the pages before and after it in the book.

• Page 1 (Task A) represents the first task in the book. It contains information about Task A and has an arrow pointing forward to Page 2 (Task B), indicating that Task B comes after Task A in the book. However, Page 1 does not have a backward arrow because it is the first page of the book and doesn't have a previous page.
• Page 2 (Task B) contains information about Task B and has arrows pointing both forward to Page 3 (Task C) and backward to Page 1 (Task A), indicating that Task C comes after Task B and Task A comes before Task B in the book.
• Page 3 (Task C) represents the last task in the book. It contains information about Task C and has an arrow pointing backward to Page 2 (Task B), indicating that Task B comes before Task C in the book.

With this in mind, you can think of a doubly linked list as a book where each page not only contains information about a task but also provides easy navigation to the tasks before and after it. The first page, similar to the head of a doubly linked list, does not have a previous reference, while the last page, similar to the tail of a doubly linked list, does not have a next reference

Performance Characteristics of Doubly Linked Lists

1. Traversal: Doubly linked lists allow traversal in both directions — forward and backward. This bidirectional traversal enables more flexible navigation through the list, allowing operations such as iterating in reverse order.
2. Memory Efficiency: Doubly linked lists typically require more memory compared to singly linked lists because each node contains two references (pointers) — one for the next node and one for the previous node. This additional memory overhead per node can impact the overall memory efficiency, especially for large lists.
3. Complexity: Doubly linked lists offer bidirectional traversal and flexibility. Insertion and deletion operations may require updating references in both directions (forward and backward), which can increase the complexity and potentially impact performance.

Time and Space Complexity

Traversal

The time and space complexity for this operation is the same with the singly linked list.

Insertion at the Beginning

The time and space complexity for this operation is the same with the singly linked list.

Insertion at the End

Time complexity for this operation takes O(1) time. This is because you have direct access to the tail node, so you can update the references without needing to traverse the entire list. Space complexity O(1), it doesn't require additional space proportional to the input size.

Deletion at the Beginning

The time and space complexity for this operation is the same with the singly linked list.

Deletion at the End

Time complexity for this operation takes O(1) time. This is because you have direct access to the tail node, so you can update the references without needing to traverse the entire list. Space complexity O(1), it doesn't require additional space proportional to the input size.

Circular Linked List

A circular linked list is a type of linked list where the last node of the list points back to the first node, forming a circle or loop. This characteristic distinguishes it from a traditional linked list, where the last node typically points to null, indicating the end of the list. In a circular linked list, there is no null pointer at the end; instead, the last node points back to the first node, creating a loop structure. This looping behavior allows for continuous traversal through the list. The below image shows how a singly circular linked list works.

Non-code explanation

Imagine a train line that forms a loop, with passengers boarding and exiting at various stations along the way. This loop represents a circular linked list, where each station is a node and the train continuously travels around the loop, picking up and dropping off passengers.

Just like in a circular linked list, the loop ensures continuous traversal without an end point, and passengers (data) can be added or removed at any station (node).

The circular linked list offers advantages in certain applications but requires careful handling of pointers and memory management to maintain its circular structure and prevent issues such as infinite loops.

Performance Characteristics of Circular Linked Lists

1. Traversal: Circular linked lists enable traversal in a loop, allowing seamless navigation from one node to another regardless of the direction. This circular structure facilitates efficient traversal without needing to iterate back to the beginning when reaching the end, enhancing traversal performance.
2. Memory Efficiency: Singly circular linked lists typically offer similar memory efficiency to singly linked lists, as they require only one pointer per node to connect to the next node in the sequence. This single-pointer structure results in lower memory overhead per node compared to doubly linked lists, potentially improving memory efficiency for large lists.
3. Complexity: In singly circular linked lists, insertion and deletion operations require updating references to maintain the circular structure, introducing moderate complexity compared to linear linked lists.

Time and Space Complexity

Traversal

Time Complexity: O(n) – Since you have to traverse through all the nodes in the list to reach the end.

Space Complexity: O(1) – Only a constant amount of extra space is required for a temporary variable to traverse the list.

Insertion at the Beginning

Time Complexity: O(1) – Insertion at the beginning simply involves updating the references at the head.

Space Complexity: O(1) – No additional space is required.

Insertion at the End

Time Complexity: O(n) – It may require traversing the entire list to reach the end where insertion needs to take place.

Space Complexity: O(1) – No additional space is required.

Deletion at the Beginning

Time complexity O(1), it involves updating references at the head.

Space complexity O(1), constant.

Deletion at the End

Time complexity O(n), it may require traversing the entire list to reach the end.

Space complexity O(1), constant.

Summary of Operations for the Time Complexity

Summary of Operations for the Space Complexity

Differences Between Array and Linked list

A linked list is a dynamic way to represent a list, where adding and removing items from the beginning of the list typically involves changing only a few pointers. This operation can be performed in constant time, denoted as O(1), regardless of the list's size.

On the other hand, arrays are a sequential representation of a list. Adding or removing items from the beginning of the list requires shifting all subsequent elements to accommodate the change. This operation has a time complexity of O(n), where n is the number of elements in the array. Therefore, for large arrays, adding or removing items from the beginning can be relatively slow compared to linked lists.

How to Solve the Remove Duplicates from Sorted List Problem

Explanation of the problem: Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well.

Solution in PHP

/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next = null;
 *     function __construct($val = 0, $next = null) {
 *         $this->val = $val;
 *         $this->next = $next;
 *     }
 * }
 */


class Solution {

    /**
     * @param ListNode $head
     * @return ListNode
     */
    function deleteDuplicates($head) {
        $node = $head;

        while($node !== null && $node->next !== null) {

            if ($node->val == $node->next->val) {
                $node->next = $node->next->next;
            }else {
                $node = $node->next;
            }   
        }

        return $head;
    }
}

Solution in JavaScript

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */


var deleteDuplicates = function(head) {
    let node = head;

    while(node?.next) {

        if (node.val === node.next.val) {
            node.next = node.next.next
        } else {
            node = node.next
        }
    }

    return head
};

Code explanation

Given the deleteDuplicates method:

• node is initialized to the head of the linked list.
• A while loop iterates through the linked list until the end or until the current node's next property is null.
• Inside the loop, it checks if the current node's value is equal to the next node's value. If they are equal, it skips the next node by setting the current node's next property to the next node's next property.
• If the values are not equal, it moves to the next node by updating the value of node to node->next.
• Finally, the method returns the head of the modified linked list.

The null safe operator (?.) used in the JS code solution is also available from PHP 8.0.

This code efficiently removes duplicates from a singly-linked list by adjusting pointers and has a time complexity of _O_(_n_) and a space complexity of _O_(1), where n is the number of nodes in the linked list.

Reference

• How does a linked list work

Conclusion

In this article, you learned about linked list, types of linked list and a real world problem that involves solving the removal of duplicates from sorted list.

Keep learning, and Happy Coding!

You can find me on LinkedIn and Twitter.

In this tutorial, you'll learn the following:

• Constant and linear time complexity.
• Why use a hash map?
• Things to consider when writing hash functions.
• How to solve the Two Sum problem in PHP and JavaScript.

What is Constant Time Complexity - O(1)?

O(1) indicates that the running time of an algorithm is constant, regardless of the input size.

This implies that the algorithm's performance isn't dependent on the size of the input. An example is accessing an index of an array.

<?php

function constantTimeAlgorithm($arr) 
{

    echo $arr[0] . PHP_EOL;
}

Here is a non-code example to illustrate the concept of constant time complexity:

Imagine sending a file through an airline to your friend, and the airline has a policy where they charge based on the weight of the package.

Now, whether your file weighs 2 grams or 20 kilograms, the airline's processing time remains constant. This means that the time it takes for the airline to handle your package doesn't depend on the weight of the file – it's always the same.

In other words, the processing time is constant irrespective of the size of the file.

What is Linear Time Complexity - O(n)?

O(n) indicates that the running time of an algorithm grows linearly with the size of the input.

The performance of the algorithm is directly proportional to the input size. An example is traversing a for loop and printing elements.

<?php

function linearTimeAlgorithm($arr) 
{
    foreach ($arr as $element) {
        echo $element . PHP_EOL;
    }
}

Here's a non-code example to illustrate the concept of linear time complexity:

Consider using an electronic transfer service to send a file to your friend. In this scenario, the time it takes to transfer the file increases linearly with the size of the file.

For instance, if it takes 1 minutes to transfer a 100 MB file, it would take approximately 100 minutes to transfer a 10 GB file using the same service.

This linear relationship between the size of the file and the time it takes to transfer it reflects linear time complexity. The time taken to transfer the file increases proportionally or linearly with the size of the input or file.

Why use a Hash Map?

Illustration of how a hash map works

A hash map is a concrete implementation of the abstract data type known as an associative array.

In a hash map, keys are hashed to determine the index where the corresponding values will be stored, allowing for efficient retrieval and storage of key-value pairs.

This implementation typically provides fast access times for operations like insertion, deletion, and lookup of values based on their associated keys.

In languages like PHP or JavaScript, when you use an associative array, you are essentially using a hash map. Their associative arrays are implemented using hash tables behind the scenes.

You can use strings, integers, or other data types as keys, and the language's internal hashing mechanism efficiently maps these keys to their corresponding values. Additionally, JavaScript provides the Map object for more advanced hash map functionalities.

Time and Space Complexity for Hash Map

The time and space complexity for a hash map (or hash table) is not necessarily O(n) for all operations. The typical and desired time complexity for basic operations like insertion, lookup, and deletion in a well-designed hash map is O(1) on average.

Here's a breakdown of time and space complexity for a hash map:

Time Complexity:

Average Case:

• Insertion (average): O(1)
• Lookup (average): O(1)
• Deletion (average): O(1)

Worst Case:

• Insertion (worst): O(n), where n is the size of the hash map. This occurs when there are many hash collisions, leading to linear probing or other collision resolution strategies that may involve traversing the entire hash map.
• Lookup and Deletion (worst): O(n), for the same reason as insertion.

Space Complexity:

• The space complexity is typically O(n). Where n is the number of key-value pairs stored in the hash map. Each key-value pair occupies constant space, and the space required grows linearly with the number of elements.

In algorithm analysis, the notation O(1) and O(n) represent the upper bounds on the time complexity of an algorithm, where n is the size of the input.

Operations

1. Insertion: The key-value pair is hashed, and the resulting index is used to store the value in the corresponding slot. If a collision occurs, the collision resolution strategy is applied.
2. Deletion: The key is hashed to find the index, and the item at that index is removed. Collision resolution may be necessary.
3. Lookup: The key is hashed to find the index, and the value at that index is returned. Collision resolution may be applied if needed.

Things to consider When Creating Hash Tables

When creating hash tables, there are several important considerations to ensure efficiency, including fast computation of hash codes and effective collision resolution strategies.

Fast Computation

Hash codes should be computed quickly to ensure efficient insertion, lookup, and deletion operations. A good hash function contributes to the speed of hash code computation.

Avoid collision

A collision happens when two or more keys produce the same hash code. In other words, multiple keys map to the same array index.

How to Handle Collisions

Hash maps use collision resolution techniques to deal with collisions. Common strategies include:

Chaining

To manage several values with the same hash code, chaining involves storing a linked list or other data structure at each array index. If a collision occurs, the new key-value pair is appended to the linked list at the relevant index.

Open addressing

When a collision happens in a hash table, a technique called open addressing is employed to resolve it by searching for the next open space.

All it does is search the array for the next empty slot where the key-value combination can be placed. Methods including double hashing, quadratic probing, and linear probing are applied.

Linear Probing: In linear probing, the algorithm moves linearly to the next index in the array in order to find the next open slot when a collision occurs.

Quadratic Probing: In this method, an algorithm employs a quadratic function to find the next slot that becomes available.

Double Hashing: In double hashing, the algorithm calculates the step size between probes using a secondary hash function.

In order to reduce the possibility of collisions, a good hash function should generate distinct hash codes for various inputs. By making sure the hash codes are evenly distributed throughout the range of potential values, collisions can be prevented.

How to Solve the Two Sum Problem

Two sum problem

The Two Sum problem involves finding all pairs of elements in an array that sum up to a specific target value. Now let's look at the problem statement.

Problem statement

Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to the target.

Example 1:

Input: nums = [3,2,4, 8], target = 12

Output: [2, 3]

Example 2:

Input: nums = [5,5], target = 10

Output: [0,1]

Solution

To solve the Two Sum problem, we can use a hash table. The idea is to traverse the nums array and, for each element, check if the complement (the difference between the target and the current element) is already in the hash table. If it is, we have found a pair of indices whose elements add up to the target.

Here are the steps to follow:

1. To hold the elements and their respective indices, create an empty hash table upon initialization.
2. Go over the array of nums.
3. Do the complement calculation (target - current element) for each element.
4. Verify if the complement has already been added to the hash table. If yes, return the current index and the index stored in the hash table for the complement.
5. If the complement is not in the hash table, store the current element and its index in the hash table.
6. If no such pair is found during the traversal, it implies that there is no solution.

PHP Code Solution

<?php

function twoSum($nums, $target) {
    $hashTable = [];

    foreach ($nums as $i => $num) {
        $complement = $target - $num;

        if (array_key_exists($complement, $hashTable)) {

            // Found the pair, return the indices
            return [$hashTable[$complement], $i];
        }

        // Store the current element in the hash table
        $hashTable[$num] = $i;
    }

    // No solution found
    return [];
}

// Example usage:
$nums = [2, 7, 11, 5, 15, 30];
$target = 12;
$result = twoSum($nums, $target);

echo "Indices of the two numbers: [" . implode(", ", $result) . "]";

JavaScript Code Solution using map Function

function twoSum(nums, target) {
    const hashTable = new Map();

    for (const [index, num] of nums.entries()) {
        const complement = target - num;

        // Check if the complement is in the Map
        if (hashTable.has(complement)) {

            // Found the pair, return the indices
            return [hashTable.get(complement), index];
        }

        // Store the current number and its index in the Map
        hashTable.set(num, index);
    }

    // No solution found
    return [];
}

// Example usage:
const nums = [2, 7, 11, 5, 15, 30];
const target = 12;
const result = twoSum(nums, target);

console.log(`Indices of the two numbers that add up to ${target}: [${result.join(', ')}]`);

This approach has a time complexity of O(n) because we iterate through the array once. The space complexity is also O(n) due to the storage of elements in the hash map.

Resources

1. Hash table From Wikipedia
2. Hash maps in Python

Conclusion

In this article, you learned about hash maps, things to consider when writing hash functions and a real world problem that involves solving the Two Sum problem.

Keep learning, and Happy Coding!

You can find me on LinkedIn and Twitter.

In this tutorial, you’ll learn the following:

• Introduction to Composer.
• Minimum stability in Composer.
• Levels of stability, and the recommended version for production code.

One of the benefits of using a dependency tool is that it makes it easy to declare the key-value pair of packages you need for your project. This way, you can install dependencies via the composer install command or update them via the composer update command in the terminal.

Introduction to Composer

In Laravel, the composer.json is a JSON file located at the root of the project directory. It contains sample configurations used for dependency management, such as the project name, type (optional), description (optional), and the list of required packages.

These packages are represented using key-value pairs (name and version to be installed). Additionally, the composer.json file includes some required packages for the development environment which can be added as part of the configuration setup.

Here's what a composer.json file looks like:

{
    "name": "laravel/laravel",    
    "type": "project",    
    "description": "The Laravel Framework.",    
    "keywords": [        
        "framework",        
        "laravel"    
    ],    
    "license": "MIT",    
    "require": {        
       "php": "^8.1",        
       "laravel/framework": "^10.0",    
    },    
    "require-dev": {    
         .    
         .     
    },    
    "config": {    
         .    
         .    
    },    
    "minimum-stability": "dev"| "alpha"| "beta"| "RC"|"stable", //stable
}

What is Minimum Stability?

In Composer, the “minimum-stability” configuration specifies the minimum stability level for all installed packages.

Packages to be installed or updated will use the minimum-stability value to determine version limitations during dependency resolution.

Levels of Stability

The following are the different stability levels:

• dev: This is the least stable version, and should never be used in production. It often includes packages under active development that may contain bugs or breaking changes and may still undergo significant modifications. It is only recommended for local development purposes.
• alpha: It's a version also undergoing development but in a more stable state. It usually contains fewer breaking changes and features nearing final completion or awaiting a beta release. However, it is also not highly recommended for production environments.
• beta: This version is currently being tested, and minor bugs, when noticed, will need to be fixed. However, it is more stable than the alpha and dev versions, but it's still not recommended for production purposes.
• RC: The RC (Release Candidate) is a version pending official release. It's the closest to being stable, but the version requires community testing and feedback prior to the final release. Undiscovered bugs can also be identified during this phase, so it's best practice not to use it for production purposes.
• stable: This is the required level for production purposes. It includes all packages that have gone through significant changes, bug fixes, community testing, feedback, and is now ready to use.

In your composer.json, you can specify the minimum stability by doing the following:

{
    "minimum-stability": "stable"
}

Conclusion

In this article, you have learned about Composer, the composer.json file, minimum stability, and, most importantly, the levels of stability offered by Composer.

For your application, you should carefully choose the stability level that satisfies your production needs, while keeping security and downtime issues in mind. Remember, your application should only depend on stable and reliable packages.

I hope you now have a better understanding of minimum stability.

Keep learning, and Happy Coding!

You can find me on LinkedIn and Twitter.

In this tutorial, you'll learn the following:

• Introduction to logging
• Understanding log configurations
• Channel drivers for log files
• Formatting log messages

Log file image

Introduction to Logging

Laravel provides a log of what's happening in your application. The log service is built upon the Monolog open-source library.

The logging service is robust as it allows you to write log messages to files and send critical ones to teams on Slack (if configured), Socket, databases, and other web services.

The channel you wish to write your log information on is defined by the team, as there are a couple of channels supported by Laravel. Based on the severity of log information, the write information can also be done in multiple channels. You'll see how you can do this in the configuration section.

How to Configure Your Laravel Logs

Laravel log configuration is located in the config > logging.php file. Consider using a couple of log channels based on your preferences, such as stack, single, daily, syslogs, slack, papertail, and so on.

The channels are where you send log information. The default channel for every project is usually stack. You can change it by defining the LOG_CHANNEL in the env or specifying the channel name as the second parameter in the same logging.php file.

'default' => env('LOG_CHANNEL', 'stack')

The stack channel has a driver name set to stack. Channels set to single means you get all logs in a single log file. You can also use daily which means a new log is auto-generated every day. It is an array.

You can also use multiple channels, 'channels' => ['daily', 'slack'], and ignore_exception is a boolean (true, false).

I highly recommend using the daily channel, as this helps you keep track of daily logs by auto-generating a new log file every day (laravel-2023-01-15.log, laravel-2023-01-16.log and so on) without having to clear logs for the previous day.

The daily options keep you updated each day with log info in your log files for as long as you want. It also enables you to monitor frequent errors within the application if they occur on different days.

 'channels' => [        
    'stack' => [ 
        'driver' => 'stack',            
        'channels' => ['daily'],    
        'ignore_exceptions' => false,        
        ],
....],

Channel Drivers for Log Files

Here’s the list of the channel drivers Laravel offers:

1. Single: The Single driver ensures log information is sent to a single file. The driver sends logs to storage > logs > laravel.log by default.
2. daily: The driver ensures that logs are written daily. The beauty about this is that every day new log file is auto-generated. Compared to the Single driver, there's no need to clear up the previous day's log information frequently. But the drawback to this channel is that you might have several log files. Every week/month, you should clear up all unused files.

Within the logs directory, you often get logs like this:

Daily log file

3. slack: The slack driver ensures that all logs are sent to Slack. Slack needs to be configured to get user credentials (username, webhook) to help with error logging. This is super helpful as it allows your team to stay updated about what's happening right in a Slack channel.

4. syslog: Logs using this driver will send log reports to the system log. The location of this log driver is dependent on the server operating system.

5. errorlog: Logs set up to use this driver will send log reports to the error logs file setup on the web server operating system.

6. monolog: This driver provides support for all Monolog handlers.

7. custom: This driver helps create a custom channel based on user preference. It could be to a third-party service that needs log reports.

8. stack: The stack driver is responsible for creating multiple channels

9. null: All log messages get discarded by the driver.

How to Format Log Messages

If you need a refresher on how facades work or how to create one, you should refer to this article about how facades work in Laravel.

Laravel has a Log facade that helps with writing logs. Import the facade at the top of the file to use any log level.

<?php

use Illuminate\Support\Facades\Log; 


Log::info($message);

You can also choose to escape the Log facade, so you won't need to import anything. This is suitable if you're logging a single instance of log info.

<?php

\Log::info($message);

In a recent Laravel release, logging has greatly improved. You can do away with the Log facade while logging info and reference the info from within your Laravel application.

<?php

info($message);

Other logging levels used to write information include alert, emergency, critical, warning, error, notice, and debug.

Within a file, you can log any of the data types or messages and even format the output of text you wish to write to the log file.

How to format strings, booleans, and integers:

<?php

use Illuminate\Support\Facades\Log;


Log::warning('There is a warning'); 

Log::error(false);

Log::notice(500);

How to format to an array:

You can also format to an array. With the array function, a new array is created. So we can write an array to the log file by passing the log info to the array function. The json_decode converts the JSON object to a PHP object, and the true ensure it returns associative arrays (key and value pairs).

<?php

$person = '{"Peter":35, "John":37, "Yinka":43}'; 

$data = json_decode($person, true);

info($data);

How to format to an object:

You can also write JSON objects to the log file when working with logs. Use the json_encode to encode values into JSON format.

<?php 

$data = ["Peter"=> 35, "John"=> 37, "Yinka" => 43];

info(json_encode($data));

How to concatenate string with array or objects:

This is helpful when including a string to track the log information. You can do this using the concatenation operator (.)

<?php

$persons = ["Peter"=> 35, "John"=> 37, "Yinka" => 43];

info('The person info ' . json_encode($persons));

How to write to dedicated channels:

This method is helpful when you feel there's a need to write into specific channels aside from the default log channel. It would help if you had to specify the channel name when calling the Log facade.

<?php


\Log::channel('slack')->info('registeration successful');

The snippet above ensures the write operation is done on the Slack channel. Also, the stack method allows logging on multiple channels.

<?php


\Log::stack(['single', 'slack'])->info('registeration successful!');

You can learn more about custom channels via factories and monolog channel customization from the official documentation.

Wrapping up

In this article, you have learnt about logging, configuring logs in your Laravel application, available channel drivers, and how to write log files in different formats.

You should now have a better understanding of laravel logging. Keep learning, and Happy Coding!

You can find me on LinkedIn and Twitter.

I wondered if it was an M1 issue or because I had yet to shut the machine down. I shut down, and the problem persisted. And I couldn't find anything online indicating that it was an issue with M1. So how could I fix it?

In this tutorial, you'll learn:

• Why does the Error 504 occur?
• What is Laravel Valet and how does it work?
• Valet commands you should know
• How to fix the 504 error and speed up performance in Valet

Why does the Error 504 occur?

Error 504 Nginx

Error 504, also known as "Gateway timeout", is an error that occurs when a server takes longer than usual to respond to an HTTP request. This makes it unable to complete the request cycle.

The Gateway timeout is a server-side error caused by several things. It can result from network connectivity issues when the server exceeds the default limit of 256M or an execution time of 60 seconds, an overloaded server, firewall, and so on.

This error happens with local servers, too, such as XAMPP, WAMP and Valet, during the local development lifecycle.

This article will help you fix this problem on Valet by adding some configurations to speed up the server request lifecycle.

What is Laravel Valet and How Does It Work?

Laravel Valet is a development environment for macOS, Windows, and other operating systems. Once installed, Valet runs Nginx processes in the background when your laptop comes on.

Unlike other development environments like XAMPP and WAMP, you'll have to manually start your server each time you set out to work. Valet then uses DnsMasq to proxy all parked applications to a .test domain.

So, for instance, you would access on XAMPP server http://localhost/application but on valet, you would do http://application.test, and it will point to where the application is installed.

Working with Valet means you don't have to put all applications in an htdocs or www directory. Instead, any random directory you create will work just perfectly in Valet.

Helpful Valet Commands You Should Know:

• valet park: Registers all applications/sites in a directory and exposes them with the .test domain.

cd ~/project_directory
valet park

• valet parked: Gives a tabular breakdown of all registered sites. Information like site name, SSL, URL, and path is available.

cd ~/project_directory
valet parked

• valet secure: Secures your application with an SSL certificate and makes the site accessible over HTTPS.

cd ~/project_directory/site
valet secure

• valet unsecure: Use this command to unsecure your site and revert to serving over HTTP.

cd ~/project_directory/site
valet unsecure

• valet isolate: Isolates a particular site and makes it run on a different PHP version that's not the globally installed version. You can run php -v on the terminal to see the version. But if some of your applications want to downgrade or upgrade, you should use the isolate command and specify the version you need. The isolate command below, enforce the site to use PHP version 7.4:

cd ~/project_directory/site
valet isolate @php7.4

• valet unisolate: Reverts a site back to the globally installed PHP version.

cd ~/project_directory/site
valet unisolate

• valet restart: The restart command ensures all valet services are restarted. It's useful when configurations are modified, updated, and installed.

cd ~/project_directory/site
valet restart

• valet -v: This command helps check the the current Valet version. Not only that, but the command also shows a list of all available commands and descriptions of what they do in Valet.

~/project_directory/site
valet -v

Valet available commands

How to Speed Up Performance in Valet

Over in the terminal, we will need to create a file www.conf in a directory and then add the configuration settings we need.

Get your PHP global version and copy it like this:

php -v

Navigate to the directory and replace the 7.4 with the PHP version you copied earlier.

cd /opt/homebrew/etc/php/7.4/php-fpm.d

Create a www.conf file like this:

touch www.conf

Open the file so you can add the valet configuration settings:

open -a TextEdit www.conf

The command opens up the www.conf file in your text editor and you can update the file with these settings:

pm.max_children = 200
pm.start_servers = 20
pm.min_spare_servers = 10
pm.max_spare_servers = 20
pm.process_idle_timeout = 10s
pm.max_requests = 500

Save and close the file from the text editor.

Let's go through each line we added to the www.conf file:

• pm is an acronym for process manager, and the setting will impact how the process manager controls every child process. The possible values available to us include static, on-demand, and dynamic.
• pm.max_children is a static option, indicating the maximum number of the child processes, which we have set to 200.
• pm.start_servers, pm.max_spare_servers and pm.min_spare_servers: These are dynamic values, and the child processes are set dynamically based on the server directives – that is, start_servers = 20, min_spare_servers = 10 and max_spare_servers = 20.
• pm.process_idle_timeout: the total time taken for an idle request not processed to be killed/terminated is set to a default value of 10 seconds (s). Other units can be estimated in minutes (m), hours (h) or days (d).
• pm.max_requests: This refers to the maximum number of requests a child process can handle at a given time before it's killed/terminated. If the request executes the maximum, it becomes idle, and the pm gets rid of it.

Finally, restart all services from the terminal using the sudo brew command. Notice again the 7.4 – that's because of my global PHP version.

sudo brew services restart php@7.4

You can now say bye-bye to the 504 error and slow Valet performance in your local environment.

Wrapping up

In this article, you have learned about working with Laravel Valet and how to get all Valet configurations set up. You also learned how to ensure a fast development environment and get rid of persistent 504 gateway timeout errors.

Keep learning and Happy Coding!

You can find me on LinkedIn and Twitter.

For example, an if () else if () else {} check case expression handles all SQL conditionals. If the first condition is satisfied, the query stops executing with a return value. The value specified within the else is returned if no condition is satisfied.

In this article, we'll cover:

1. What the SQL CASE statement is and how it works
2. How to solve an exercise using the SQL CASE statement
3. What some important terms mean, like order by, limit, offset, left join and alias.

SQL CASE Statement Explained

In programming when you have a given set of conditions, you end up using conditionals (switch or if else) to know which block of code to execute when a condition is met.

With SQL, you can do this using the CASE statement. You use the CASE keyword together with the WHEN clause to execute a block of conditional statement code. You use a THEN statement to return the result of the expression. If none of the conditions are met, then you use a final ELSE clause to return a fallback result.

The SQL CASE statement has the following syntax:

CASE
    WHEN conditional_statement1 THEN result1
    .
    .
    .
    .
    WHEN condition_statementN THEN resultN

    ELSE result
END;

When you use the CASE statement, it has to be followed by a WHEN and THEN the result if the first condition is met. If the first condition is not met it keeps on checking the other conditions until the nth (or final) condition. If that is still not met then the ELSE condition gets executed.

Also, the ELSE part is optional when using the CASE statement. In scenarios where you don't use it, the query result returns NULL.

SQL Challenge

In this section, we will take a case study of a real-life scenario to help you learn how to solve a SQL challenge that uses the CASE statement.

The challenge is one I encountered on Coderbyte, a platform for practicing coding challenges. It was a bit tough to crack, and I will break down the step-by-step process involved in this article.

What is the challenge?

The challenge involves coming up with a SQL query to return the employee with the third-highest salary from a table.

You'll need to structure a query to find this employee and return that row. You also have to replace the position of the DivisionID column with the corresponding DivisionName from the table company_divisions. Then you'll need to replace the ManagerID column with the ManagerName if the ID exists in the table and is not NULL.

What problem does the SQL CASE statement solve in this challenge?

In this challenge, we need the CASE statement to help achieve the followings:

1. Ensure that the MangerID is not NULL.
2. Match the company ManagerID to company ID and return the Name as the ManagerName.
3. Ensure that if no Name is returned, then the name Susan Wall is used as the default ManagerName.

Here's the expected output:

And here's the data you'll need to solve this challenge:

Table 1: company

Table 2: company_divisions

How to Solve the SQL CASE Statement Challenge

In this section, we will look at the step-by-step process involved in solving the challenge.

Step 1: Get the third-highest salary

First, you'll need to structure a query to return the third-highest salary. You'll do this by selecting from the company table and ordering by salary (since we're interested in the record with the third-highest salary).

You can do that like this:

SELECT *

FROM company

ORDER BY salary DESC limit 1 offset 2;

The query returns the employee's row with the third highest salary, as expected.

So what's going on in this query?

SELECT: you use the SELECT command with the asterisk (), also known as a wildcard) to retrieve all columns from the *company table.

ORDER BY: The ORDER BY command orders column(s) in ascending or descending order. SQL orders by ascending (ASC) by default, but we will order the salary column by descending (DESC). This is because we need the desc salary from the highest to the lowest, that is 110,000 - 40,000.

limit: The limit command limits the number of records returned based on the limit's set value. Since we are only interested in just one row, we will set the limit in the query to 1. This ensures that we will get a return value of a single record every time this query gets executed.

offset: Using the offset clause here helps you specify the number of rows to skip before the start of actually returning the row from the query. Offset lets us skip the two highest-paid rows (Susan Wall and Dennis Front) and return the third highest-paid (Mark Red).

Step 2: Replace DivisionID with DivisionName

Now, you need to modify the query by selecting only the columns you need – ID, Name, ManagerID, DivisionName, and Salary. Then you need to replace the DivisionID column with the corresponding DivisionName from the table company_divisions.

You can do that like this:

SELECT c.ID, c.Name, c.ManagerID, c.salary, cd.DivisionName

FROM company as c

LEFT JOIN company_divisions as cd ON c.DivisionId = cd.id

ORDER BY salary DESC limit 1 offset 2;

Here's the output:

Let's discuss what's going on in the above query:

LEFT JOIN: Since records are returned from the left side (company), we will match them using the LEFT JOIN on the right side (company_divisions) using the company_division.id and company.DivisionID.

If a matching record is found, that is the company's id is also present in company division, then the DivisionName column is populated with the actual value from the left join, in our case (Sales). If there is no record, nothing is returned.

as (alias): The alias used is a temporary name for the table. So rather than company.name with an alias for the company as c, we can define it as c.name. Using aliases helps improve readability.

Step 3: Replace ManagerID with ManagerName

We will build on the result of the query from Step 2. We'll use the CASE statement we learned to add conditionals for when the ManagerId is not null and to check if the ManagerId also exists.

The first thing we need to do is check if the company.ManagerID is not null and make sure that the ID exist in the table. We will apply the CASE statement here.

CASE WHEN c.ManagerID IS NOT NULL 

AND c.ManagerID = c.ID

The second part of the CASE statement is to replace the ManagerID column with the ManagerName. Then we'll need to use the THEN block we learnt earlier like this:

CASE WHEN c.ManagerID IS NOT NULL 

AND c.ManagerID = c.ID

THEN Name ELSE 'Susan Wall' END AS 'ManagerName'

Finally, we can now include the CASE block into the already existing code snippet we had from STEP 2. This will look somewhat like this now:

SELECT c.ID, c.Name, c.salary, cd.DivisionName

CASE WHEN c.ManagerID IS NOT NULL 

AND c.ManagerID = c.ID

THEN Name ELSE 'Susan Wall' END AS 'ManagerName'

FROM company as c

LEFT JOIN company_divisions as cd ON c.DivisionId = cd.id

ORDER BY salary DESC limit 1 offset 2;

The result of Step 3 is the expected output – the employee with third-highest salary.

Wrapping up

In this article, I hope you learned about the CASE statement in SQL and how to approach a real-world problem using CASE.

You also learned other SQL commands such as SELECT, ORDER BY, LIMIT, OFFSET, LEFT JOIN, and ALIAS.

CSRF is a malicious activity that involves an attacker performing actions on behalf of an authenticated user. Fortunately, Laravel provides out-of-the-box measures to prevent this type of vulnerability.

In this tutorial, you'll learn:

• What is CSRF?
• How to prevent a CSRF request
• How and where CSRF verification happens

What is CSRF?

CSRF attacks hijack user sessions. They do this by tricking a user into sending a request through hidden form tags or malicious URLs (images or links) without the user's knowledge.

This attack leads to a change in the state of the user session, data leaks, and attackers can sometimes manipulate end-users data in an application.

CSRF Explainer

The image above illustrates this scenario where an Actor (User) sends a request from malicious.xyz through the webserver to application.xyz. They then realize that their information has been manipulated by updating their password.

How to Prevent CSRF Requests

For each user session, Laravel generates secured tokens that it uses to ensure that the authenticated user is the one requesting the application.

Since this token changes each time a user session is regenerated, a malicious attacker can not access it.

Each time there’s a request to modify user information on the server-side (back end) like POST, PUT, PATCH, and DELETE, you need to include a @csrf in the HTML form request. The @csrf is thus a Blade directive used to generate a hidden token validated by the application.

Blade directive is the syntax used within the Laravel templating engine called Blade. To create a blade file you give it a name – in our case form – followed by the blade extension. This means that the file will have the name form.blade.php.

You use the blade file to render views to users on the webpage. There are a couple of default directives or blade shorthand syntaxes you can use. For example, @if checks if a condition is met, @empty checks if records are not empty, @auth checks if a user is authenticated, and so on.

But here we are more interested with the @csrf directive. Here's how you use it:

<form method="POST" action="{{route('pay')}}">

    @csrf

</form>

Earlier Laravel releases used to look somewhat like this – both work and do the same thing behind the scenes.

<form method="POST" action="{{route('pay')}}">

    <input type="hidden" name="_token" value="{{ csrf_token() }}" />

</form>

When the CSRF token is not present in the form request that gets sent or if it appears invalid, Laravel throws an error message "Page Expired" with a status code 419.

Laravel 419 Page Expired

How and Where CSRF Verification Happens

The VerifyCsrfToken middleware handles CSRF verification within the Laravel application. The middleware is registered in the Kernel.php, and found within the application's web route middleware group. This means the middleware is triggered for requests within the Web, not related to APIs.

protected $middlewareGroups = [
        'web' => [
           .
           .
           .
           .
           .
            \App\Http\Middleware\VerifyCsrfToken::class,
        ],
    ];

The VerifyCsrfToken middleware extends the Illuminate\Foundation\Http\Middleware\VerifyCsrfToken class. This means that the CSRF verification is housed within the class.

Let's dive deeper to learn how Laravel handles the CSRF verification.

Within the class, we have the tokensMatch function.

protected function tokensMatch($request)
    {
        $token = $this->getTokenFromRequest($request);

        return is_string($request->session()->token()) &&
               is_string($token) &&
               hash_equals($request->session()->token(), $token);
    }

The function does two things:

1. $this->getTokenFromRequest gets the token from the incoming request attached via a hidden field or the request's header. The token is decrypted and then returned to the token variable.

protected function getTokenFromRequest($request)
    {
        $token = $request->input('_token') ?: $request->header('X-CSRF-TOKEN');

        if (! $token && $header = $request->header('X-XSRF-TOKEN')) {
            try {
                $token = CookieValuePrefix::remove($this->encrypter->decrypt($header, static::serialized()));
            } catch (DecryptException $e) {
                $token = '';
            }
        }

        return $token;
    }

2. Cast both request token and session to a string and then use the PHP built-in hash_equals to compare if both strings are equal using the same time. The result of this operation is always a bool (true) or (false).

Wrapping up

In this article, you have learned about CSRF, how to handle and protect against it, and the behind-the-scenes of how Laravel does the verification.

You can read more about this in the Laravel documentation. And you can read more about PHP hash equals in the docs here.

Happy Coding!

You will not need to download any tools to do this, since you can get it done right within VS Code.

The article covers the following:

1. Intro to VS Code IDE and marketplace
2. Why use Thunder Client?
3. Advantages of Thunder Client
4. How Thunder Client works
5. How to download and install Thunder Client
6. How to launch Thunder Client
7. Collections and environment variables
8. How to make a client request
9. Preview of a sample request and response

Intro to VS Code IDE and Marketplace

VS Code is more than a code editor or IDE for so many developers. It doesn't just let you write code in your preferred language(s) – it also lets you fast track the whole development process.

VS Code provides a marketplace of extensions that lets you easily search and download your favorite ones from the pool of many open-source options.

Why Thunder Client?

Thunder Client is an alternative to the famous Postman tool used for testing client APIs. The Thunder Client VS Code extension is lightweight and lets you test APIs on the fly within the editor.

You might not want to download another tool to test the APIs you're building. Instead, how about downloading an extension in VSCode that offers a wide range of functionalities like:

• collections,
• environment variables,
• support for standard HTTP verbs,
• navigation tabs (Query, Headers, Auth, Body, Test), and
• Support for JSON Responses

Thunder Client vs Postman

Thunder Client is lightweight and is suitable for users who want a simple user interface and fantastic user experience with zero complexity. It also runs flawlessly offline and provides documentation with markdown support 🤯.

Keep in mind that Postman is more robust and has a broader range of features built to industry standards. It allows a community of developers to explore the largest network of APIs, workspace, and collections all over the world. It also has features like creating teams, reporting, monitors (periodically checking for APIs performance and response), and mock servers (leverages mock servers that help simulate endpoints and their corresponding responses without a backend).

It's easy to create APIs because it offers support for versioning, schema types (OpenAPI 3.0- 1.0, RAML, GraphQL), and schema format (JSON, YAML).

Like every great tool, Postman has an up-to-date learning centre where you can find documentation to get started with the tool. Sounds interesting too, right? Well yeah 😁 both are unique and perfect for their use cases.

Advantages of Thunder Client

First, it's a super fast API client extension. It creates requests to retrieve responses quickly and seamlessly. It also does not require internet access when testing APIs on your local machine.

It also has an intuitive and easy to use user interface. The interface is friendly and a lot easier to use as there are relatively few features on the extension compared to a tool like Postman.

Thunder Client has extensive API request handling. It's efficient for processing large requests at a time and does not slow down the VS Code application.

It also supports Visual Studio Code themes and adopts your currently configured VS Code theme.

Finally, Thunder Client supports collections, environment variables, GraphQL, and test scripts. It also has popular features that robust tools like Postman have.

In general, Thunder Client makes an excellent alternative for a small team who only need access to basic features like collections, an environment variable, and testing.

How Thunder Client Works

If you want to use Thunder Client, you'll need to go to the VS Code marketplace to download the extension and then launch it. Once you've done that, here are a few basic things you can use the extension to do:

Track Activity: Thunder Client keeps track of recent API requests a user has made in the past. You can also filter the activity to narrow it down to a preferred activity search. It is also called History.

Use Collections: You can organise APIs so it's easier to access them. Collections are a group of APIs, so you can create a User collection to include APIs like create user, edit user, delete user, and so on.

Environment Variables: With Envs, you can store credentials like tokens, base URLs, and public and private keys and then use the variables within the request body.

Make Requests: You can specify your preferred HTTP verb to go along with the request, like POST, then the endpoint. With the request Thunder Client, there is also support for Query Parameters, HTTP Headers (Raw or Not), Authentication (None, Basic, Bearer, OAuth 2, AWS and NTLM Authentication), Body (Payload attached to individual request) and Test (you select the test type which can be a response code and set a value to assert).

Responses: Thunder Client offers a well-crafted response section with the response body, response status, and size and time it took for the request. It also lets users add markdown supported documentation, making it even more enjoyable.

How to Download and Install Thunder Client

To download Thunder Client, you can find it on VS Code marketplace. Just search for "Thunder Client" when you're prompted and then install it.

Search Thunder Client On Marketplace

NOTE: I have mine installed already, so the uninstall option is showing in the image.

Install the Thunder Client extension by clicking on the install button.

Install Thunder Client

How to Launch Thunder Client

Click on the new icon that's been added in VS Code to launch Thunder Client.

Launch Thunder Client

Then you can start using Thunder Client.

How to Use the Activity Tab

The activity tab shows the history of your API request in recent times. You are also free to perform operations such as saving to a collection, renaming, duplicating, and more as shown in the image.

How to Use Collections and Environment Variables

Collections are a group of API Requests. Thunder Client lets you work with collections or create a single individual request like the "New Request" button.

To work with collections, click on the "Collections tab", then click on the icon the arrow points to in the image below. This shows a dropdown where you select if you want a "New collection" or have an existing collection for import.

Create & Import collection

You can add environment variables by clicking the "Env" tab, then clicking on the icon the arrow points to in the image below. This shows a dropdown to set up the env variables for requests. You also get to import existing variables.

How to Make a Client Request

Depending on the type of Request, Thunder Client offers a list of HTTP VERBS for requests such as GET, POST, PUT, DELETE, and PATCH.

HTTP Verbs in Thunder Client

There is also support for Query parameters, Headers, Authorization, Body and Tests. At the time of writing, there is no support for file attachments for requests yet. You can check the upcoming release notes here.

Query Parameters allow you to append query parameters to the request.

Query Params

Headers let you set HTTP headers like authorization, content-type, origin, user-agent, accept-language, referrer, and so on.

If you want any headers to be optional, just make sure to leave them unchecked for the request. There is also an autocomplete suggestion enabled for your preferred type of header.

Http Headers

To access resources, you need to have tokens that authenticate them. With Thunder Client, the Auth tab lets you select your preferred type of Auth and add credentials.

In my case, I choose Bearer; then, I have a token pasted into the text area and an auto-generated token prefix for the request.

Authentication

You can include a payload when making a request. To add the payload, select the Body tab, and you will see different data formats supported by the extension.

Request Payload

Sample Request and Response

The image below shows a sample request with query parameters and a sample JSON response.

Sample Request & Response

Conclusion

Yaaay, excited to have you hooked till the end. I hope you have learned how to search the VS Code marketplace for extensions and can start making API Requests with Thunder Client.

Massive shout out to the creator @Rangav on Twitter for the superb extension.

Follow me on twitter and also share if you find it useful.

What is reCaptcha?

reCaptcha is a Google service provided for free that helps you protect your websites from spam and malicious attacks.

The new version, V3, has many improvements over previous versions thanks to the new captcha challenges. It returns a score and analytics you can use to take appropriate action for your website.

Here's what the previous version of reCaptcha looks like – but as of the latest release (v3), reCaptcha has changed a lot and has a better user experience.

Previous reCaptcha Version

Previous reCaptcha Version

What you'll learn

By the end of this article, you'll have learned the following:

1. How to integrate the reCaptcha v3 into your Laravel project
2. How to setup a Google reCaptcha admin dashboard
3. How to view your website reCaptcha scores and analytics to help you make better security decisions

How to Setup reCaptcha in a Laravel Project

You can follow these simple steps to get reCaptcha set up on your project.

1. Install this laravel project if you haven't done so yet
2. In the terminal, pull the open-source package into your project with composer.

composer require biscolab/laravel-recaptcha

3. Publish the recaptcha.php with this command:

php artisan vendor:publish --provider="Biscolab\ReCaptcha\ReCaptchaServiceProvider"

This will create a file in the config directory, called config\recaptcha.php, where we will add more reCaptcha configurations.

4. Visit this link to create a reCaptcha admin account for yourself.

Register reCaptcha v3

To create the reCaptcha admin, you can do the following:

• Add your site name to the label – localhost or examplesite.com
• Select v3 as the reCaptcha type
• Include domains in the domain section (localhost or examplesite.com)
• Add the owner's email address to the owner's section
• Check the "accept terms and service" box

Just a note – the localhost is for the sole purpose of developing locally. As such, it should be updated before moving to a production environment.

5. Add the reCaptcha to your site

Click the submit button and save your secret keys.

Adding reCaptcha to your site within the .env

6. Add the site keys to the .env file of your project:

RECAPTCHA_SITE_KEY=ADD_YOUR_SITE_KEY
RECAPTCHA_SECRET_KEY=ADD_YOUR_SECRET_KEY
RECAPTCHA_SITE=https://www.google.com/recaptcha/admin/

Since you have made changes to the .env, it's best to clear all cached configurations so that the new changes take effect. Use php artisan optimize:clear in your terminal.

7. Within the config > recaptcha.php file, update the property of the version to V3. It's also important to note that the api_site_key and api_secret_key generated via the admin dashboard will be referenced from what we set in the .env file of the project.

return [
    'version'                      => 'v3'
]

You can now head over to the analytics page of the reCaptcha admin to view how well your site is performing, view your scores, and make decisions when you're in a production environment.

reCaptcha analytics page

The below image shows that reCaptcha has been implemented.

Conclusion

At the end of this article, I hope you'll find it easier to set up reCaptcha and that you'll have a better understanding of what it's all about. Now you should be able to set up the most recent version within your Laravel project.

Resources

• What is reCaptcha?
• Laravel reCaptcha repo
• Laravel reCaptcha docs

For instance, if you're using a REST API and you need a list of books, you might hit the GET /books/list endpoint for all books. Then if you need a specific book by ID, you would hit GET /book?id={id}, which means you'll be making multiple requests to the server.

But GraphQL does something called declarative data fetching, where you can ask for what you want and get a predictable result in a single request.

Awesome right? Let's see how it all works.

What we will be learning?

In this article, you'll learn the basics of GraphQL by using the Laravel GraphQL package to build a server that does the following:

1. Register users
2. Fetch all users
3. Get a user by ID
4. Fetch all posts
5. Fetch all posts with user relationships
6. Finally, as a bonus, you'll also learn how to use the super awesome Postman tool to run your query and get a real-time response

Prerequisites

Here are a few things you'll need for this tutorial:

1. A local server (XAMPP or WAMP)
2. A code editor (Sublime Text, VS Code, or Atom)
3. A version control system (Git)
4. A dependency Manager (Composer)
5. The Laravel GraphQL package

GraphQL Basics

Before we get started, let's go over some GraphQL fundamentals.

What is a GraphQL Schema?

A GraphQL schema describes queries, mutations, and types associated with it:

type User {
    id: ID !
    name : String !
    email : String !
    age : Int
    hobbies: [String]
    created_at : DateTime 
    updated_at : DateTime
}

In the code above, the exclamation mark on column names such as id, name, and email means that they are required fields.

You can also define various data types such as Int, String, and so on. You can also include list types and define the data type it should contain like with hobbies.

What are GraphQL Queries?

GraphQL makes it convenient to interact with data on an object. You use methods to ask for specific fields on objects and then get the expected results:

{
  user {
    name
  }
}

{
  "data": {
    "user": {
      "name": "John doe"
    }
  }
}

What are GraphQL Resolvers?

Every time you request data from a GraphQL server, it gets resolved.

Resolvers contain arguments such as an object, args, context, and info. You'll see how resolvers work while building this project.

How to Get Started with GraphQL

Installation

Set up a Laravel environment by running this command in the terminal:

composer create-project laravel/laravel graphql-laravel

If you don't have composer installed, you can get it from here.

Install the open-source graphql-laravel server package:

composer require rebing/graphql-laravel

Once the installation is finished, publish config/graphql.php:

php artisan vendor:publish --provider="Rebing\GraphQL\GraphQLServiceProvider"

And start the development server with php artisan serve:

The Laravel homepage

How to Create the Migration, Controllers, and Resource

Post

In this section, you'll create a relationship between users and posts.

To do this, you'll need to create models where you define the relationship between the entities, create migrations, and define database schemas.

php artisan make:model Post -mcr

In app/Models/User, create a hasMany relationship between users and posts:

public function posts()
{
    return $this->hasMany(Post::class);
}

And in app/models/Post, define a relationship to map users to posts:

public function user()
{
    return $this->belongsTo(User::class);
}

How to Create the Migration

In this section you'll create the migration.

Laravel already ships with a default User migration. All you need to do now is add a migration for posts:

php artisan make:migration create_post_table

This creates a migration file with the database/migrations direction. Within the migration file, define the schema:

Schema::create('posts', function (Blueprint $table) {
            $table->id();
             $table->integer('user_id')->unsigned();
            $table->string('title');
            $table->text('comment');
            $table->timestamps();
        });

Next, modify the existing .env to name the database and establish a connection:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=graphql-laravel
DB_USERNAME=root
DB_PASSWORD=

Run the migrate command to create the User and Post tables:

 php artisan migrate

You can generate random records for the User and Post tables using Laravel factories.

Since Laravel ships with a default User factory, you can use that and focus on creating a Post factory.

How to Create a Post Factory

php artisan make:factory PostFactory

Once PostFactory gets created within the database > factories directory, you'll have to define the column names and the fakers you need within the definition method:

use Illuminate\Support\Str;


public function definition()
    {
        return [
            'user_id' => rand(1,5),
            'title' => $this->faker->name(),
            'comment' => $this->faker->realText(180)
        ];
    }

How to Make the Database Seeder

Within the seeder class, create an execution instance for both User and Post factories.

This will create five users and five posts with corresponding user_id's:

public function run()
    {
        \App\Models\User::factory(5)->create();

        \App\Models\Post::factory(5)->create();
    }

Then run the artisan seeder command:

php artisan db:seed

Once you run that command in the terminal, check the database tables (User and Post):

Post table

User table

How to Create a User Query

As of the time of writing this article, the Laravel GraphQL package doesn't support creating a scaffold for queries via the terminal.

So add the following to app > GraphQL > Type > UserType.php:

<?php

namespace App\GraphQL\Type;

use App\Models\User;
use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Type as GraphQLType;

class UserType extends GraphQLType
{
    protected $attributes = [
        'name'          => 'User',
        'description'   => 'A user',
        'model'         => User::class,
    ];

    public function fields(): array
    {
        return [
            'id' => [
                'type' => Type::nonNull(Type::int()),
                'description' => 'The id of the user',
            ],
            'name' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The name of user',
            ],
            'email' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The email of user'
            ],
        ];
    }
}

In the code snippet above, you add the namespace you need to the User model. You also include a protected $attributes array that describes the model.

You also added a public field function that returns an array.

Within this function, you define the schema to include columns you specified in the user table (id, name, email).

Type::nonNull(Type::string()) is the exclamation mark indicating the required fields and string data type.

How to Add a Type to the Config

Add the UserType to the config file you created earlier: app > config > graphql.php:

'types' => [
        App\GraphQL\Type\UserType::class
    ],

How to Define the User Query

Next, you'll need to define a query that returns the UserType or a list. You also need to specify the arguments you'll use within the resolve method:

<?php

namespace App\GraphQL\Type;

use GraphQL;
use App\Models\User;
use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Type as GraphQLType;

class UserType extends GraphQLType
{
    protected $attributes = [
        'name'          => 'User',
        'description'   => 'A user',
        'model'         => User::class,
    ];

    public function type(): Type
    {
        return Type::nonNull(Type::listOf(Type::nonNull(GraphQL::type('User'))));
    }

    public function args(): array
    {
        return [
            'id' => [
                'type' => Type::nonNull(Type::int()),
                'description' => 'The id of the user',
            ],
            'name' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The name of user',
            ],
            'email' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The email of user',
            ]
        ];
    }

    public function resolve($root, $args)
    {        
        if (isset($args['id'])) {
            return User::whereId($args['id'])->get();
        }

        if (isset($args['name'])) {
            return User::whereName($args['name'])->get();
        }

        if (isset($args['email'])) {
            return User::whereEmail($args['email'])->get();
        }

        return User::all();
    }
}

In the snippet above, you use the required namespace the package ships with together with App\Models\User.

You also extend the GraphQLType from the Laravel package, and define the attributes as a protected array.

The args method returns an ID, name, and email from the User model.

The resolve method is used to retrieve the data from the database. If there are args, then the if block gets executed and helps you filter based on user requests.

Otherwise, all the data from the User model is retrieved.

How to Add a Query to the Config

Add the following query to the app > config > graphql.php configurations file:

'schemas' => [
        'default' => [
            'query' => [
                App\GraphQL\Query\UsersQuery::class,
            ],
            'mutation' => [
                // ExampleMutation::class,
            ],
            'types' => [
                // ExampleType::class,
            ],
            'middleware' => [],
            'method' => ['get', 'post'],
        ],
    ],

You should now be able to query data from this endpoint: http://localhost:8000/graphql.

And in case you're curious, /graphql is the prefix for the route.

How to Query to Fetch all Users

For this query:

query {
    users {
        id, name , email
    }
}

Here's the expected output with Postman:

Fetch all Users

How to Create a Post Relationship with the User

Now you need to define a PostType.

This approach follows what you defined earlier for UserType.

Navigate to app > Type > PostType.php and add the following:

<?php

namespace App\GraphQL\Type;

use GraphQL;
use App\Models\Post;
use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Type as GraphQLType;

class PostType extends GraphQLType
{
    protected $attributes = [
        'name'          => 'Post',
        'description'   => 'A post',
        'model'         => Post::class,
    ];

    public function args(): array
    {
        return [
            'id' => [
                'type' => Type::nonNull(Type::int()),
                'description' => 'The id of the post',
            ],
            'title' => [
                'type' => Type::nonNull(Type::string()),
                'description' => 'The title of post',
            ],
        ];
    }
}

Post follows the specification defined for User. Here you also used the namespace of the query, and also used the Post model.

With the code above, you extend the Query on the PostQuery class and set the $attributes array to be protected. And you have a fields function that returns and array with the ID, title, and comment.

Finally, you have a type within the args function that shows their various data types int or string with a description that tells you what they do at a glance.

How to Create a PostsQuery

Add the following to app > GraphQL > Query > PostsQuery.php:

<?php 

namespace App\GraphQL\Query;

use Closure;
use App\Models\Post;
use Rebing\GraphQL\Support\Facades\GraphQL;
use GraphQL\Type\Definition\ResolveInfo;
use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Query;

class PostsQuery extends Query
{
    protected $attributes = [
        'name' => 'posts',
    ];

    public function type(): Type
    {
        return Type::nonNull(Type::listOf(Type::nonNull(GraphQL::type('Post'))));
    }

    public function args(): array
    {
        return [
            'id' => [
                'name' => 'id', 
                'type' => Type::int(),
            ],
            'title' => [
                'name' => 'title', 
                'type' => Type::string(),
            ]
        ];
    }

    public function resolve($root, $args)
    {        
        if (isset($args['id'])) {
            return Post::whereId($args['id'])->get();
        }

        if (isset($args['title'])) {
            return Post::whereTitle($args['title'])->get();
        }

        return Post::all();
    }
}

In the code above, you use the resolve method to retrieve data from the database like I mentioned earlier.

If there are args, then the if block gets executed and helps you filter based on the user request. Otherwise, all the data from the Post model is returned.

How to Add PostsQuery and PostType to Config

'schemas' => [
        'default' => [
            'query' => [
                App\GraphQL\Query\UsersQuery::class,
                App\GraphQL\Query\PostsQuery::class
            ],
            'mutation' => [
                // ExampleMutation::class,
            ],
            'types' => [
                // ExampleType::class,
            ],
            'middleware' => [],
            'method' => ['get', 'post'],
        ],
    ],

'types' => [
        App\GraphQL\Type\UserType::class,
        App\GraphQL\Type\PostType::class
    ],

Now you can use the following query to get all posts:

query{
    posts{
        id
        user_id
        title
        comment
    }
}

Image of Fetch all post

You can also fetch users with post relationships with this query:

query{
    users{
        id 
        name
        posts {
            title
        }
    }
}

Image to fetch users with post relationship

How to Create a Mutation

Now you'll set up a mutation to create a user. This mutation will help with operations that involve modifying state on the server.

In your case you'll be mutating the state of the server by creating a user.

Create a mutation folder within the app directory, app > Mutation > CreateUserMutation.php.

Then add the following code to CreateUserMutation.php:

<?php

namespace App\GraphQL\Mutation;

use Closure;
use App\Models\User;
use GraphQL;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\ResolveInfo;
use Rebing\GraphQL\Support\Mutation;

class CreateUserMutation extends Mutation
{
    protected $attributes = [
        'name' => 'users'
    ];

    public function type(): Type
    {
        return Type::nonNull(GraphQL::type('User'));
    }

    public function args(): array
    {
        return [
            'name' => ['
                name' => 'name', 
                'type' => Type::nonNull(Type::string()),
            ],
            'email' => ['
                name' => 'email', 
                'type' => Type::nonNull(Type::string()),
            ],
            'password' => [
                'name' => 'password', 
                'type' => Type::nonNull(Type::string()),
            ]
        ];
    }

    public function resolve($root, $args, $context, ResolveInfo $resolveInfo, Closure $getSelectFields)
    {
        return User::firstOrCreate(
            [   'email' => $args['email']],
            [   'name' => $args['name'],
                'password' => bcrypt($args['password'])
            ]);
    }
}

The resolve method helps users of the application sign up and create their record. resolve accepts args as a parameter and then uses the firstOrCreate method to ensure all users registering have a unique identifier, in this case, their email address.

In the config, you'll also need to include the mutation you just created:

'schemas' => [
        'default' => [
            'query' => [
                App\GraphQL\Query\UsersQuery::class,
                App\GraphQL\Query\PostsQuery::class
            ],
            'mutation' => [
                App\GraphQL\Mutation\CreateUserMutation::class,
            ],
            'types' => [],
            'middleware' => [],
            'method' => ['get', 'post'],
        ],
    ],

And here's how to create a user:

mutation{
    users(name : "John Doe", email : "Johndoe@gmail.com", password : "John1234"){
        id
        name
    }
}

Image of user creation

Conclusion

Congrats! You've successfully built a GraphQL server using Laravel, and ran queries with Postman to get responses. Now that you know the basics of GraphQL, I hope you use it in your projects going forward.

All the code in this tutorial is available on GitHub, which also includes the Postman collection.

Resources

• GraphQL website
• Laravel GraphQL
• How to use GraphQL with Postman

Orchestration simply means that it automates the workflow processes that occurs in order to deliver resources as a service on the cloud.

In this tutorial, we will be walking through the simple steps to set Elastic Beanstalk up locally. Setting it up locally means that we will be able to interact directly with AWS from the terminal and push our deployed applications to the cloud via the commands provided by EB .

Benefits of Elastic Beanstalk

Elastic Beanstalk allows your data to persist after the elastic cloud compute instance is terminated. Data stored on the volume are still accessible.

Also, it helps you avoid component failure by offering high availability and durability.

How to Install the Elastic Beanstalk CLI

The Elastic Beanstalk CLI is a command line interface that allows users to create, setup, and manage processes on Elastic Beanstalk.

To install EB in our local environment, we need to check out the open-source aws-elastic-beanstalk-cli-setup project. There we'll find installation guides to help with the process.

Step 1:

Clone the repository into our local environment. If you don't have a Github account, you can sign up here.

git clone https://github.com/aws/aws-elastic-beanstalk-cli-setup.git

Step 2:

In this section we have to download zlib and configure it. Zlib is a library used for compression and decompression. EB leverages this feature when it needs to compress and decompress data (strings, structured in-memory content, or files).

brew install zlib openssl readline
CFLAGS="-I$(brew --prefix openssl)/include -I$(brew --prefix readline)/include -I$(xcrun --show-sdk-path)/usr/include" LDFLAGS="-L$(brew --prefix openssl)/lib -L$(brew --prefix readline)/lib -L$(brew --prefix zlib)/lib"

Step 3:

Once the installation is done, we'll export and setup paths for the environment variables for zlib. Run the following in the command line:

$ export LDFLAGS=$LDFLAGS:-L/usr/local/opt/zlib/lib
$ export CPPFLAGS=$CPPFLAGS:-I/usr/local/opt/zlib/include
$ export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:~/usr/local/opt/zlib/lib/pkgconfig

To view if the paths were correctly set, run this command:

$ echo $LDFLAGS $CPPFLAGS $PKG_CONFIG_PATH

Step 4:

Back in our terminal where we pulled the repository, we need to run the bundled installer with the code below:

$ ./aws-elastic-beanstalk-cli-setup/scripts/bundled_installer

Once the process is complete you'll see an output that looks something like this:

Step 5:

To complete the installation process, we need to add eb and python to our environment path as well. We can do this by running this code in the terminal:

$ echo 'export PATH="/Users/user/.ebcli-virtual-env/executables:$PATH"' >> ~/.bash_profile && source ~/.bash_profile
$ echo 'export PATH=/Users/user/.pyenv/versions/3.7.2/bin:$PATH' >> /Users/user/.bash_profile && source /Users/user/.bash_profile

Once we are done adding the paths, we can now try to initialize an Elastic Beanstalk and see if we get a list of selected regions. Run this in the terminal:

$ eb init

And you should see the following:

Voilà! We have a list of regions that we can choose from and we can add our credentials from an S3 bucket on AWS. We can also run other EB commands such as eb create, eb deploy, and a lot more.

References

• AWS Elastic Beanstalk Developer Guide
• Compression with zlib

It took me a considerable amount of time to figure out how facades work, and I'm writing this to help anyone who is having trouble wrapping their heads around the concept.

In this article we'll cover what facades are, how they're used in Laravel, how you can build your own simple facade, and more.

What is a facade? And what is a wrapper?

A facade in Laravel is a wrapper around a non-static function that turns it into a static function.

The word "wrapper" can also be used when describing design patterns. Wrapping an object to provide a simplified interface to it is often described as the "facade" pattern.

So in short, the wrapper is the facade.

Before diving deeper into facades, it's important to understand what static and non-static functions are in PHP.

Static Methods

In Static methods we're not required to create an instance of a class to reference it. Static methods use double colons (::) when accessing properties or methods of a class:

<?php
class Calc {
    const GOLDEN_RATIO = '1.618';
}

echo Calc::GOLDEN_RATIO;  //1.618

Reserved keywords like self , static and parents is used to reference properties or methods within a class:

<?php
class backend {
    private const language = "php";
    public static function language() {
        echo self::language;
      }
}

backend::language();  //php

Non-static Methods

Non-static methods require that a given class be instantiated. In other words, they require an instance of the class to execute:

<?php
class backend{

    public function language($name){

        echo $name;
    }

}


$test = new backend; //creating an instance of the class

$test->language('php'); //php

Now that we've gone over static and non-static methods, we can dive deeper into facades in Laravel.

Laravel facades

In the vendors > laravel > framework > src > illuminate > support > Facades directory, there's a list of files which are the various facades that ship with Laravel by default.

Here's a screenshot of what the directory structure actually looks like in our editor:

Let's use the working code from Log.php to examine facades in more detail – the same explanation should apply to all facades in any Laravel application.

Laravel's Log facade

Here's the code for Laravel's Log facade:

<?php

namespace Illuminate\Support\Facades;

class Log extends Facade
{
    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'log';
    }
}

Log is a class that extends the base facade which is from the namespace above.

Within the Log class we have a protected access modifier, getFacadeAccessor, and what that method does is it just returns log.

The name of this facade, log, is being returned so we can access the named facade anywhere within the Laravel application without initializing it. So we can do something like Log::info('hello there'); anywhere really easily.

As you can see, facades make code easier to read, more organized, and make testing 10 times easier.

Since learning about Log from one of my co-workers, it's been my favorite debugging tool.

How to create a facade in Laravel

In this section we'll implement our own facade. The main objective here is to help learners understand how Laravel facades work.

We'll do this by creating a StudentFacade which will extend properties from a base Facade that returns a name property after it has been resolved. This name property will be of type string and it will be returned each time we instantiate the class as shown below:

Curious how we will achieve this? Follow along as I'll be walking you through the steps.

We won't be creating our facade using the normal Laravel convention where we have a .php file in app > facade and then another in the providers before we end up registering it in the config > app.

Instead, we will make do with the web.php inside the routes for this illustration since we're just trying to see how facades work under the hood in a typical Laravel application.

First, let's start with this in web.php:

<?php 
class Student{
    public function students(){
        return 'Sean';
    }
}

 app()->bind('student', function(){
     return new Student;   
 });

We've created a class Student, and inside it we have a non-static students method that returns an array of students.

Then we call the bind method to make it always instantiate new Student so we don't need to do this manually anymore.

Next, let's create a base Facade class still within the same web.php:

 class Facade{
    public static function __callStatic($name, $args){
        return app()->make(static::getFacadeAccessor())->$name();
    }

    protected static function getFacadeAccessor(){
        //override take place 
    }
}

Any facade we might create later will be extending the properties of this base facade.

Within the Facade class we have a __callStatic magic method that helps us resolve the static::getFacadeAccessor() from the container with app()->make(). And with those we're able to access the $name property.

class StudentFacade extends Facade {
    protected static function getFacadeAccessor(){
        return 'student';
    }
}

Here, StudentFacade inherits the properties of the base facade. Then we override getFacadeAccessor() and set the return value to be whatever we have each time we instantiate in the bind above student.

StudentFacade::students(); //output "Sean"

When we try to call the facade which we created it returns "Sean" as expected. Now in the final step we have to put all these steps together:

<?php

class Student{
    public function students(){
        return 'Sean';
    }
}

 app()->bind('student', function(){
    return new Student;   
 }); 


 class Facade{
    public static function __callStatic($name, $args){
        return app()->make(static::getFacadeAccessor())->$name();
    }

    protected static function getFacadeAccessor(){
        //override take place 
    }
}

class StudentFacade extends Facade {
    protected static function getFacadeAccessor(){
        return 'student';
    }
}

//log or die it to the output
dd(StudentFacade::students());

Conclusion

I hope that by the end of this lesson you have been able to broaden your knowledge about facades work. If you have questions or wish to continue the conversation feel free to tweet at me.

References

Laravel Beginner tutorial - Bitfumes

What is WRAPPER in programming, what does it help to do? - Stackoverflow

It took me a while to figure out how it's done, but now I can share that knowledge with you all in this write up. By the end you will be able to launch Sublime Text from bash.

Prerequisites:

• Make sure you have Sublime text editor set up
• Make sure you have Git installed

Getting started

Sublime text is a source code editor that helps software developers code and edit text or markup.

It has amazing features such as syntax highlighting, indentation, plugins and packages. All these features help make it easier and more comfortable to work with and contribute to a wide variety of programming language code bases.

Once you've downloaded and installed Sublime, it will be located within the program files as shown below:

What we want to do is create an alias for the sublime_text.exe found within the Sublime Text 3 folder. Then when we type the alias into Git bash it auto launches the text editor.

How to Configure Git Bash with Sublime Alias

To begin configuring Git bash, we first need to open the bash terminal. Then we can proceed to explore various Linux commands in order to complete the configuration process .

First, we need to create a .bashrc file using the touch command. It's important that the file be created within the C:\Users\username\ directory – otherwise you will get a permission denied error.

I have created the bash file within the specified directory, so mine looks like C:\Users\larry.bashrc.

Next we need to edit the .bashrc file to include the alias we'll need to launch Sublime text:

When we click on enter we will see an interface that looks somewhat like what we have below. Then you need to press i to enter the insert mode.

Now you have access and can type into the prompt. So we can add our alias there now, like this:

alias subl='C:/Program\ Files/Sublime\ Text\ 3/sublime_text.exe'

Once we've included that, we can press esc to exit insert mode and then :wq to save and exit.

Once we are done with that we can head back to our bash to check if our configuration worked by doing subl as shown below:

Yes, it works! And you can see Sublime Text launch itself.

I also figured out that if you have a working directory you can force Sublime to open that directory. I will navigate into a code base now and show the difference in the next screenshot:

From the screenshot above, Sublime doesn't just launch a blank workspace – it launches with all project folders associated with that project. That's because we added a wildcard to the command.

I hope with this hack you will be able to setup an alias for Sublime Text. I really appreciate the answers on this stack overflow thread. It helped me form the knowledge I was able to share in this article .

Laravel is an open source PHP framework used to develop web applications. It follows the model-view-controller architectural pattern.

Prerequisites

1. Install composer
2. Set up your local server (xampp, wamp)
3. Make sure you have a code editor installed (sublime text, vs code, atom etc)
4. Install Git (enables source control & versioning)

Getting Started

With Git installed you have access to Git bash. With bash open you can work with the terminal to run commands that lets you install and use Laravel and its packages easily.

Install Laravel via composer

Once you have satisfied all the above conditions, we will use the below command to set up the Laravel installer:

composer global require laravel/installer

The above command lets us download the Laravel installer using composer that we installed earlier.

laravel new project_name

This installation process takes a while so just be patient. Note that the installation will be done in the directory you specify in your bash terminal or any terminal you choose to use.

Generating a basic authentication scaffold

Once we have a copy of the Laravel app installed we should generate a basic authentication scaffold.

cd project_name

composer require laravel/ui

php artisan ui vue --auth

The above command will install layout view, registration view, and login view, as well as routes for all user authentication.

Setting up environment variables in the .env file

Next we need to set up our environment variables and establish a connection to our database (in this article we'll use a shared dummy ip address).

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=your_database_name
DB_USERNAME=server_username
DB_PASSWORD=server_password


MAIL_DRIVER=smtp
MAIL_HOST=domain.com
MAIL_PORT=465
MAIL_USERNAME=noreply@domain.com
MAIL_PASSWORD=domain_password
MAIL_ENCRYPTION=ssl
MAIL_FROM_ADDRESS=noreply@domain.com
MAIL_FROM_NAME="${APP_NAME}"

Now we're done setting up the database connection. In my case I work with Xampp where I have DB_USERNAME=root and DB_PASSWORD=. Also don't forget to start your local server as shown below.

Image of xampp server

Versioning the database and starting the development server

Before you can run migrations in Laravel you need to establish a connection to your database. Since I have specified your_database_name in the .env configuration above I can click "create" and phpMyAdmin will build an empty database.

Adding a database name

In Git bash, navigate or cd into the project_name directory and run the below command:

cd project_name

php artisan migrate

This will run all default Laravel migrations in our application as long as you have created a matching DB_DATABASE which we created above.

php artisan serve

We can now start our development server:

Starting development server

Creating a contact.blade.php file

Set up a contact page in the resources > views folder like this:

@extends('layouts.client.app')

@section('content')

<!-- contact section -->
    <div class="contact">
        <div class="container">
            <div class="row justify-content-center">
                <div class="col-xl-7 col-lg-8 col-md-8">
                    <div class="section-title">
                        <h2>Contact Us</h2>
                    </div>
                </div>
            </div>

            @if(session('status'))
            <div class="row justify-content-center">
                <div class="col-xl-8 col-lg-8 col-md-8">
                    <div class="alert alert-success alert-dismissible fade show" role="alert">
                        <strong>Success ! </strong>  &nbsp; {{ session('status') }}
                        <button type="button" class="close" data-dismiss="alert" aria-label="Close">
                            <span aria-hidden="true">&times;</span>
                        </button>
                    </div>
                </div>
            </div>
            @endif
        </div>
    </div>
@endsection

The above code snippet will extend a layouts file containing the header section. It also contains the section title "Contact Us" along with a message that's been returned and displayed to the User if and only if the mail message was successfully sent.

The main focus here is on the form section that you can see in the next code snippet:

<div class="row justify-content-center">
    <div class="col-xl-8 col-lg-8">
        <div class="login-form">
            <form method="POST" action="{{ route('addContact') }}" enctype="multipart/form-data">
                @csrf
                <div class="row">

                    <div class="col-6">
                        <div class="form-group">
                            <label for="name" class="col-form-label text-md-right">{{ __('Full Name') }}</label>

                            <input type="text" class="form-control @error('fullname') is-invalid @enderror" name="fullname" value="{{ isset(Auth::user()->firstname) ? Auth::user()->firstname : '' }} {{ isset(Auth::user()->lastname) ? Auth::user()->lastname : '' }}" required autocomplete="Fullname" autofocus>

                            @error('fullname')
                                <span class="invalid-feedback" role="alert">
                                    <strong>{{ $message }}</strong>
                                </span>
                            @enderror
                        </div>
                    </div>

                    <div class="col-6">

                        <div class="form-group">
                            <label for="email" class="col-form-label text-md-right">{{ __('Email Address') }}</label>

                            <input type="email" class="form-control @error('email') is-invalid @enderror" name="email" value="{{ isset(Auth::user()->email) ? Auth::user()->email : '' }}" required autocomplete="email" autofocus>

                            @error('email')
                                <span class="invalid-feedback" role="alert">
                                    <strong>{{ $message }}</strong>
                                </span>
                            @enderror
                        </div>

                    </div>

                    <div class="col-6">

                        <div class="form-group">
                            <label for="name" class="col-form-label text-md-right">{{ __('Phone Number') }}</label>

                            <input type="text" class="form-control @error('phone_number') is-invalid @enderror" name="phone_number" value="{{ isset(Auth::user()->phone_number) ? Auth::user()->phone_number : '' }}" required autocomplete="phone_number" autofocus>

                            @error('phone_number')
                                <span class="invalid-feedback" role="alert">
                                    <strong>{{ $message }}</strong>
                                </span>
                            @enderror
                        </div>
                    </div>

                    <div class="col-6">


                        <div class="form-group">
                            <label for="name" class="col-form-label text-md-right">{{ __('Subject') }}</label>

                            <input type="text" class="form-control @error('subject') is-invalid @enderror" name="subject" required autofocus>

                            @error('subject')
                                <span class="invalid-feedback" role="alert">
                                    <strong>{{ $message }}</strong>
                                </span>
                            @enderror
                        </div>
                    </div>

                    <div class="col-6">
                        <div class="form-group">

                            <label for="password" class="col-form-label text-md-right">{{ __('Message') }}</label>

                            <textarea class="form-control @error('message') is-invalid @enderror" name="message" required></textarea>

                            @error('message')
                                <span class="invalid-feedback" role="alert">
                                    <strong>{{ $message }}</strong>
                                </span>
                            @enderror
                        </div>
                    </div>

                    <div class="col-6">

                        <div class="form-group">
                            <label for="name" class="col-form-label text-md-right">{{ __('Attach Screenshot') }}</label>

                            <input type="file" accept="image/*" class="form-control @error('screenshot') is-invalid @enderror" name="screenshot" autofocus>

                        </div>
                    </div>
                </div>

                <div class="form-group row mb-0">
                    <div class="col-md-6 offset-md-4">
                        <button type="submit" class="btn btn-primary">
                            {{ __('Send Message') }}
                        </button>
                    </div>
                </div>
            </form>
        </div>
    </div>
</div>

The snippet above contains the various input fields that we will use in processing user information. The fields include FULLNAME, EMAIL ADDRESS, PHONE NUMBER , SUBJECT or PURPOSE , MESSAGE , IMAGE UPLOAD (if any) and finally a SEND MESSAGE button to process the submission of the form.

Next we will merge both code snippets together to make them lot more meaningful.

@extends('layouts.client.app')
@section('content')
<div class="contact">
    <div class="container">
        <div class="row justify-content-center">
            <div class="col-xl-7 col-lg-8 col-md-8">
                <div class="section-title">
                    <h2>Contact Us</h2>
                </div>
            </div>
        </div>

        @if(session('status'))
        <div class="row justify-content-center">
            <div class="col-xl-8 col-lg-8 col-md-8">
                <div class="alert alert-success alert-dismissible fade show" role="alert">
                    <strong>Success ! </strong>  &nbsp; {{ session('status') }}
                    <button type="button" class="close" data-dismiss="alert" aria-label="Close">
                        <span aria-hidden="true">&times;</span>
                    </button>
                </div>
            </div>
        </div>
        @endif
        <div class="row justify-content-center">
                <div class="col-xl-8 col-lg-8">
                    <div class="login-form">
                        <form method="POST" action="{{ route('addContact') }}" enctype="multipart/form-data">
                            @csrf
                            <div class="row">

                                <div class="col-6">
                                    <div class="form-group">
                                        <label for="name" class="col-form-label text-md-right">{{ __('Full Name') }}</label>

                                        <input type="text" class="form-control @error('fullname') is-invalid @enderror" name="fullname" value="{{ isset(Auth::user()->firstname) ? Auth::user()->firstname : '' }} {{ isset(Auth::user()->lastname) ? Auth::user()->lastname : '' }}" required autocomplete="Fullname" autofocus>

                                        @error('fullname')
                                            <span class="invalid-feedback" role="alert">
                                                <strong>{{ $message }}</strong>
                                            </span>
                                        @enderror
                                    </div>
                                </div>

                                <div class="col-6">

                                    <div class="form-group">
                                        <label for="email" class="col-form-label text-md-right">{{ __('Email Address') }}</label>

                                        <input type="email" class="form-control @error('email') is-invalid @enderror" name="email" value="{{ isset(Auth::user()->email) ? Auth::user()->email : '' }}" required autocomplete="email" autofocus>

                                        @error('email')
                                            <span class="invalid-feedback" role="alert">
                                                <strong>{{ $message }}</strong>
                                            </span>
                                        @enderror
                                    </div>

                                </div>

                                <div class="col-6">

                                    <div class="form-group">
                                        <label for="name" class="col-form-label text-md-right">{{ __('Phone Number') }}</label>

                                        <input type="text" class="form-control @error('phone_number') is-invalid @enderror" name="phone_number" value="{{ isset(Auth::user()->phone_number) ? Auth::user()->phone_number : '' }}" required autocomplete="phone_number" autofocus>

                                        @error('phone_number')
                                            <span class="invalid-feedback" role="alert">
                                                <strong>{{ $message }}</strong>
                                            </span>
                                        @enderror
                                    </div>
                                </div>

                                <div class="col-6">


                                    <div class="form-group">
                                        <label for="name" class="col-form-label text-md-right">{{ __('Subject') }}</label>

                                        <input type="text" class="form-control @error('subject') is-invalid @enderror" name="subject" required autofocus>

                                        @error('subject')
                                            <span class="invalid-feedback" role="alert">
                                                <strong>{{ $message }}</strong>
                                            </span>
                                        @enderror
                                    </div>
                                </div>

                                <div class="col-6">
                                    <div class="form-group">

                                        <label for="password" class="col-form-label text-md-right">{{ __('Message') }}</label>

                                        <textarea class="form-control @error('message') is-invalid @enderror" name="message" required></textarea>

                                        @error('message')
                                            <span class="invalid-feedback" role="alert">
                                                <strong>{{ $message }}</strong>
                                            </span>
                                        @enderror
                                    </div>
                                </div>

                                <div class="col-6">

                                    <div class="form-group">
                                        <label for="name" class="col-form-label text-md-right">{{ __('Attach Screenshot') }}</label>

                                        <input type="file" accept="image/*" class="form-control @error('screenshot') is-invalid @enderror" name="screenshot" autofocus>

                                    </div>
                                </div>
                            </div>

                            <div class="form-group row mb-0">
                                <div class="col-md-6 offset-md-4">
                                    <button type="submit" class="btn btn-primary">
                                        {{ __('Send Message') }}
                                    </button>
                                </div>
                            </div>
                        </form>
                    </div>
                </div>
        </div>
    </div>
</div>
@endsection

The image below is a simple layout of what the contact page looks like right now.

Contact us page

Add routes to enable GET & POST requests

First, we'll set up the routes in routes > web.php to render the contact page via a GET request and send mails via the POST request (which has been specified in the form attribute above).

Route::get('/contact', 'HomeController@index')->name('contact');

Route::post('/contact', 'HomeController@send_mail')->name('addContact');

Adding logic within the HomeController

In app > Http > Controllers, Laravel scaffold generated a HomeController.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class HomeController extends Controller
{
    public function index()
    {
        return view('template.client.contact'); //renders the contact page
    }

}

The Controller file is where the logic of the application resides. Laravel Scaffold already generated the default HomeController. So we will make do with that and create a function named index. We will use it to render the contact us page each time the user visits the route or URL in the application.

<?php

use Illuminate\Support\Facades\Mail;

use App\Mail\ContactFormMail;

class HomeController extends Controller
{
    public function send_mail(Request $request)
    {
        $this->validate($request, [
            'fullname' => ['required', 'string', 'max:255' ], 
            'email' => ['required', 'string', 'email', 'max:255' ],
            'phone_number' => ['string', 'max:255'],
            'subject' => ['required', 'string', 'max:255'],
            'message' => ['required', 'string', 'max:255']
        ]);

        $contact = [
            'fullname' => $request['fullname'], 
            'email' => $request['email'],
            'phone_number' => $request['phone_number'],
            'subject' => $request['subject'],
            'message' => $request['message'],
            'screenshot' => $request->file('screenshot')->store('contact', 'public')
        ];


        Mail::to('receipent@domain.com')->send(new ContactFormMail($contact));

        return redirect()->route('contact')->with('status', 'Your Mail has been received');
    }
}

In the same HomeController, we need to create another function named send_mail . The function will validate all user input and check to make sure fields are not left empty and the right data is parsed.

Next create a variable called $create to store the array values of all user data including image uploads.

Laravel ships with a filesystem that lets us work with images easily. The Mail::to(....)and send ship with Illuminate\Support\Facade which I included at the top of the snippet. I have also included a Mailable, which I will explain soon.

We now need to alert users when the message has been dispatched and redirect them.

Bringing the code snippets together now will make the HomeController look somewhat like this:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Illuminate\Support\Facades\Mail;

use App\Mail\ContactFormMail;

class HomeController extends Controller
{
    public function index()
    {
        return view('template.client.contact'); //renders the contact page
    }

    public function send_mail(Request $request)
    {
        $this->validate($request, [
            'fullname' => ['required', 'string', 'max:255' ], 
            'email' => ['required', 'string', 'email', 'max:255' ],
            'phone_number' => ['string', 'max:255'],
            'subject' => ['required', 'string', 'max:255'],
            'message' => ['required', 'string', 'max:255']
        ]);

        $contact = [
            'fullname' => $request['fullname'], 
            'email' => $request['email'],
            'phone_number' => $request['phone_number'],
            'subject' => $request['subject'],
            'message' => $request['message'],
            'screenshot' => $request->file('screenshot')->store('contact', 'public')
        ];


        Mail::to('receipent@domain.com')->send(new ContactFormMail($contact));

        return redirect()->route('contact')->with('status', ' Your Mail has been received');
    }
}

Having merged both of the above functions, we are done with the logic for the HomeController. Now let's proceed to the next step.

Generating Laravel Mailable

Each mail sent within the Laravel application is represented as a "mailable" just in case you're wondering about the name. Let's create a markdown mailable for contact information that we want to process:

php artisan make:mail ContactFormMail --markdown=template.client.contactform

The command above will generate a markdown file in the resources > views > template > client directory and also create a mailable file in app > Mail > ContactFormMail.php.

In ContactFormMail.php we have the following code snippet that lets us send mails without an attachment:

<?php

namespace App\Mail;
use App\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;

class ContactFormMail extends Mailable
{
    use Queueable, SerializesModels;

    /**
    * Create a new message instance.
    *
    * @return void
    */

    public function __construct($data)
    {
        $this->user = $data;
    }

    /**
     * Build the message.
     *
     * @return $this
     */
    public function build()
    {
        return $this->from('noreply@domain.com')
                ->markdown('template.client.contactform')
                ->with([
                        'subject' => $this->user['subject'],
                        'message' => $this->user['message'],
                        'email' => $this->user['email'],
                        'phone_number' => $this->user['phone_number'],
                        'fullname' => $this->user['fullname'],
                    ]);
    }
}

Let's break this code down a bit.

In the **_construct** method I'm parsing all user data as a parameter and reassigning it. In the **build** method, all of the mailable class configuration is done.

The **from** Method specifies the mail sender, that is who the mail is coming from (in my case noreply@domain.com).

The **with** Method lets you choose to customize how mails will be rendered to the markdown which was generated. In this article we will assign all the fields to key and value pairs within the array so that within the markdown we can access each value with its own unique key.

The **markdown** Method accepts the name the of markdown template to be rendered with an optional data parameter (if we weren't making use of the **with** method).

And lastly, the **to** Method specifies the recipient of the mail. In the HomeController above, change 'receipent@domain.com' to the actual recipient's address.

Add Data to the Markdown File

Now we need to configure the markdown file in the resources > views > template > client directory. Since we have key value pairs in place already, it's easier to reference with keys in the markdown file as shown below:

@component('mail::message')
# {{$subject}}

## {{$message}}

Feel free to contact me via {{$phone}} or {{$email}}

Thanks,<br>
{{$fullname}}

{{ config('app.name') }}
@endcomponent

At this point we're almost done ???. Kudos for following along with the process this far. You have now learned how to send an email without attachment. Now let's look at how to do it with an attachment.

Sending Mails with an Attachment

Laravel already ships with a powerful filesystem, so sending mails with an attachment isn't too difficult. We will leverage this feature and create storage for users where we will store their attached files within the application.

php artisan storage:link

NOTE : In HomeController above I already specified a storage directory for the uploads. You should do same by creating a folder (called contact) in storage > app > public > contact .

Also in the config > filesystems.php check and make sure the default filesystem disk is set to return ['default' => 'public'].

Now the ContactFormMail.php looks like this. We are now able to use the attachFromStorage method which makes reference to the filepath.

<?php

namespace App\Mail;
use App\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;

class ContactFormMail extends Mailable
{
    use Queueable, SerializesModels;

    /**
    * Create a new message instance.
    *
    * @return void
    */
    public $user;

    public function __construct($data)
    {
        $this->user = $data;
    }

    /**
     * Build the message.
     *
     * @return $this
     */
    public function build()
    {
        return $this->from('noreply@domain.com')
                ->markdown('template.client.contactform')
                ->attachFromStorage($this->user['screenshot'])
                ->with([
                        'subject' => $this->user['subject'],
                        'message' => $this->user['message'],
                        'email' => $this->user['email'],
                        'phone_number' => $this->user['phone_number'],
                        'fullname' => $this->user['fullname']
                    ]);
    }
}

The only addition here will be attachFromStorage. It is used to process the attached files (either image or pdf) during the entire mailing process.

In the markdown file that we earlier used, we can slightly rework it to look like what's shown below:

<div class="row">
    <h1 class="text-dark">{{$subject}}</h1>

    <h3>{{$message}}</h3> 

    <h4>You can reach me via mail or telephone : {{$email}} or {{$phone_number}}<br/>
    Thanks
    </h4>
</div>

Screenshot of successful mail message

Yaaay we can now do a happy dance because we're finally done ?????

via GIPHY

Now that you've made it through the entire article, you should be able to implement a similar emailing feature in your Laravel applications.

To learn more you can check out the official Laravel documentation here.