DEV Community: Ikechukwu Vincent

This turned out to be my best-performing technical article. Unfortunately I do not have the time to write more like it.

Ikechukwu Vincent — Tue, 14 Jan 2025 09:21:25 +0000

Linked List Implementation in C with User Input

Ikechukwu Vincent ・ Jul 31 '22

#c #datastructure #algorithms #beginners

How Documentation Can Help Your Team Scale

Ikechukwu Vincent — Wed, 23 Oct 2024 17:54:20 +0000

Coming from a software engineering background, many developers understand the importance of scaling applications to handle increased traffic and functionality. However, fewer people are familiar with what it takes to scale a team effectively. Scaling a team from 2 to 10, or 10 to 30, in a short amount of time can introduce challenges that, if not handled properly, can lead to decreased productivity, and missed deadlines.

The goal of expanding a team is to increase speed and output. In a well-structured, scalable team, this is exactly what happens—new members bring fresh perspectives and boost development velocity. But in many cases, adding more people without proper structures in place can have the opposite effect, slowing down development.

I once joined a team of four—three engineers and one quality assurance (QA) professional—brought in to help a West African fintech company launch its product in just three months. Initially, I was confident that I could handle the task solo in about a month - at least the backend. But instead of speeding things up, our presence as an external team actually slowed things down. Aside scalability, another aspect of a team that many don’t pay enough attention to is resilience.

The Resilience of a Scalable Team
One of the key aspects of scalability in a team is its resilience—the ability of the team to continue functioning smoothly even when certain individuals leave or become unavailable. If the departure of a few key team members can halt the entire project, it's a sign that the team isn't scalable. I've seen this play out many times when clients have to restart a project from scratch just because they replaced a developer.

A truly scalable team should be able to withstand turnover and changes in personnel without losing momentum. This is where proper documentation becomes crucial.

Why Did We Fail to Speed Up the Team?
Reflecting on my experience with the fintech startup, several factors contributed to the slowdown:

Lack of Clear Documentation: On my first day, I spent almost a full day trying to set up the Laravel project because migrations were failing. It turned out that many business logic decisions had been placed inside the migration files, which also included seeding logic. No one told me this and this is deviation from Laravel convention. Instead, I was handed a dump MySQL file. It was much later that I realized the dump file wasn’t just to populate tables, but to create them.

Unclear Coding Standards: When I finally managed to get my code ready for review, it took over 48 hours of back-and-forth to get it approved. At one point, I realized the team had a set of unwritten rules—do’s and don'ts—that they never shared with me. When I asked for their coding style guide, they gave me an outdated style guide, which only partially helped.

Duplicate Codebases: Another hurdle was discovering that the application had two separate Laravel installations—one for the admin panel and another for public-facing features. Often, we had to build similar features on both sides. But if we wrote code for one side without realizing a similar feature already existed on the other, our code would be rejected for "unnecessary duplication." In some cases, entire days of work were thrown out because the same functionality already existed elsewhere, or because we hadn’t used an internal library that did the same thing. So why were we not informed?

These issues wasted valuable time. Not only did we (the external team) spend days figuring out these quirks, but the in-house team also wasted time walking us through them during pull request (PR) reviews and calls. This time could have been spent writing new code and shipping features. In the end both in-house dev team, external team, business wonders of both sides were frustrated.

How Can Teams Avoid These Problems and Scale Faster?
A month or so later, I joined a small fintech startup to help build its first in-house infrastructure with a small team. From day one, I used careful reflection from past experience to set the environment ready for team scaling. I realized the key to avoiding these roadblocks and scaling a team effectively lies in creating a solid foundation of documentation. Here’s how you can ensure that adding new team members increases, rather than decreases, your team’s productivity:

Detailed Documentation: Every engineering team should treat documentation as a core part of its culture, not an afterthought. Good documentation doesn’t just cover API endpoints but also includes:

Internal reusable libraries.
Engineering decisions and the rationale behind them.
A map of the codebase, with explanations for key sections.
Global helpers and libraries, with examples or demos of their usage.
System and infrastructure architecture
.
This type of documentation allows new team members to understand the codebase quickly, reducing the need for constant one-on-one help from existing developers. This, in turn, frees up more time for your in-house team to focus on writing code and building new features instead of answering repetitive questions.

Coding Style Guides:
A clear, up-to-date coding style guide is essential for ensuring consistency across the team. It helps ensure that everyone writes code in a similar way, reducing friction during code reviews. But a style guide is only the start—teams also need to document specific practices unique to their project, like why certain architectural decisions were made and when to use custom-built libraries.

Standardized Onboarding:
As your team grows, onboarding becomes one of the most critical factors in determining whether new hires will integrate smoothly or become a drain on productivity. A standardized onboarding process, built on solid documentation, can help new team members get up to speed quickly. This includes documentation on the tools your team uses, the workflow you follow, and the architecture of the codebase.

You can take onboarding a step further by pairing new hires with experienced team members for one-on-one guidance. This approach ensures that newcomers feel supported while reducing the amount of time senior engineers spend on repetitive onboarding tasks.

Knowledge Sharing: Teams should cultivate a culture of knowledge sharing. This can be done through:
Internal wikis where developers document their findings and solutions.
Regular "show-and-tell" sessions where team members demonstrate new tools or code patterns.
Mentorship programs where experienced developers coach junior engineers.
When knowledge is shared openly and widely, the team becomes more resilient. Replacing a developer doesn’t mean losing critical knowledge because it’s already documented and shared with the rest of the team.

Conclusion
Documentation is the key to scaling teams effectively. Without it, you risk creating bottlenecks, increasing frustration, and slowing down development—exactly the opposite of what you want when bringing new people onboard. With detailed documentation, a strong onboarding process, and a culture of knowledge sharing, teams can scale quickly and efficiently, ensuring that new hires contribute positively from day one instead of dragging the team down.
So, if you want your team to scale successfully, don’t just focus on adding headcount—focus on building the right infrastructure through documentation. You'll be amazed at how much smoother everything runs!

I am Ikechukwu Vincent a Full Stack Software Engineer proficient in PHP, Python, NodeJs, and React. I specialize in building B2B Multi-tenancy applications.

Connect with me on Socials

Linkedin Vincent
Facebook Vincent
Twitter Vincent

How to Write Scalable and Testable Laravel Production App

Ikechukwu Vincent — Sun, 07 Jan 2024 08:53:37 +0000

I have been working full-time as a software engineer for a little over three years. During this period I have noticed a couple of things:

