DEV Community: Dike Pascal Ozioma

20 Living Room Decor Ideas

Dike Pascal Ozioma — Sun, 01 Dec 2024 22:45:32 +0000

20 Living Room Decor Ideas That'll Make You Want to Stay Home Forever! (Warning: #15 Is Addictive!)

Dike Pascal Ozioma ・ Dec 1

20 Living Room Decor Ideas That'll Make You Want to Stay Home Forever! (Warning: #15 Is Addictive!)

Dike Pascal Ozioma — Sun, 01 Dec 2024 22:44:10 +0000

20 Living Room Decor Ideas That'll Make You Want to Stay Home Forever! (Warning: #15 Is Addictive!)

Imagine curling up in a living room that feels like a warm hug every time you step inside.

With the right decor elements, your space can transform into a cozy haven that invites relaxation and joy. From modern twists to classic comforts, here are 20 living room decor ideas that will inspire you to create a sanctuary you'll never want to leave.

1. Bohemian Bliss

Embrace an eclectic mix of patterns and textures with Bohemian decor. Layering rugs, vibrant textiles, and an array of plants creates a laid-back atmosphere.

A low coffee table surrounded by floor cushions and colorful throws invites casual gatherings and relaxation.

2. Scandinavian Simplicity

Scandinavian design is all about minimalism and functionality. Neutral color palettes, clean lines, and natural materials create a serene environment.

Incorporate wooden furniture, soft textiles, and plenty of natural light for a refreshing feel.

3. Industrial Edge

Industrial decor brings a raw, urban vibe to your living space. Exposed brick walls, metal accents, and vintage furniture create a unique character.

Pair with warm lighting to soften the ruggedness and invite warmth.

4. Cozy Cottage

Cottage decor is all about warmth and comfort. Soft hues, floral patterns, and vintage-inspired furniture create a welcoming atmosphere.

Add cozy blankets and a fireplace to complete the charming feel.

5. Modern Minimalism

Modern minimalism focuses on functionality and sleek designs. Choose furniture with clean lines and a monochromatic color scheme for a sophisticated look.

Incorporate statement pieces for visual interest without clutter.

6. Colorful Accents

Inject personality into your living room with vibrant accent pieces. Bright cushions, artwork, and decorative items can transform a neutral space into a lively one.

Choose a few bold colors and repeat them throughout the room for a cohesive look.

7. Vintage Charm

Incorporate vintage items for a timeless appeal. Antique furniture, retro decor, and unique finds tell a story and add character to your living room.

Mix and match different styles for a curated look that feels personal.

8. Greenery Galore

Bring the outside in with an abundance of plants. A range of indoor greenery enhances air quality and adds a fresh feel to your living space.

Choose various plant sizes and types for visual interest and a touch of nature.

9. Textured Layers

Layering different textures adds depth and coziness to a living room. Combine soft fabrics, woven materials, and wooden elements for a tactile experience.

Use throws, pillows, and rugs to create a welcoming environment that invites relaxation.

10. Artistic Expressions

Make your living room a canvas for creativity by showcasing artwork. Large paintings or a gallery wall can serve as stunning focal points.

Mix different art styles and frames for an eclectic vibe.

11. Smart Technology

Incorporate smart technology seamlessly into your living room for convenience and style. From smart lighting to integrated sound systems, technology can enhance your space.

Choose sleek, modern designs that blend with your decor.

12. Rustic Retreat

Rustic decor evokes a sense of warmth and comfort. Use reclaimed wood, warm colors, and cozy furnishings to create a retreat-like atmosphere.

Incorporate natural elements like stone and metal for added charm.

13. Coastal Calm

Bring the beach into your living room with coastal decor. Soft blues, whites, and natural materials create a refreshing and serene atmosphere.

Incorporate seashells, driftwood, and nautical elements for that seaside vibe.

14. Layered Lighting

Create a cozy ambiance with layered lighting. Use a combination of overhead lights, floor lamps, and table lamps to adjust the mood throughout the day.

Warm-toned bulbs can enhance the inviting atmosphere.

15. The Ultimate Reading Nook (Addictive!)

Transform a corner of your living room into a reading nook that invites you to curl up with a good book. A comfortable armchair, soft throw blankets, and a small bookshelf create the perfect retreat.

Add a side table for your favorite drink and a warm light for the ideal reading atmosphere.

16. Monochrome Magic