Microservice is an overkill in most instances where folks use it.
Most monolith code bases aren't scalable or maintainable.

But what does it mean for your code to be scalable? It involves a couple of things, for this article I will give a simplified but important definition: scalability is the ability of your code to accommodate more requirements and features without breaking or boxing the developer into a corner.

Insights I will share in this article can help you write more maintainable and scalable monolith code and even better micro-services if you must write one. While I will use Laravel as an example, this article applies to any MVC-based framework. Shall we?

Writing scalable and maintainable code begins with understanding the limitations inherent in your framework's software architecture - and that would be MVC in the case of Laravel.
To understand the limitations of MVC, read this article from Uber about their engineering challenges: https://www.uber.com/en-NG/blog/new-rider-app-architecture/

Here is the catch:

First, matured MVC architectures often face the struggles of massive view controllers. For instance, the RequestViewController, which started off as 300 lines of code, is over 3,000 lines today due to handling too many responsibilities: business logic, data manipulation, data verification, networking logic, routing logic, etc. It has become hard to read and modify.

This whole thing is about making your controller as lean as possible. What are the things that mess up your controller?

Validation logic
Business logic
Data manipulation and redirection
API vs Web request handling
Non-crude controllers

Validation Logic

For every form submission create a new Request class for form validation.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StoreReviewRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array|string>
     */
    public function rules(): array
    {
        return [
            'body' => 'required|string',
            'rating' => 'required|string',
        ];
    }
}

Use it as follows inside the reviews controller:

   public function store(StoreReviewRequest $request)
    {
        return DB::transaction(function () use ($request) {
            $this->service->storeUserRestaurantReview($request->all());
            Session::flash('success', 'Thank you for leaving a review');

            return redirect()->back();
        });
    }

The magic above may not seem like a lot until the number of fields you want to validate increases to a certain number. Get more context here.

Business Logic

You will write lots of logic and manipulate lots of data, for the interest of maintainability and scalability, you should do this in a service class - this is called Service Pattern. Create a folder named "Services", subfolder it if necessary, or even version it for API. Inside this folder, write your services. Now take a second look at the code above you will see where I imported the ReviewService class. Inside the class, you can write all kinds of methods you need for review.
Most of your business logic should be in service classes.

However, some that have to do with precisely data retrieval or storage can be in your models.

By following this, you have small pieces of code that can be tested via unit tests and integration tests. That my friend is your code becoming maintainable.

If necessary you could also use a repository pattern. Create a folder in the App folder called "Repository" and in a file named "BaseRepositoryInterface:

<?php
namespace App\Repository;

//use Illuminate\Datatbase\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Collection;

interface EloquentRepositoryInterface{
  public function all(array $column =['*'], array $relations=[]):Collection;

  public function findById(
    int $modelid,
    array $column = ['*'],
    array $relations = [],
    array $appends = []
  ):?Model;

  public function create(array $payload):?Model;

  public function update(int $modelid, array $payload):bool;

  // public function restoryById(int $modelid):bool;

  //public function attach()
}

Inside the repository, create a folder called Eloquent, inside a file called BaseRepository:

<?php
namespace App\Repository\Eloquent;

use App\Repository\EloquentRepositoryInterface;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;

class BaseRepository implements EloquentRepositoryInterface{

  protected $model;

  public function __construct(Model $model)
  {
    $this->model = $model; 
  }

  public function all(array $column = ['*'], array $relations =[]):collection{
    return $this->model->with($relations)->get($column);
  }

  public function findById(
    int $modelId,
    array $column = [],
    array $relations = [],
    array $append = []
  ):?Model{
    return $this->model->select($column)->with($relations)->findOrFail($modelId)->append($append);
  }

  public function create(array $payload):?Model{
    $model = $this->model->create($payload);
    return $model->fresh;
  }

  public function update(int $modelId, array $payload):bool{
    $model = $this->findById($modelId);
    return $model->update($payload);
  }

  // public function findById(

  // )

    public function attach(){

    }

}

Now we have a MoviesRepository file inside Repository/Eloquent

<?php 
namespace App\Repository\Eloquent;
//namespace App\Repository\Eloquent;

use App\Models\Movie;
use App\Repository\MovieRepositoryInterface;
use App\Repository\UserRepositoryInterface;

class MovieRepository extends BaseRepository implements MovieRepositoryInterface{
  protected $model;

  public function __construct(Movie $model){
    $this->model = $model;
  }
}

You can see it extends an interface inside the repository folder, here is the code:

<?php 

namespace App\Repository;

interface MovieRepositoryInterface extends EloquentRepositoryInterface{};

Now let us see how to use this code:

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Repository\MovieRepositoryInterface;
use Illuminate\Support\Facades\Auth;
use App\Repository\LocationRepositoryInterface;
use Illuminate\Support\Facades\Session;
class MoviesController extends Controller
{

    private $movieRepository;
    private $locationRepository;


    public function __construct(MovieRepositoryInterface $movieRepository){
        $this->movieRepository = $movieRepository;
    }

    public function create(LocationRepositoryInterface $locationRepository){

        $this->locationRepository = $locationRepository;
        $locations = $this->locationRepository->all();

        return view('pages.movies.create')->with('locations', $locations);
    }

    public function store(Request $request){
        // I AM JUMPING FIELD VALIDATION AND PURIFICATION STEP HERE.
        $id = Auth()->user()->id;
        $payload = [
            'name'=>$request->title, 
            'descript'=>$request->description,
            'poster'=>$request->poster,
            'showtime'=>$request->showtime,
            'location'=>$request->location,
            'userid'=>$id
        ];

        // var_dump($payload);die;
        $this->movieRepository->create($payload);
        Session::flash('success', "New movie Created");
        return redirect()->route('new_movie');
    }
}

For the above to work, you must register Repository Provider as follows:

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Repository\EloquentRepositoryInterface;
use App\Repository\Eloquent\BaseRepository;
use App\Repository\MovieRepositoryInterface;
use App\Repository\Eloquent\LocationRepository;
use App\Repository\Eloquent\MovieRepository;
use App\Repository\LocationRepositoryInterface;

class RepositoryServiceProvider extends ServiceProvider
{
    /**
     * Register services.
     *
     * @return void
     */
    public function register()
    {
        $this->app->bind(EloquentRepositoryInterface::class, BaseRepository::class);
        $this->app->bind(MovieRepositoryInterface::class, MovieRePository::class);
        $this->app->bind(LocationRepositoryInterface::class, LocationRepository::class);
    }

    /**
     * Bootstrap services.
     *
     * @return void
     */
    public function boot()
    {
        //
    }
}

Now inside AppServiceProvider you must register repository service provider as follows:

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Illuminate\Support\Facades\Schema;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        $this->app->register(RepositoryServiceProvider::class);
    }

    /**
     * Bootstrap any application services.
     *
     * @return void
     */
   public function boot(){
    // Fix for MySQL < 5.7.7 and MariaDB < 10.2.2
   Schema::defaultStringLength(191);
}
}

Repository pattern introduces more abstraction into your code as such I think you should not use it unless it's totally necessary.

API vs Web Request Handling

You can use the same controllers for web and API but I recommend you use different controllers for web and API and have them share the code in the service class. Now the service class needs to be versioned. This is keeping up with DRY.

Non-crude Controllers

Ideally, your controllers should be pure crude - create, read, update, edit but some devs define other kinds of method in there. Any method that cannot fit into these should be in an invokable controller. Keep your controllers crude or invokable.

Invokable controllers are controllers with one method __invokable() that executes when the controller is called.

Beyond Framework Limitations

I mentioned earlier about understanding the limitations of the software architecture your framework of choice uses. Beyond that, you also need to understand the functionalities available in your framework so you don't have to reinvent the wheel while using the framework. For instance, laravel has many ways of authorization who sees and acts on a resource. A deep understanding of them like gates, policies, spatie permissions, and co will save tons of lines of unnecessary code and gnashing of teeth.

Tests

With the few points above you can proceed to add unit and integration tests to your code to keep track of things each time you make a change.

Database Integrity

For things not to blow apart and also to avoid encountering funny edge case malfunctions in your application, I strictly recommend you enforce data integrity with military precision. First, use foreign keys in your relationships so it would be illegal to delete some resources.

Use database transactions whenever you are writing to more than one table, this keeps your data consistent across tables.

Conclusion

With the few points we have discussed in this article, your code will be very maintainable and scalable. It will be easy to modify existing features or add a new one without breaking things. This approach will make your monolith application incredibly maintainable and scalable. If you are building microservices, this approach will help to keep things a lot saner.

I am Ikechukwu Vincent a Full Stack Software Engineer proficient in PHP, Python, NodeJs, and React. I specialize in building B2B Multi-tenancy applications.

Connect with me on Socials

Linkedin Vincent
Facebook Vincent
Twitter Vincent

How to Escape Tutorial Hell

Ikechukwu Vincent — Thu, 09 Mar 2023 02:31:46 +0000

Tutorial hell refers to a state of being stuck in a cycle of constantly consuming programming tutorials without being able to apply the knowledge in the real world and build real apps. This can be frustrating for beginner developers who feel overwhelmed and unsure of how to take the next step in their learning journey. The repetitive nature of consuming tutorials can hinder one's ability to develop problem-solving skills, which are crucial for building practical applications.

To escape tutorial hell, beginner developers should focus on building their projects. By taking these steps, developers can gain the experience and confidence they need to become proficient programmers who can tackle real-world problems.

Add Features to Tutorial Projects: You have followed a tutorial to the end and probably built a project in one of these tutorials. If there are no projects built into the tutorials you have been following then you have been following the wrong tutorial and your journey will be long(pun). Now fold your sleeves and add new features to this project. Attempting to add a feature to a such project will force you to develop a deeper understanding of the project and sharpen your problem-solving skill as a developer. Always remember that Google is your friend.

Focus on building projects: The next stage for you is to try to build something from scratch all by yourself. In my experience the challenge here is in "thinking big"- I mean thinking of the project as a whole. Stop. Break it down. Begin with building the authentication pages for registration, and log in - once that is working - you build the first or main authenticated page or dashboard. From there another feature. One feature at a time.
After the course I took in HTML, CSS and SCSS nearly three years ago, I first rebuilt landing page of Binance before jumping onto the next course.

Start small: Don't try to build complex projects right away. Start with small projects that are achievable and build up your skills gradually. After little less than a year of working full time as a developer and continuously learning, I am currently building my first SaaS, attempt to build a SaaS as my first project after my first training would have failed for good.

Practice consistently: It's important to practice consistently, even if it's just for a short period each day. This will help you to build momentum and make progress over time. Even if you aren't building a full project, improve an existing one or build web components like mobile responsive navigation, beautiful popup modal, elegant slider, etc. A full web application is a collection of tiny components like this. Practicing with them individually will improve your skill and understanding of how parts of the whole project work.

Join a community: Join a community of like-minded developers who can offer support and guidance. This can be a great way to get feedback on your projects and stay motivated. Ask questions and get answers from people more experienced.

Google and Docs are Your Friends: As you begin to do things by yourself, I want you to understand that "how to" implement a feature doesn't have to fall out of your head because you have taken a course. Feel free to google stuff up and consult the documentation. Consult the "damn" documentation.

Take breaks: Don't get burnt out by studying and coding for long hours. Take regular breaks and do something unrelated to coding.

Remember, the key to escaping tutorial hell is to apply what you've learned and keep practicing. The next thing to do now is to apply what you have learned in this short article right away - don't jump onto the next article - that it's self is tutorial hell. Apply what you have just learned. With time and dedication, you can become a proficient developer who can build amazing things.

Thank you for reading. Don't forget to drop a comment and share.

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below.

Linkedin Vincent
Facebook Vincent
Twitter Vincent

Beyond Engineering: Before You Build B2B SaaS

Ikechukwu Vincent — Sun, 05 Mar 2023 01:03:14 +0000

In today's world, software as a service (SaaS) has become increasingly popular as it offers businesses the opportunity to access bespoke software through the internet, without having to build and maintain it themselves.

A Bit of SaaS Trend
According to a report from Gartner, the global SaaS market is expected to reach $145.3 billion by the end of 2022, up from $102.8 billion in 2019. This growth is being driven by several factors, including the increasing demand for cloud-based solutions, the need for businesses to be more agile and flexible, and the rise of remote work.
Another trend that we've seen is the increasing number of businesses that are turning to SaaS solutions to improve their operations and drive growth. SaaS solutions offer several benefits, including cost savings, scalability, and ease of use. With SaaS solutions, businesses can access powerful tools and resources without having to invest in expensive hardware or software. Additionally, SaaS solutions can be quickly and easily deployed, which allows businesses to respond to changing market conditions and customer needs more quickly.