Embrace the elegance of a monochrome palette. Using varying shades of one color can create a chic and sophisticated living room.

Pair different textures to keep the space visually interesting.

17. Family-Friendly Fun

Design a living room that balances style with family-friendly features. Choose durable fabrics, and incorporate plenty of storage for toys and games.

Comfortable seating and playful decor can create a fun environment for all ages.

18. Statement Furniture

Incorporate statement furniture pieces that draw the eye. A unique coffee table or a bold sofa can become the focal point of your living room.

Choose pieces that reflect your personality and style.

19. Cozy Fireplace Setup

Create a cozy atmosphere with a fireplace as the focal point of your living room. Arrange seating to encourage conversation and warmth around the fire.

Use soft lighting and warm textiles to enhance the inviting feel.

20. Eclectic Mix

Combine different styles and eras for a truly unique living space. An eclectic mix of furniture, art, and decor can showcase your personality.

Don't be afraid to experiment with colors and textures to create a one-of-a-kind ambiance.

Conclusion

Your living room should be a reflection of your style and a sanctuary for relaxation. With these 20 decor ideas, you can create a space that feels inviting and uniquely yours.

Which idea inspired you the most? Share your thoughts and start your decorating journey!

How to get started with Opens source internship

Dike Pascal Ozioma — Sat, 15 Apr 2023 09:45:29 +0000

Open source software has been around for decades, and has transformed the technology industry. Open source projects are generally maintained by a community of developers, who work on the project in their spare time. However, as the complexity and importance of open source software has grown, more and more organizations are investing in open source projects. One way that organizations are contributing to open source is through paid internships.

Paid open source internships offer a unique opportunity for students and early-career professionals to gain real-world experience working on open source projects. These internships are a win-win situation for both the intern and the open source project. The intern gets to learn valuable skills, work on interesting projects, and make a real contribution to an open source project. Meanwhile, the open source project benefits from the intern's contributions and gains new contributors who may continue to contribute to the project after the internship is over.

One of the benefits of paid open source internships is that they allow students and early-career professionals to gain experience that is relevant to their future careers. Many software companies use open source software in their products, so having experience working on open source projects can be a valuable asset when applying for jobs. Additionally, open source projects often use modern development tools and practices, so working on an open source project can help interns learn these tools and practices.

Paid open source internships can also help to diversify the open source community. Traditionally, the open source community has been dominated by white men, and this has led to a lack of diversity in open source software. By offering paid internships, organizations can help to attract a more diverse pool of candidates, which can lead to more diverse open source projects and communities.

Open source projects that offer paid internships can also benefit from the increased attention and visibility that comes with having interns. Paid internships can attract talented individuals who may not have considered contributing to open source projects before. Additionally, by having interns work on specific projects, the project can move forward more quickly and with higher quality, leading to a better user experience for the end users.

However, there are also some challenges associated with paid open source internships. For example, open source projects often have limited resources, and paying interns can be expensive. Additionally, interns may require more supervision and guidance than volunteers, which can be a drain on the project's resources. Finally, there is always the risk that interns may not be as committed to the project as volunteers, and may leave the project after the internship is over.

Despite these challenges, paid open source internships are a great way for students and early-career professionals to gain experience working on real-world projects, contribute to open source software, and potentially build a career in open source software development. For open source projects, paid internships can bring in new contributors and help to diversify the project's community. It's a win-win situation for everyone involved, and a great way to promote the growth and development of open source software.

If you're interested in gaining real-world experience working on open source projects and making a valuable contribution to the open source community, paid open source internships can be a great opportunity. Here are some examples of paid open source internships and how to get started with each.

Google Summer of Code:

Google Summer of Code (GSoC) is a global program that offers students a paid internship to work on open source projects. The program is open to students over 18 years old, who are enrolled in an accredited college or university. Students can apply to work on a wide range of projects in areas such as web development, machine learning, data science, and more. To get started with GSoC, check out the list of participating organizations and their project ideas, and submit your application by the deadline.

Outreachy:

Outreachy is a paid internship program for people who are traditionally underrepresented in the tech industry, such as women, people of color, and LGBTQ+ individuals. The program offers internships to work on open source projects in a variety of areas, including web development, data science, and software engineering. To get started with Outreachy, check out the list of participating organizations and their project ideas, and submit your application by the deadline.

Microsoft Open Source Programs:

Microsoft offers several paid internship programs for students and early-career professionals to work on open source projects. These include the Microsoft Open Source Internship Program, the Microsoft Research Internship Program, and the Microsoft Garage Internship Program. To get started with these programs, check out the list of available internships and submit your application by the deadline.

Red Hat:

Red Hat is a leading provider of open source solutions, and offers paid internships to work on open source projects in areas such as cloud computing, middleware, and more. To get started with Red Hat, check out the list of available internships and submit your application by the deadline.

Linux Foundation:

The Linux Foundation is a non-profit organization that supports the growth of the Linux operating system and other open source technologies. The foundation offers several paid internship programs, including the CommunityBridge Program, the Open Source Mentorship Program, and the Open Mainframe Project Internship Program. To get started with these programs, check out the list of available internships and submit your application by the deadline.

To prepare for a paid open source internship, it's important to have a strong understanding of the open source project you're interested in working on. Start by researching the project's history, development process, and community. Join the project's mailing list or Slack channel, and start contributing to the project as a volunteer. This will give you a better understanding of the project's culture and workflow, and will help you stand out when applying for a paid internship.

In addition to contributing to open source projects, it's important to develop your technical skills. Take online courses or attend coding bootcamps to learn programming languages, tools, and frameworks that are commonly used in open source development. Build your own projects and share them on GitHub or other open source repositories to demonstrate your skills and experience.

Overall, paid open source internships are a great way to gain experience working on real-world projects, contribute to open source software, and potentially build a career in open source software development. By researching available programs and preparing for the application process, you can increase your chances of securing a paid open source internship and making a valuable contribution to the open source community.

The best practices for open-source contribution

Dike Pascal Ozioma — Fri, 14 Apr 2023 22:05:37 +0000

Open-source software development is becoming increasingly popular, and many developers are interested in contributing to open-source projects. However, contributing to open-source projects can be challenging, especially for beginners. In this blog post, we will discuss the best practices for open-source contribution to help developers make high-quality contributions successfully.

Follow the project's guidelines

Before contributing to an open-source project, it is essential to read the project's guidelines, coding standards, and development process. Following these guidelines will make it easier for the maintainers to review and merge your contributions. If you're not sure about something, don't hesitate to ask for clarification.

Communicate effectively

Effective communication is crucial when contributing to open-source projects. Use the project's communication channels, such as Slack or Discord, to discuss your ideas, ask for help, and get feedback on your contributions. Remember to be respectful and polite when communicating with other contributors and maintainers.

Test your changes

Before submitting your contribution, make sure to test your changes thoroughly. This includes testing your code on different platforms and environments and making sure that your changes don't break any existing functionality. You can also run the project's test suite to ensure that your changes don't cause any test failures.

Write clear documentation

Documentation is an essential part of any software project, and open-source projects are no exception. Document your code and explain your changes clearly in your pull request. This will make it easier for other contributors to understand your changes and for maintainers to review your contribution.

Be responsive to feedback

Be open to feedback from other contributors and maintainers. Respond to feedback promptly and make changes to your contribution as needed. Remember that feedback is an opportunity to improve your contribution and learn from other experienced developers.

Keep your contributions small and focused

Try to keep your contributions small and focused on a specific issue or feature. This will make it easier for maintainers to review and merge your changes and will also make it easier for other contributors to understand your contribution. Large contributions can be overwhelming and may require significant time and effort to review.

Be patient

Remember that open-source projects are often maintained by volunteers who have limited time. Be patient while waiting for feedback on your contribution and be understanding if your contribution is not accepted. Don't take rejection personally, and use the feedback to improve your skills and make better contributions in the future.

Conclusion

In conclusion, contributing to open-source projects can be a rewarding experience, but it requires effort and dedication. By following these best practices, you can make high-quality contributions successfully and become a valuable member of the open-source community. Remember to be respectful, communicate effectively, test your changes, write clear documentation, be responsive to feedback, keep your contributions small and focused, and be patient. With these best practices in mind, you can make a positive impact on the software development community and improve your skills as a developer.

How To Deploy A Laravel Project To DigitalOcean Droplet Using Github Action

Dike Pascal Ozioma — Sat, 04 Mar 2023 20:46:45 +0000

In this article, I will walk you through the step-by-step process of how you can deploy your Laravel application on the digital-ocean droplet, Before we get started below are some of the prerequisites for you to follow along in this article.

Prerequisites