Let's Proceed
After resigning from my job last year, in the wake of this year, I found myself leading a small team to build B2B SaaS at a startup Viviane Health Lab - a maker of healthcare software solutions. One thing became clear pretty fast - there is a difference between making fintech applications to facilitate borderless transactions or building novel social media platforms vs building industry-specific enterprise SaaS.

In the first two, you can proceed as a team of designers and engineers and a hypothesis about the end users. In the latter, you need a little more than "Design and Engineering" might, garnished with assumptions - you need industry or domain experts in the team.

There is a growing number of solo entrepreneurs online who pride themselves on having built lucrative one-man SaaS - as attractive as that may sound, it is something you should never do especially when you are not a professional in your target industry. I mean if you are a developer building an accounting solution, you should not go solo.

Come with me...

One of the most critical aspects of building a successful SaaS product is having a team of experts that includes not only developers and designers but also industry or domain experts. Industry experts are professionals with domain knowledge, and they play a critical role in developing a SaaS product that is tailored to the needs of their specific industry.

One of the primary advantages of having industry experts on the team is that they provide invaluable insights into the needs of the industry and the workflow of their colleagues. By understanding the specific needs of the industry, they can help the development team create a product that is not only useful but also intuitive and easy to use.

For example, if you're building a SaaS application for the healthcare industry, having experts in the field can help ensure that the product complies with industry regulations, is HIPAA compliant, and meets the unique needs of healthcare professionals.

Furthermore, industry experts can provide input on the features and functionalities of the product. They can help the development team prioritize features and ensure that the product has the necessary features to address the needs of the industry while being lean if necessary. This can save development time and resources, as the team can focus on building features that are essential to the industry, rather than developing features that may not be useful.

Another benefit of having industry experts on the team is that they can help bridge the communication gap between the development team and the end users. Since industry experts have an understanding of the language, workflows, and processes used in their industry, they can help ensure that the product speaks the same language as the users. This can help prevent misunderstandings, and improve user adoption.

Finally, industry experts can help with the product's testing and validation. They can test the product in real-world scenarios and provide feedback to the development team. This feedback can help the team identify any bugs or issues that should be addressed before the product gets released to the public.

Extra Edge
Beyond the above listed advantages of having industry experts in
your development team, they can also be an invaluable asset in marketing - this is because most of the professionals who can provide the needed development edge have been around in their industry for years and have built credibility. They can spread the word about the product and with that first set of users can be onboarded effortlessly.

Slippery
One of the core obstacles standing in the way of developers and entrepreneurs wanting to build B2B SaaS is funding. In absence of funding compensation for the domain experts can be a difficult nut to crack especially in developing countries. It can be tempting to wave aside the need for these people in the team, however, I strongly advise against that. Equity is an option, however, the team cannot sustainably run on that for any reasonable length of time. These guys are worth their weight!

In Conclusion
...building a SaaS product that is industry-specific requires collaboration between UI designers, developers, and industry experts. Industry experts play a critical role in developing a product that meets the unique needs of their industry. They provide insights into the needs of the industry, help prioritize features, bridge the communication gap between the development team and end-users, and help with testing and validation. With the help of industry experts, SaaS products can be tailored to meet the needs of their specific industry, resulting in a more successful product.

Thank you for reading. Don't forget to drop a comment and share.

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below.

Linkedin Vincent
Facebook Vincent
Twitter Vincent

What is Flask Blueprints? Structuring Project with Blueprints

Ikechukwu Vincent — Mon, 20 Feb 2023 15:13:02 +0000

NB: For this tutorial, for every change you make, you need to restart your flask server. Except if you set up your Flask server with env.

Flask is a popular Python lightweight web framework that allows developers to build web applications quickly and easily. One of the most powerful features of Flask is its blueprint functionality, which enables developers to organize their code into logical modules.

After few years of working with Laravel, I learned Python and a bit of Flask at ALX Software Engineering training. While building my first real application with Flask, I quickly notice that my "route definition file" is growing too fast. It is littered with route definitions, route-associated functions and logic.

How do I effectively break it down?

Then I remembered we were thought Blueprints. Well Blueprints! In this article, we'll take a closer look at Flask blueprints and show you how they can help you build scalable and maintainable applications.

What are Flask Blueprints?

Flask blueprints are a way to organize your Flask application into reusable and most importantly maintainable units. With blueprints, you can break your application into smaller, more manageable pieces, making it easier to maintain and scale.

Each blueprint is a self-contained unit that can be registered with your Flask application. Blueprints define a set of views, templates, and static files that are associated with a specific URL prefix.
Using blueprints, you can create a flexible and extensible application structure that allows you to add new features and functionality without disrupting the existing codebase.

Now Lets get our hands dirty

Create your project folder, inside it create app.py file. Paste the code below inside this file. Afterwards, if you go to your terminal and enter "flask run" a flask server will be started for you.

from flask import Flask

def create_app():
    app = Flask(__name__)

    from blueprints.authentication.authentication import authentication as auth_blueprint
    app.register_blueprint(auth_blueprint)

    from blueprints.profile.profile import profile as profile_blueprint
    app.register_blueprint(profile_blueprint)
    return app

Take a look on the code above and notice that two blueprints for authentication and profile has been registered already. Now lets see how to create these blueprints.

In your current folder where you have your app.py, create a folder named blueprints. Inside blueprints, create another two folders named "profile" and "authentication" respectively.

Great!

Now inside "profile" and "authentication" folders, create the following:

a folder named static
a folder named templates

Inside "profile", create profile.py
Inside "authentication" create authenication.py

Now inside profile.py write the following code

from flask import Blueprint, render_template

profile = Blueprint('profile', __name__, template_folder='templates', static_folder="static", static_url_path='/blueprints/profile/static')

@profile.route('/profile')
def profile_page():
    return "profile pages"

Notice the parameters of Blueprint method. We defined a few things in there most importantly, the template_folder telling Flask where to search for templates for this profile blueprint. That is a folder named templates within the profile folder. We also defined static_folder. Where to search for static files of any html file being rendered by this blueprint.

Now for authentication blueprint. The code is as follows

from flask import Blueprint, render_template

authentication = Blueprint('auth', __name__, template_folder='templates', static_folder="static", static_url_path='/blueprints/profile/static')

@authentication.route('/auth')
def auth_page():
    return "auth pages"

Static Files

At the beginning of this article, we said that each blueprint can be self contained having it's own static files and templates. Let us demonstrate that.

Inside profile blueprint folder, you must have created a template folder. The template folder create a html file named profile.html
Inside profile/static create a folder named css and inside create style.css. Here is html code to put into profile.html

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap demo</title>
    <!-- <link rel="stylesheet" href="/blueprints/profile/static/css/styles.css"> -->
    <link rel="stylesheet" href="{{ url_for('profile.static', filename='css/styles.css') }}">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">
  </head>
  <body>
    <h1>Hello, world!</h1>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>
  </body>
</html>

Pay special attention to the head of this html file where I included css files. I did it two different ways. Note That. That is how you can include all your static files. This works inline with definition of static_url in blueprint method.

To run your /profile url on browser, you need to modify to route to render profile.html

@profile.route('/profile')
def profile_page():
    return render_template('profile.html')

To be sure your css file is properly included, go ahead and style the page with the css file. That should be fun.

As you can see, Flask blueprint is truly self contained unit of flask application. All features of your app relating to profile can have there routes defined and handled by profile.py.
Same goes with authentication.

Thank you for reading. Dont forget to drop a comment and share.

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below.

Linkedin Vincent
Facebook Vincent
Twitter Vincent

Questions to Ask Yourself Before ALX Software Engineering

Ikechukwu Vincent — Wed, 15 Feb 2023 19:24:37 +0000

Hi there!

Since I joined ALX Software Engineering training about 10 months ago, I have got tons of questions on social media about the program.

There is a common problem with these questions, however. They are all about the program. The right questions should be about the person wanting to enroll. They should be asking more questions about themselves than about the ALX Software Engineering program.

So of questions I get can be summed as follows:
What is the program like?

Is the program worth it?

*Do they teach very well?

If I will be spending 70hrs per week, will they be paying me? No dude! They won't pay you!

These are the wrong questions. A quick read-up about the program on the ALX website will tell you that it is an intensive program - demanding at least 70hrs per week. That says a lot.

Low and no code tools are rising more than ever before right now. AI is also rising. This is not a good time to learn software engineering, last of all enroll in intensive software engineering training as intensive as ALX Software Engineering without being very clear about what exactly you want to do with yourself.

Let me answer the questions regardless:
What is the program like? They already described it on their website dude.

Will they pay me? ALX got a training that was originally around $40k per year for two years, made it one year, and made it free. That is more than enough so they won't pay you.

Is it worth it? It is about what you can make out of the knowledge you gain at the end of the day. You define worth.
Do they teach well? They don't teach actually. Your learning capacity is what will get you through. You will teach yourself.

You need to find out what exactly you want to do with yourself first.

If you are here because "tech is the new oil" and you want "instant money", it is more advisable to gain mastery of many low and no-code tools out there. You can do a lot today without being a software engineer or subjecting yourself to intensive training.

About the right questions...

Before you emback on 70hrs per week drill into Software Engineering, ask yourself these:

Do I want to be involved in building things that require deep knowledge of the fundamentals of computing?

What role do I want to play? Engineer? Principal engineer?

If the answer is YES or positive for all, then you are an ALX Software Engineering candidate. I wanted to build intelligent SaaS for healthcare and I was also interested in hardware virtualization - I mean creating software to mimic hardware and eliminate the need for the hardware itself. I started the first one while still on ALX.

You are a candidate but don't rush yet!

The next question is:

If I have to dedicate 70hrs plus per week to learning, how the actual "eff" do I pay my bills?

ALX Software Engineering training is not something you can pull off using your leisure time at night while working full time during the day. Especially, most especially if you are an absolute beginner with zero coding experience. That won't work.

If you have no plan of being involved in building something that requires fundamental knowledge of computing in near future, then ALX may not be your best bet.

If you have such plans but you cannot handle your bills while dedicating most of your time to ALX software engineering training, then you need to consider alternative routes to gaining the skills you need - the good news is that there are many alternative routes.

You can look at the curriculum and buy courses for topics there on a platform like Udemy where the courses are pre-recorded enabling you to learn absolutely on your own pace.

Whatever part you chose at the end of the day, I wish you the very best. If you chose ALX Software Engineering after a careful evaluation of yourself, then I have one more article for you about how to prepare and ace it.

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below.

Linkedin Vincent
Facebook Vincent
Twitter Vincent

How to Login Users With Phone Number or Username in Laravel

Ikechukwu Vincent — Fri, 10 Feb 2023 09:55:10 +0000

Welcome to the world of Laravel, a popular PHP framework for web application development. In this article, we will be discussing the process of logging in with either a phone number or username in Laravel. Laravel implemented email login out of the box, however, developers tend to struggle when there is a need to log in with any other user bio data like username or phone number

As with everything in programming, there are many ways to do it. However, there is a defined laravel way to do it - which is in fact best practice and more secure.

Before we proceed, I have a word for you as a laravel developer or developer working with laravel, make the doc your best friend.

Lets begin!

We begin by altering user table migration file to add the bio data of interest. This bio data(phone or username) will have to be unique for the table - no two users in same table can have same phone or username.

php artisan make:migration add_cols_to_users_table

Now let us add the table columns to the file

$table->string('phone')->unique();
$table->string('username')->unique();

NB: In your registration page, these fields are must for users fill them in. And they must be unique to the table.

In laravel default login blade page, email input field have the name value of email. Change it to anything you want, I normally use "identifier".

Now let us proceed to the controller method that handles user login.

   if (Auth::guard('web')->attempt(['email' => $request->identifier, 'password' => $request->password])|| 
        Auth::guard('web')->attempt(['phone' => $request->identifier, 'password' => $request->password])) {
            // Authentication was successful...
            // Auth::guard('web')->login($user);
            return redirect()->intended(RouteServiceProvider::HOME);
        }else{
            return redirect()->route('login')->with('fail','Incorrect credentials');
        }

That will be all, now navigate to your login page, and login either with email or phone number.

If you would like to add username to the authentication parameters, all you need to is to add one more "Or" to the if statement of the login method. Just the way I did it for phone.

To gain deep understanding how this work behind the scene, read more about Laravel Authentication Auth Facade
and also about authentication guards in laravel.

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below.

Linkedin Vincent
Facebook Vincent
Twitter Vincent
Github Vincent

If you run into trouble leave a comment or say hi on my social media.

Laravel Multi Table Authentication

Ikechukwu Vincent — Tue, 07 Feb 2023 10:06:48 +0000

Authentication is an essential component of any web application, and Laravel makes it easy to implement with its built-in authentication features powered by single user table. However what if you have multiple user types, each with its own table in the database? In this scenario, you need to implement multiple table authentication to ensure that the correct user is authenticated and given the right access to the application.