To follow along in the article you should have a Laravel project already built and pushed to your GitHub repository, a basic understanding of GitHub Actions, and a digital-ocean account required. You can get started with Laravel here, and get started on Digital-ocean here. You will also need to create a droplet and set up your droplet, the following articles below can get you started.

Digital Ocean

Digital Ocean is a unique cloud hosting provider that offers cloud computing services to business entities so that they can scale themselves by deploying DigitalOcean applications that run parallel across multiple cloud servers without compromising on performance!

Github Action

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform that allows you to automate your build, test, and deployment pipeline.
You can create workflows that build and test every pull request to your repository or deploy merged pull requests to production. GitHub Actions goes beyond just DevOps and lets you run workflows when other events happen in your repository.
For example, you can run a workflow to automatically add the appropriate labels whenever someone creates a new issue in your repository. GitHub provides Linux, Windows, and macOS virtual machines to run your workflows, or you can host self-hosted runners in your own data center or cloud infrastructure.

Overview of GitHub Action Workflow

GitHub Action workflow consists of one or multiple jobs which contain one or multiple steps. To deploy our application, we need to create the following jobs:

Create GitHub Action build artifacts for deployment
We want to achieve the following for our Laravel application artifacts:

Install NPM dependencies.
Compile CSS and Javascript assets.
Install Composer dependencies.
Archive our build and remove unnecessary data (e.g., node_modules).
Store our archive so we can deploy it to our servers.

Prepare release on all our servers
We want the release preparation job to do the following:

Ensure we have a directory that holds every release.
Ensure we have a storage directory that shares data between releases.
Ensure we have a current directory that links to the active release.
Extract our build files into our releases directory.

Run optional before hooks
This is an optional feature, but I want to execute specific commands before the release is activated (e.g., chmod directories). So there needs to be a way to configure these so-called before hooks.

Activate the release
Now we are ready to activate our new release without any downtime. We can do this by changing symbolic links, this essentially swaps the underlying release, which is linked to our current directory, to a new release inside our releases directory. I'm running PHP FPM on my servers, so I also want to reload PHP FPM to detect the changes.

Run optional after hooks
This is an optional feature as well, but I want to execute specific commands after the release is activated to send a notification that my deployment is completed for example. So there needs to be a way to configure these so-called after hooks.

Cleaning up
Given that we are uploading and extracting new releases, we take up more disk space after each release. To make sure we don’t end up with thousands of releases and a full disk, we need to limit the number of release artifacts living on every server.

Project scaffolding

To start you will need a GitHub repository as testing your workflow requires you to commit and push your workflow .yml file, you should have one already with your Laravel project, I recommend you create a separate branch for this, Be sure to verify that in your project everything works before you continue.
Lastly, from your project root directory create a new workflow file, feel free to give it any name you would like and place it in the .github/workflows.

name: Deploy Application

on:
  push:
    branches: [ master ]

jobs:
  # Magic

Inside the .github/workflows/any_name_you_like.yml file write the following, make sure you choose a different branch if you don’t want to clutter your commit history, as you might end up pushing to GitHub several times, as you follow along.

Create deployment Artifacts

let's kick off by checking out our project by using the predefined checkout action by GitHub. Before we have something to deploy, we will start the build our Laravel application as we would typically do.

# // code from earlier is ommited for clearity

jobs:
  create-deployment-artifacts:
    name: Create deployment artifacts
    runs-on: ubuntu-latest

  steps:
  - uses: actions/checkout@v3

GitHub will checkout the code from our repository in the container; no further steps are necessary. Now that we have our code, we can continue compiling our assets.

# // code from earlier is ommited for clearity

- name: Compile CSS and Javascript
    run: |
      npm install
      npm run prod

Tip: If you use a CDN to deliver your static files, be sure to implement your own solution. The front-end assets are now shared amongst all servers individually, which is not ideal. It may impact your website speed since assets could be loaded from different servers on every request depending on your load-balancer.

We can now continue with our back-end code. Before we can install any composer packages, we need to make sure PHP is installed first. We will use the setup-php action by Shivam Mathur, which makes this a breeze.

# // code from earlier is ommited for clearity

  - name: Compile CSS and Javascript
    run: |
      npm ci
      npm run prod

  - name: Configure PHP 8.1
    uses: shivammathur/setup-php@master
    with:
      php-version: 8.1
      extensions: mbstring, ctype, fileinfo, openssl, PDO, bcmath, json, tokenizer, xml

This will configure PHP 8.1 and install the required extensions. If your application requires additional extensions, be sure to add them to the list. We can continue by installing our Composer dependencies.

# // code from earlier is ommited for clearity

  - name: Composer install
    run: |
    composer install --no-dev --no-interaction --prefer-dist

Time to test out what we’ve got so far! Commit your code changes and push them to GitHub. Once you’ve done so, visit the Actions page (https://www.github.com///actions)

You can click each job to see the execution output. If a job fails, it will show a red cross instead of a checkmark. The execution output will often provide you with the information you need to resolve the issue.

We’ve successfully compiled our front-end assets and installed our Composer dependencies. Now we need to store the results. GitHub provides an Upload-Artifact helper. This will help us to share the GitHub Actions artifacts between jobs.

You can upload single files, multiple files, and directories. Since we just want all our files deployed, I prefer to create a TAR archive, so we have a single file to work with. You could also create a ZIP archive, but this will require installing additional software in the build container as Ubuntu doesn’t ship with the required libraries.

  - name: Create deployment artifact
    run: tar -czf app.tar.gz *

This will create a new tar archive called app.tar.gz containing all the files, including the additional build artifacts we've made in the previous steps.

This works just fine, but the archive now contains files we don’t need, like the node_modules directory. We only required these to run the npm run production command. Let's fix this by excluding directories from our archive.

# //
- name: Create deployment artifact
  run: tar -czf app.tar.gz --exclude=*.git --exclude=node_modules --exclude=tests *

Our archive will now skip the .git, node_modules, and tests directories from our archive. If you have additional files that are not required to be on your production server, exclude them now. By making the archive smaller, your deployment will be quicker.

I want to change our archive's filename so it's easier to identify which commit our archive contains. GitHub has some global variables you can use in your .yml file, so let's change the name to the commit hash.

The DRY Principle in Software Development.

Dike Pascal Ozioma — Wed, 16 Nov 2022 17:10:50 +0000

When developing software or writing code there are so many principles or best practices to follow in order for your code to be readable, maintainable, and easy to optimize, sometimes this might be not very clear for beginners. One of these principles is DRY, which stands for Don't Repeat Yourself, it is a software development principle aiming to reduce code duplication which can lead to poor refactoring and maintenance. The DRY principle is simply about the duplication of knowledge, of intent. It's about expressing the same thing in two different places, possibly in two totally different ways.

The DRY Principle

The DRY principle states that every piece of knowledge must have a single, unambiguous, authoritative representation within a system.
It is always easy to copy and paste some code when you need it in some other place of your application. Especially when it is a hotfix, you are under a pressure, and you should do it as quickly as possible. If you think that now it is ok, later I will return and refactor this. And we know, that in most cases this will never happen until something again will be broken but this time because of this duplicated piece of code.
Every duplicated logic is a potential delayed-action mine. Duplication often leads to a maintenance nightmare. When you have the same logic in multiple locations and you need this code to be changed, chances are high that the necessary changes won't correctly be applied to every location where that piece of logic occurs. When these multiple locations come out of sync with one another a heap of bugs will appear. So, to avoid these types of bugs we need to be sure that the relevant piece of code exists only in a single location:

Assign to this source of truth a clear name.
Choose the right location for it
Reuse it, don't duplicate

Next time when we need to change it we exactly know where to look for. Avoiding duplication also improves the readability of the code. A small simple function or method is much easier to read and understand than a huge complex one.

Think before you DRY

We often think about DRY as duplicate code is bad, and code reuse is good, right? But it is a wrong approach. The principle is not about a code, it is about knowledge. Next time when you see a duplication of code do not immediately extract it to a method or an abstraction.
Maybe in this current context, duplication is not evil, it is normal.
Consider two classes Student and Teacher. Both have the same method with exactly the same logic. Should we extract a base Person class? Are we sure that the logic in these methods represents the same knowledge? Or this happened by accident.

<?php

class Student 
{
    public function getFullName()
    {
        return $this->lastname . ' ' . $this->firstname;
    }
}

class Teacher 
{
    public function getFullName()
    {
        return $this->lastname . ' ' . $this->firstname;
    }   
}

We have two classes Student and Teacher. Both of them gets fullname. Furthermore, the implementations of getting the fullname are identical. Should we extract? Let's try and see what happens. We can extract a parent class Person, put getFullName() method in it and then extend our classes from Person.

<?php

class Person
{
   public function getFullName()
    {
        return $this->lastname . ' ' . $this->firstname;
    } 
}

class Student extends Person {

    public function getFullName()
    {
      $this->getFullName();
    }

}

class Teacher extends Person {

    public function getFullName()
    {
      $this->getFullName();
    }
}

Really looks very nice, but in some days we are told that the teachers' full name should contain their middle name. Now what? We need to go and override parent's implementation.

As the result of our extraction we achieved nothing but complexity. We have a reusable thing that is used only once. It is not very clever. We should keep this duplication in these classes.

In this case, the duplication is not about a knowledge, it is only about a code. But this code represents different knowledge, even if it looks quite the same. When we make changes to Teacher, it is unlikely that the same changes will be done to a Student.

Premature Refactoring

You shouldn't apply the DRY principle if your business logic doesn't have any duplication yet. Again, it depends of the context, but, as a rule of thumb, trying to apply DRY to something which is only used in one place can lead to premature generalization.

One more example when we don't need to remove duplication is when the application will never be changed. When you are creating a prototype or some script that will be run once and then thrown away, it is ok to copy and paste some pieces of code, if they will never be changed. Code duplication costs a lot, but only if the code changes.

Rule Of Three

This rule can help us in making decision when to extract a duplicated code. It says: Extract duplication only when you see it the third time.
The first time you do something, you just write the code.
The second time you do a similar thing, you duplicate your code.
The third time you do something similar, you can extract it and refactor.

But why? Why should we duplicate our code, when we have always been said that it is wrong?
These simple steps are build to prevent you from prematurely and wrong refactoring, when the problem we are trying to solve is not yet clear. Prematurely refactoring a piece of code when we don't exactly see the problem behind it can cause tremendous problems in the future.

With only two examples of duplication, it can be dangerous to abstract, because some details of the specific scenario can bleed into the abstraction.
But when we have at least three examples of duplicated code we can more precisely define patterns and abstractions for it. These rules also prevent you wasting your time and making something reusable when at the end of the day you end up with only one use of it.

DRY and Code Duplication

Code reuse and code duplication are two different things. DRY states that you shouldn't duplicate knowledge, not that you should use abstractions to reuse everything, everywhere.

So DRY is all about knowledge? All about business logic? Let's look at some code snippets to understand why:

<?php

class CsvValidation
{
    public function validateProduct(array $product)
    {
        if (!isset($product['color'])) {
            throw new \Exception('Import fail: the product attribute color is missing');
        }

        if (!isset($product['size'])) {
            throw new \Exception('Import fail: the product attribute size is missing');
        }

        if (!isset($product['type'])) {
            throw new \Exception('Import fail: the product attribute type is missing');
        }
    }
}

This code doesn't look that bad, does it?, The method validates some CSV output in only one place (validateProduct()). This is the knowledge, and it's not repeated. but you might notice that there are conditionals statements everywhere Those If statements Isn't it an obvious violation of the DRY principle?
Well… no. It's not. I would call that unnecessary code duplication, but not a violation of the DRY principle.
we can restucture this code snipplet in a more readable and maintainable way, for example

<?php

class CsvValidation
{
    private $productAttributes = [
        'color',
        'size',
        'type',
    ];

    public function validateProduct(array $product)
    {
        foreach ($this->productAttributes as $attribute) {
            if (!isset($product[$attribute])) {
                throw new \Exception(sprintf('Import fail: the product attribute %s is missing', $attribute));
            }
        }
    }
}

It looks better, does it? There's no code duplication anymore!

Conclusion

Knowledge duplication is always a DRY principle violation.
Code duplication doesn't necessarily violate the DRY principle.

The idea of DRY is simple in theory: you shouldn't need to update in parallel multiple things when one change occurs. If your knowledge is repeated two times in your code and you need to change it, you might forget to change it everywhere. In your documentation, it could lead to misconceptions, confusion, and ultimately wrong implementations.

Where can one get a remote PHP Job

Dike Pascal Ozioma — Tue, 25 Oct 2022 20:41:14 +0000

Please if you anyone hiring, please drop the link or details on the comment below

Anyone looking for a Job is free to check the comment for job listings

How to build an Application with PHP and PostgreSQL

Dike Pascal Ozioma — Mon, 24 Oct 2022 19:13:03 +0000

Today, I am writing about how to build an application with PHP and PostgreSQL. This article assumes you have already installed PHP on your PC or MacBook, and that you know the basics of PHP, At least you built a PHP application with MYSQL.

What is PHP
PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open-source general-purpose scripting language that is especially suited for web development and can be embedded into HTML.

I assumed that you are already familiar with PHP syntax and that you have written your first PHP program. if not, I recommend you take an introduction to PHP course on youtube.

What is PostgreSQL
PostgreSQL, also known as Postgres, is a free and open-source relational database management system emphasizing extensibility and SQL compliance. It was originally named POSTGRES, referring to its origins as a successor to the Ingres database developed at the University of California.

How to install PostgreSQL
To install PostgreSQL on your PC or MacBook follow all the instructions in This Article depending on your local machine. if you are on a windows machine another easy way to install PostgreSQL is to install WAPP (Windows, Apache, PostgreSQL, PHP) stack. BITNAMI is a software package that offers a WAPP package. You can download it from “http://bitnami.org/learn_more/installers" and by double clicking the installer file, it is easily installed on Windows. While installing, it asks you where to install it and also asks for a password which will later be required to login into the phpPgAdmin.

Using PostgreSQL with PHP
In this article, am going to show you have to use PostgreSQL with PHP in a simple example. I am going to create a simple web application. I am going to connect to PostgreSQL using PHP native functions

PHP provides many functions for working directly with PostgreSQL databases. Here are some functions :

pg_connect: The function is used to open a PostgreSQL connection.

Version: (PHP 4, PHP 5)

Syntax :

pg_connect ( string $connection_string [, int $connect_type ] );

pg_query: The function is used to execute a query

Version: (PHP 4 >= 4.2.0, PHP 5)

Syntax :

pg_query ([ resource $connection ], string $query )

Insert data into the table with PHP

I will create an HTML form and a PHP script to insert data into the “book” table (assuming we have a database and table named book). Here is the code (file name insert.php),

<!DOCTYPE html> 
<head> 
<title>
Insert data to PostgreSQL with php - creating a simple web application
</title> 
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
<style> 
li {listt-style: none;} 
</style> 
</head> 
<body> 
   <h2>Enter information regarding book</h2> 
   <ul> 
       <form name="insert" action="insert.php" method="POST" >

         <li>Book ID:</li> 
         <li><input type="text" name="bookid" /></li> 
         <li>Book Name:</li> 
         <li><input type="text" name="book_name" /></li> 
         <li>Author:</li> 
         <li><input type="text" name="author" /></li> 
         <li>Publisher:</li> 
         <li><input type="text" name="publisher" /></li>

         <li>Date of publication:</li> 
         <li><input type="text" name="dop" /></li> 
         <li>Price (USD):</li>
         <li><input type="text" name="price" /></li> 
          <li><input type="submit" /></li> 
        </form> 
      </ul> 
</body> 
</html> 
<?php 
$db = pg_connect("host=localhost port=5432 dbname=postgres      user=postgres password=admin123"); 
$query = "INSERT INTO book VALUES ('$_POST[bookid]','$_POST[book_name]', '$_POST[author]','$_POST[publisher]','$_POST[dop]', '$_POST[price]')"; 
$result = pg_query($query);  
?>

Use this form to enter some data into the “book” table.

Retrieving and updating data with PHP

In the next step, I will create a form so that we can see the detail of book records and update the existing data of the “book” table. For this, we will create a form where the user can supply the book id and it will show all the information stored in the database regarding that particular book. So, you will learn how to fetch data from the table, how to display that data with PHP, and how to update the data.

Here is the code (file name enter-bookid):

<!DOCTYPE html>
<head>  
<title>
Enter bookid to display data - creating a simple web application
</title>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <style>
li {list-style: none;}
</style>
</head>
<body>
    <h2>Enter bookid and enter</h2>
    <ul>
      <form name="display" action="enter-bookid.php" method="POST" >
        <li>Book ID:</li>
        <li><input type="text" name="bookid" /></li>
        <li><input type="submit" name="submit" /></li>
      </form>
    </ul>
</body>
</html>
<?php
$db = pg_connect("host=localhost port=5432 dbname=postgres 
      user=postgres password=admin123");
$result = pg_query($db, "SELECT * FROM book where book_id = 
          '$_POST[bookid]'");
$row = pg_fetch_assoc($result);
if (isset($_POST['submit']))
{
echo "<ul>
       <form name='update' action='enter-bookid.php' method='POST' >
        <li>Book ID:</li>
        <li><input type='text' name='bookid_updated' 
        value='$row[book_id]'  /></li>
        <li>Book Name:</li>
        <li><input type='text' name='book_name_updated' 
        value='$row[book_name]' /></li>
        <li>Author:</li>
        <li><input type='text' name='author_updated' 
         value='$row[author]' /></li> 
        <li>Publisher:</li>
        <li><input type='text' name='publisher_updated' 
         value='$row[publisher]' /></li>  
        <li>Date of publication:</li>
        <li><input type='text' name='dop_updated' 
         value='$row[date_of_publication]' /></li>
        <li>Price (USD):</li>
        <li><input type='text' name='price_updated'    
        value='$row[price]' /></li>
      <li><input type='submit' name='new' /></li>  
    </form>
</ul>";
}
if (isset($_POST['new'])) {
   $result1 = pg_query($db, "UPDATE book SET book_id =  
  '$_POST[bookid_updated]', book_name = '$_POST[book_name_updated]',     
   author = '$_POST[author_updated]', publisher = '
   $_POST[publisher_updated]',date_of_publication = 
  '$_POST[dop_updated]', price = '$_POST[price_updated]'");
  if (!$result1){
    echo "Update failed!!";
  }else {
    echo "Update successfull;";
  }
}
?>

From this article, you have learned how to insert data from an HTML form and how to fetch, display and update data to PostgreSQL with PHP.
I recommend you take a detailed course in PostgreSQL with PHP, you can find some of them on Youtube.

Read more on this article on my medium page click here

follow me on twitter for more updates

Major Difference between Web2 and Web3

Dike Pascal Ozioma — Tue, 08 Mar 2022 21:54:02 +0000

Web3 has become the trending technology in recent time. Everybody is talking about it. Many companies has adopted the web3 technology. Today, I'm going to explain the major differences between web2 and web3.

What Is Web2

If you a beginner in this space you will be confused just like I was the first time I heard the word web2 or web 2.0. For the rest of this article I will be using web2.

The web2 is the current version of the Internet as we know it – less static and more dynamic. Web2 started to become popular in 2004, when the first Web2 conference was held. The system behind it aims to actively engage users, and the content itself is more user-generated. The way we share and deliver information has been transformed with Web2 components like blogs, wikis and social media platforms. Take Facebook or Twitter as examples: users can not only read information, they can also share thoughts, perspectives and opinions by liking, sharing, tagging, tweeting etc. Undoubtedly, there is a dependency on “Big Tech” companies to provide the infrastructure and services we need, a reliance Web3 hopes to remove.
The web browser technologies are used in Web2 development and it includes AJAX and JavaScript frameworks. Recently, AJAX and JavaScript frameworks have become a very popular means of creating web2 sites.

What is Web3

Web3 is the future, and a more intelligent, autonomous and open version of the Internet. Computers will be able to interpret information in a way that is more similar to humans, and by using technologies like Blockchain, Artificial Intelligence (AI), Augmented Reality (AR) and Virtual Reality (VR), users will be given more personalized content and experiences.

The Semantic Web (3.0) promises to establish “the world’s information” in a more reasonable way than Google can ever attain with their existing engine schema. This is particularly true from the perspective of machine conception as opposed to human understanding. The Semantic Web necessitates the use of a declarative ontological language like OWL to produce domain-specific ontologies that machines can use to reason about information and make new conclusions, not simply match keywords.

The purpose of Web3

The Internet is currently controlled by Big Tech companies like Youtube, Amazon, Netflix and Meta (Facebook), they hold the information, the power and the profits. Web3 plans to steer us towards decentralization of power and profits by instead letting it trickle down to the participants. At present, the most promising way to achieve this is would be to use blockchain technology and a version of Decentralized Applications (Dapps).

Difference between Web2 and web3

Web3 leverages artificial intelligence for offering correct results at a faster pace alongside accessing real-time insights.
Web2 enables free information sorting thereby enabling users to collectively retrieve and classify the information.
Web3 refers to the Semantic Web functionality. It implies that Web3 could support understanding the meaning of words. As a result, machines and humans could easily find, share and analyze information in web3.
web2 is also referred to as a participative social web. Users could now participate in the creation and sharing of responsive content alongside presenting favorable prospects for collaboration. Therefore, one can clearly notice how web2 is vital in encouraging the growth of new virtual communities.

This article is written as part of BLOCKGAMES, NESTCOIN and ZURI blockchain training