In this article, I will walk you through the steps of implementing multiple table authentication in Laravel, so you can secure your application and give your users the best experience possible. Get ready to dive into the world of Laravel multiple table authentication!

Shall we? Let's go.

I am starting with assumption that you know how to install a fresh laravel application and you have one installed already. That said, let us proceed.

Laravel comes with default users table, lets assume this is the table for default users of your application. And you want another table for admin users.

Model(s)

First we create model for the new class of users in this cas Admins. In your case it could be teachers and students.

php artisan make:model Admin/Admin

Now you have created the Admin model, go in side it and replicate the following code. The Notifiable trait makes it possible to use laravel default notification on these model.

use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class Admin extends Authenticatable
{
    use HasFactory, Notifiable;
    protected $guard = 'admin';
}

Configurations

Laravel have config folder that houses all config files. Inside this file, open auth.php file and paste the following code where we create authentication rules for admin.

In auth.php config

'defaults' => [
        'guard' => 'web',
        'passwords' => 'users',
    ],
 'admin'=>[
        'driver'=>'eloquent',
        'model'=>App\Models\Admin\Admin::class,
     ],

  'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],

        'api' => [
            'driver' => 'token',
            'provider' => 'users',
            'hash' => false,
        ],
        'admin'=>[
           'driver'=>'session',
           'provider'=>'admins',
        ],
    ],

    'providers' => [
        'users' => [
            'driver' => 'eloquent',
            'model' => App\Models\User::class,
        ],

        'admins'=>[
            'driver'=>'eloquent',
            'model'=>App\Models\Admin\Admin::class,
         ],
    ],

    'passwords' => [
        'users' => [
            'provider' => 'users',
            'table' => 'password_resets',
            'expire' => 60,
            'throttle' => 60,
        ],
        'admins'=>[
            'driver'=>'eloquent',
            'model'=>App\Models\Admin\Admin::class,
        ],
    ],

Middleware

Now navigate to middlware folder and open the Authentication.php file. This is the file that redirect users who are not authenticated when they try accessing guarded pages. Notice that I commented out the default code in the file.

Middelware Authenticate.php

  // foreach ($guards as $guard) {
        //     if (Auth::guard($guard)->check()) {
        //         return redirect(RouteServiceProvider::HOME);
        //     }
        // }


        foreach ($guards as $guard) {
            if (Auth::guard($guard)->check()) {

                if($guard === 'admin'){
                    return redirect()->route('admin.home');
                }
                return redirect()->route('user.home');
                // return redirect(RouteServiceProvider::HOME);
            }
        }
    if (! $request->expectsJson()) {
            if($request->routeIs('admin.*')){
                return route('admin.login');
            }
            return route('login');
        }

In same middleware folder, open the following file. It is the middleware responsible for redirecting authenticated users based on the guard used in their authentication.

In RedirectIfAuthenticated.php

  // foreach ($guards as $guard) {
        //     if (Auth::guard($guard)->check()) {
        //         return redirect(RouteServiceProvider::HOME);
        //     }
        // }


        foreach ($guards as $guard) {
            if (Auth::guard($guard)->check()) {

                if($guard === 'admin'){
                    return redirect()->route('admin.home');
                }
                return redirect()->route('user.home');
                // return redirect(RouteServiceProvider::HOME);
            }
        }

Admin auth controller

Here we shall create a controller to handle authentication for this category of users.

We begin by creating a controller to handle admin login.

php artisan make:controller Auth/AdminAuthController

Inside the controller

public function __construct()
{
     Auth::setDefaultDriver('admin');
     config(['auth.defaults.passwords' => 'admins']); 
}

public function login()
{
     return view('admin_auth.adminlogin');
}

   public function logoutAdmin(Request $request)
    {
        Auth::guard('admin')->logout();
        $request->session()->invalidate();
        $request->session()->regenerateToken();
        return redirect('/');
    }

public function store(Request $request)
{
     $request->validate([
         'email'=>'required|string',
         'password'=>'required|min:5|max:30'
      ]);


    if (Auth::guard('admin')->attempt(['email' => $request- 
    >identifier, 'password' => $request->password])|| 
     Auth::guard('admin')->attempt(['username' => $request>identifier, 'password' => $request->password])) {
            // Authentication was successful...
            return redirect()->route('panel');
     }
   else{
       return redirect()->route('admin.login')- 
         >with('fail','Incorrect credentials');
     }
    }

Routes

Now let use create authentication logic for this set of users(admins).

Route::get('/admin/login', [AdminAuthController::class, 'login'])->name('admin.login');
Route::get('/admin/login', [AdminAuthController::class, 'store'])->name('admin.login.store');
Route::post('/admin/logout', [AdminAuthController::class, 'logoutAdmin'])->name('admin.logout');

Pay attention to this part. You will need a route more leading to your dashboard or any other protected pages. Below is exampme of such route. Notice the middleware usage auth:admin. Very important.

Route::get('/panel', [AdminPagesController::class, 'panel_home'])->name('panel')->middleware('auth:admin');

Login html

At this point, let us create blade file or html file for login admin login page. resources\views\admin_auth.blade.php
Take note of where we are submitting this form to.

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap demo</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-rbsA2VBKQhggwzxH7pPCaAqO46MgnOM80zW1RWuH61DGLwZJEdK2Kadq2F9CUG65" crossorigin="anonymous">
  </head>
  <body>
    <!-- <h1>Hello, world!</h1> -->
    <main class="container mt-5">
    <form method="POST" action="{{route('admin.login.store')}}">
        @csrf 
        <div class="form-group">
            <h3 class="text-center">Admin Login</h3>
        </div>
        <div class="mb-3">
            <label for="exampleInputEmail1" class="form-label">Email or Username</label>
            <input type="text" class="form-control" name="identifier" id="exampleInputEmail1" aria-describedby="emailHelp">
            <div id="emailHelp" class="form-text">We'll never share your email with anyone else.</div>
        </div>
        <div class="mb-3">
            <label for="exampleInputPassword1" class="form-label">Password</label>
            <input type="password" name="password" class="form-control" id="exampleInputPassword1">
        </div>
        <div class="mb-3 form-check">
            <input type="checkbox" name="remember" class="form-check-input" id="exampleCheck1">
            <label class="form-check-label" for="exampleCheck1">Check me out</label>
        </div>
        <button type="submit" style="float:right;" class="btn btn-primary">Submit</button>
    </form>
    </main>
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" crossorigin="anonymous"></script>
  </body>
</html>

Migration

Now let us create table or migration for this new users - admins. Run the command

php artisan make:migration create_admins_table

Inside the migration file, copy and paste the code below

     $table->string('name');
     $table->string('username')->nullable();
     $table->string('email')->unique();
     $table->timestamp('email_verified_at')->nullable();
     $table->string('password');
     // $table->enum('admin_typ', ['admin'])->nullable();
     $table->rememberToken();

Factory and Seeder

Let us now quickly populate the database. We begin by making a model factory for our admin model and also a seeder file.

php artisan make:factory Admin/AdminFactory    
php artisan make:seeder AdminSeeder

Inside the factory Definition method

  return [
            'name' => fake()->name(),
            'username'=>fake()->userName(),
            'email' => fake()->unique()->safeEmail(),
            'email_verified_at' => now(),
            'password'=>'$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
            'remember_token' => Str::random(10),
        ];

Inside the seeder file, in the run method

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

        \App\Models\Admin\Admin::factory()->create([
            'name' => 'Test Admin',
            'username'=>'admin',
            'email' => 'admin@admin.com',
        ]);

Next run the seeder command to populate your database.

php artisan db:seed --class=AdminSeeder

Remember to create html blade for your protected page.

So that is it. Start your laravel application and try logging in on your admin login page.

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below.

Linkedin Vincent
Facebook Vincent
Twitter Vincent
Github Vincent

If you run into trouble leave a comment or say hi on my social media.

A to Z of How to Prepare for ALX Software Engineering Training and Ace It

Ikechukwu Vincent — Sat, 17 Dec 2022 11:26:48 +0000

Disclaimer: This is personal opinion. Post not sponsored by any of the companies mentioned.

If you are here, I believe you understood what ALX Software Engineering Training is about. It is one of the finest SE on planet earth, currently available for free to people of African extraction.

The Software Engineering training is the most expensive and the most challenging of all ALX programs demanding that applicants be willing to spend at least 70hrs per week to the training for 12 months or more.

Ideally, I like to get straight to the point when I write, however I beg to take an exception today. Before I proceed to how you should prepare to ace the training, let us take look at what must be involved in a good software engineering training. Here are some of them key qualities to expect from a good software engineering program:

1. Comprehensive curriculum: A great software engineering training program should cover all the key concepts and skills needed to become a proficient software engineer. This includes topics like algorithms and data structures, software design and architecture, testing and debugging, and software development processes.

2. Practical experience: A great software engineering training program should provide hands-on experience through projects and exercises. ALX SE program is big on exercise. This allows students to apply what they have learned and build real-world experience.

3. Professional development: A great software engineering training program should also focus on the soft skills needed for professional development, such as communication skills, teamwork, and project management. These skills are essential for success in the software engineering field, especially a large team.

4. Industry relevance: A great software engineering training program should stay up-to-date with the latest technologies and industry trends. This ensures that students are learning the skills that are most relevant and in demand in the job market.

5. Quality instruction: A great software engineering training program should have experienced and knowledgeable instructors who can effectively teach the material and provide guidance and support to students.

6. Flexibility: A great software engineering training program should offer flexible options, such as online or in-person classes, part-time or full-time schedules, and self-paced learning. This allows students to tailor their learning experience to their needs and schedule.

ALX Software Engineering training is all of this and more. Now back to the main deal.

How do you prepare?

Wait! Hollup! Why do you need preparation? You need preparation because 70hrs per week is about 10hrs daily. 10hrs daily! This means it may be impossible to do any other thing while the training runs. You may even need to resign from your job when push reaches shove.

If you have no coding background, you will need to give that required 70+ hours unless you are an exceptional genius. Many of us are not. If you are reading this, my bet is you are no genius - that is why you are already looking for heads-on.
That said, as you are applying, start learning coding right away using the ALX curriculum as your compass. Get a hold of git, bash, C(pointers, strings, etc), HTML, and CSS.
This will eventually reduce your overhead time investment when the program begins, buying you some 10-30hrs per week to engage in any other necessary activity like partime work. Even if it doesn't reduce your time investment, it will surely do one thing for you - it will make it possible for you to assimilate or understand topics and concepts faster. This will help you to meet project or task deadlines and earn more marks.
If you have coding or development experience, you will be fine though your grit will still be necessary.
That said let's talk about your financial life - you need to do a careful analysis of your finances or income. What is the worst that can happen? What are your contingency plans? You need to have as many as you can. You will need them all. You may want to call one or two people and brief them that you may call time to time and ask for their assistance - explain the kind of assistance you will be needing though.
Arrange for your electricity. If you depend solely on national grid around most African nations, you will surely miss many project deadline. Personally I am using MTN Lumos Prime which is N10600 per month currently.
If you are in a relationship, let them know you are getting into an intensive 12 months training and likely to be less available. Lols

How to Proceed While in The Training

ALX is not your regular Bootcamp. By that I mean, they teaching beyond coding and building things, in ALX Software Engineering training you learn the theory behind things - the fundamentals. In fact, the program when it started at Holberton School of Software Engineering was started as alternative to University degree in computer science.

For each project or topic being treated you get learning materials and tasks to accomplish within a defined period of time. So what do you do?

Read the whole material at least more than once.
Before reading the material, reading the tasks you are to do.
After reading the material the first time, you may want to read the tasks again.
The materials are mostly official documentations and sometimes may not give you precise clue to answer real questions. That said, dont hesitate to consult other tech contents like youtube videos and tech blogs.
Take the mindset sessions of the training very serious. You will need those concepts to make it through ALX. Implement the concepts in your daily life.

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below.

Linkedin Vincent
Facebook Vincent
Twitter Vincent

Linked List Implementation in C with User Input

Ikechukwu Vincent — Sun, 31 Jul 2022 11:54:40 +0000

Table of Content

Intro
Pre-requisites
What is LinkedList
Why are we using LinkedList
Implementing a LinkedList in C

If you are reading this article, I imagine you are starting your journey in data structures and algorithms. If that is the case, you are reading the right article. Before we begin, let me lay out some prerequisites - the terms and concepts we need to know to understand the concept of LinkedList fully.

Contiguous and non-contiguous memory blocks: In contiguous memory allocation, a single block of memory with a unique address is allocated to a file or process that needs it. In a Non-contiguous memory block, random memory blocks in different locations are allocated to the file or process. LinkedList falls into the latter. This is one of the core differences between LinkedList and array. Arrays are stored in contiguous memory locations.

Struct: It is a way to group related variables of different data types in C and other related languages.
Struct

Dynamic Memory Allocation Using Malloc: Since items in LinkedList are stored in random or different locations in machine memory, we will need to manipulate memory dynamically - on the fly. This brings us to the need to understand the standard c lib () function called malloc.

WHAT IS A LINKED LIST?

I imagine that at this point in your journey you are familiar with arrays. A linked list just like arrays is a linear data structure. You store data sequentially one after another. In an array however elements are stored in the same memory location, but in LinkedList elements are stored in different locations in memory. The elements of the list or the list items or NODES are stored in different memory locations. Each of these list item or node contain two things:

The data - can be any data type
Memory address to next item or node - a pointer

WHY USED A LINKED LIST?

Dynamic Size: Linked lists have variable sizes. Arrays have fixed sizes. If for your purpose number or volume of data will be varying during program runtime, it is fair to use LinkedList.
Faster Insertion and Deletion: With LinkedList insertion and deletion operations are faster or more compute-efficient. If you will be doing lots of insertion and deletion on your data, then LinkedList is better.

IMPLEMENTING A LINKED LIST
Okay in this part of this article, we will write a code in C language to implement a LinkedList. It will take multiple data from the user and use them to create a LinkedList. The first data it will require and get from the user is several data for the list to hold. Then It will prompt the user to input data until it equals the number of the data defined by the user. Next, the program will print out everything.

Now let's begin.
Step 1. First, create a C project in code blocks IDE. Inside the

main.c file: 
#include <stdio.h>
#include <stdlib.h>

struct node
{
    int data; //data of the node
    struct node *nextPtr; //address of the next node
};

In the above code, we imported standard C libraries we will need for this program and also created a node for our list. The node has two variables - an int variable to store the data. And another variable is to store a pointer(memory address) to the next node or list item.

Step 2:

struct node *startNode;

//function to create the list
static void createNodeList(int totalNodes);
static void displayList();

We declared a pointer to the starting node.and also created two function prototypes. The first function will create the linkedList. The second one will print it.

Step 3:

int main()
{
    int numberOfNodes;

    printf("Input the number of nodes: ");
    scanf("%d ", &numberOfNodes);
    createNodeList(numberOfNodes);
    displayList();
    return 0;
}

Main function is the entry point to every C program. So We created our main function and inside the main function, we declared an int variable numberOfNodes to hold the number of nodes for the list. Next, we print the user to enter the max number of nodes the list will contain, which we will store in the already declared variable.

Step 4:

static void createNodeList(int totalNodes)
{
    struct node *newNode;
    struct node *nodeBuffer;
    int nodeData;
    int nodeCounter;

    //allocate memory for starting node
    startNode = (struct node*)malloc(sizeof(struct node));

   //at this point you can check if the memory allocation is      
   //and stop the program if not 
}

In step four I started defining the first function. I created a number of variables, first of struct node type to hold new nodes. Next one is a buffer. The next node data, and node counter.
Next, I allocated memory to the starting node using malloc. Note the comment. I jumped that.

Step 5:

printf("input data for node1: ");
        scanf("%d", &nodeData);

        //save user input to the data element of the node
        startNode->data = nodeData;
        //initialize the nodes next pointer to null
        startNode->nextPtr = NULL;
        //Point the buffer to address of the first node
        nodeBuffer = startNode;

You have requested for the first user input and assigned it to a node. The thing is to use a for loop to get the rest. A linked list with one node containing data basically has two nodes. So….

Step 6:

for(nodeCounter =2; nodeCounter<=totalNodes; nodeCounter++)
        {

            newNode = (struct node*)malloc(sizeof(struct node));

            //exit if new node cannot be allocated
            if(newNode == NULL)
            {
                printf("Memory cannot be allocated.");
                break;
            }
            else
            {
                printf("input data for node %d: ",nodeCounter);
                scanf("%d", &nodeData);

                newNode->data = nodeData;
                newNode->nextPtr = NULL;

                //Link the previous node to the current node
                nodeBuffer->nextPtr = newNode;
                //copies address of current node
                nodeBuffer = nodeBuffer->nextPtr;
            }

        }

NB: code up to this point is still inside the CreateNodelist function we started in step 4.

The next thing we need to do now is to create a function that will print out our node list to the console.

Step 7:

static void displayList(){
    struct node *nodeBuffer;
    nodeBuffer = startNode;
    //exit if it is empty
    if(nodeBuffer == NULL){
        printf("List is empyt");
        return 0;
    }
    else{
        //check if the current node is empty
        while (nodeBuffer != NULL)
        {
            //PRINT THE DATA OF CRRENT NODE
            printf("DATA: %d \n", nodeBuffer->data);
            //go to the next node
            nodeBuffer = nodeBuffer->nextPtr;
        }
    }
}

In this article you must have learn the things you need to understand to understand linkedlist, also what a linkedlist is, the difference between linkedlist and array and why we use linkedlist.

References:
Image Credit goes to Geekforgeeks
Useful Resource:
Source Code: Here

I am Vincent Ikechukwu, Full Stack Web Developer and Software Engineer. Connect with me on social media via links below

Linkedin Vincent
Facebook Vincent
Twitter Vincent

Structuring Your Laravel App: Migrations In Folders

Ikechukwu Vincent — Sun, 31 Jul 2022 07:21:52 +0000

My first laravel app for production was a website for a financial service company. Just a website, it wasn't meant to manage their processes, even though I made provisions for job posting and applications among other things.

Sooner or later in building the website, I noticed the migration files is growing larger than what I wanted in a single folder. I must mention creating extra migrations to handle altering tables didn't help matters.

Quickly I started my second project which turns out to be a relatively big utility application. Shit began to get real. I needed to rethink my file structures starting from migration to business logic.

Then I figured out it would be better if I can group my migration files in folders. Related tables or migrations reside in the same folder. Without further ado let me quickly show you how to do that.

Let's say you want to group your migrations into 3 folder folders. Then in your terminal,

php artisan make:migration create_tablenames_table --path=database/migrations/admin

This single command will create a table with the name “tablenames” inside the admin folder in the migrations folder.

You can go ahead and do this for the rest of the three folders. In the end, you will have a migration folder structure like this

I am Ikechukwu Vincent, Full Stack Web Developer, I work with Laravel and ReactJs
LinkedIn
Twitter