
## Project Overview
In this project, we’ll build a dynamic blog application with the following features:

- Dynamic routes for blog posts.

- Real-time fetching of blog content from a mock API.

- SEO-optimized pages using Next.js 14 metadata tools.

- Responsive design with CSS modules.

By the end of this tutorial, you will have a deployable blog application.

## Setting Up the Environment

1. Install Node.js
Ensure you have Node.js version 18 or higher installed on your system.


2. Initialize the Project
Run the following command to set up a new Next.js project:
```bash
npx create-next-app@latest blog-app
cd blog-app
```


3. Start the Development Server
Launch the server to view the app:
```bash
npm run dev
```
Open your browser and navigate to 

<p className="bg-yellow-200 px-3 py-2 rounded-lg">
http://localhost:3000.
</p>


## Creating a Dynamic Blog App

1. Setting Up the Blog Structure

Create a folder for the blog pages under the app directory:
```bash
mkdir -p app/blog/[slug]
```
2. Dynamic Routing with App Router

Create a dynamic route for blog posts:
```jsx
// app/blog/[slug]/page.js
import { use } from 'react';

async function fetchPost(slug) {
  const res = await fetch(`https://jsonplaceholder.typicode.com/posts/${slug}`);
  if (!res.ok) throw new Error('Post not found');
  return res.json();
}

export default function BlogPost({ params }) {
  const post = use(fetchPost(params.slug));

  return (
    <article>
      <h1>{post.title}</h1>
      <p>{post.body}</p>
    </article>
  );
}
```
Key Concepts:

Dynamic Routing: [slug] allows the app to handle different URLs dynamically.

Server-Side Rendering: use(fetchPost) fetches data on the server for better SEO.


3. Fetching Blog Posts

To display a list of blog posts, create an index page:
```jsx
// app/blog/page.js
import Link from 'next/link';

async function fetchPosts() {
  const res = await fetch('https://jsonplaceholder.typicode.com/posts');
  return res.json();
}

export default async function Blog() {
  const posts = await fetchPosts();

  return (
    <section>
      <h1>Blog Posts</h1>
      <ul>
        {posts.map((post) => (
          <li key={post.id}>
            <Link href={`/blog/${post.id}`}>{post.title}</Link>
          </li>
        ))}
      </ul>
    </section>
  );
}
```
4. Styling the Application

Add styles using CSS Modules:
```css
/* styles/blog.module.css */
.container {
  font-family: Arial, sans-serif;
  margin: 0 auto;
  max-width: 800px;
  padding: 1rem;
}

h1 {
  color: #333;
}
```

Import the styles in your components:
```jsx
import styles from './styles/blog.module.css';

export default function Blog() {
  // Use `styles.container` for styling
}
```

## Adding SEO Optimization

Use the Metadata API to add SEO tags to the blog:

```js
export const metadata = {
  title: 'Dynamic Blog App | Next.js 14',
  description: 'A fully functional blog app built with Next.js 14.',
};
```
For individual blog posts, generate dynamic metadata:
```js
export async function generateMetadata({ params }) {
  const post = await fetchPost(params.slug);
  return {
    title: `${post.title} | Blog`,
    description: post.body.substring(0, 150),
  };
}
```
## Deploying the Application

1. Install Vercel CLI:
```bash
npm install -g vercel
```

2. Deploy the App:
Run the following command and follow the prompts:
```bash
vercel
```

3. Live URL: Your app will be live at a unique URL provided by Vercel.




In this tutorial, we’ll build a fully functional  blog application using Next.js 14, leveraging its newest features for dynamic routing, SEO, and performance optimization. This project is designed to help you learn practical Next.js 14 concepts step-by-step. 

Documentation Officielle Next Js

How Do I Create Web App Using Next Js ?

Blogging App Using Next Js For A Full-Stack Application

JSONPlaceholder API (Mock Data)

Vercel Deployment Guide

Build a Blog Application with Next.js 14: A Step-by-Step Tutorial 


# This the post we're going about all the time and we like it though


Genuine reality seen among some whose trying to get more done

Learning Mandarin for Engineers

Docker Installation Guide

Basic Concept Of Coding And Then Not Doing Anything


```jsx
   // pages/search.js
import { useState, useEffect } from "react";
import Fuse from "fuse.js";
import { useRouter } from "next/router";
import fs from "fs";
import path from "path";
import Layout from "@/components/Layout";
import { format } from "date-fns";
import Link from "next/link";
export default function SearchResultsPage({ blogs }) {
  const [filteredBlogs, setFilteredBlogs] = useState([]);
  const [loading, setLoading] = useState(true);
  const { query } = useRouter();

  useEffect(() => {
    if (query.query) {
      setLoading(true);
      const fuse = new Fuse(blogs, {
        keys: ["title", "description", "tags", "category"],
        includeScore: true,
        threshold: 0.4,
      });
      const results = fuse.search(query.query);
      setFilteredBlogs(results.map((r) => r.item));
      setLoading(false);
    }
  }, [query.query, blogs]);

  return (
    <Layout>

    <div className="max-w-4xl mx-auto px-4 py-8">
      <h1 className="text-2xl font-bold mb-4">Search Results</h1>
      {loading ? (
        <p>Loading...</p>
      ) : (
        <div className="grid lg:grid-cols-2 gap-4">
          {filteredBlogs.length > 0 ? (
            filteredBlogs.map((blog, index) => (
              <Link key={blog.id} href={`/blog/${blog.title.replace(/\s+/g, '-').toLowerCase()}`}>

              <div key={index} className="my-3 py-2 border-b border-gray-200">
                <h2 className="text-xl underline font-semibold">{blog.title}</h2>
                <p className="my-3">{blog.description}</p>

                <div className="flex gap-2 items-center justify-between">
                <p className="flex items-center gap-2">

                <img src={blog.authorImage} width="24" className="rounded-full ring-2  object-cover"/>
                <span className="dark:text-gray-50 text-gray-700">{blog.author}</span>
                </p>
                <div className="text-gray-600 mb-1 dark:text-gray-300 text-sm">
                {format(new Date(blog.date), 'MMMM dd, yyyy')}</div>

                <div className="text-sm text-blue-500 mb-1 hidden sm:block">{blog.category}</div>

              </div>              </div></Link>
            ))
          ) : (
            <p>No results found.</p>
          )}
        </div>
      )}
    </div>
    </Layout>
  );
}

// Fetch blogs data at build time from blogs.json
export async function getStaticProps() {
  const filePath = path.join(process.cwd(), "markdown", "blogs.json");
  const jsonData = fs.readFileSync(filePath, "utf-8");
  const blogs = JSON.parse(jsonData);

  return {
    props: {
      blogs,
    },
  };
}
```

---
## data/categories.js 

Quelle sont les manieres le plus directe pour remplacer dans un fichier ce qui le rend facile a faire

```jsx
export const categories = [
    {
      id: 1,
      name: 'Well-being',
      description: 'Tips and tricks to improve your wellness.',
      slug: 'well-being',
      icon: '/icons/wellbeing-icon.png',
    },
    {
      id: 2,
      name: 'Life',
      description: 'Articles about life balance and lifestyle.',
      slug: 'life',
      icon: '/icons/life-icon.png',
    },
    {
      id: 3,
      name: 'Marketing',
      description: 'Find peace in everyday life.',
      slug: 'marketing',
      icon: '/icons/peaceful-life-icon.png',
    },
    {
      id: 4,
      name: 'English ',
      description: 'Where you will find best english course.',
      slug: 'english',
      icon: '/icons/peaceful-life-icon.png',
    },
  ];
  ```


About that question , we're down the hall to give some response, How Does Apple Make Their Product Design So Wondrous 

How Does Apple Make Their Product Design So Wondrous

Full-stack development is a vast field that encompasses various technologies. It refers to the development of both the front end (client side) and back end (server side) of an application.

### What Does Full-Stack Development Include?

Full-stack development covers several technologies, such as:

1. **Front-End Development**:
   - HTML
   - CSS
   - JavaScript frameworks like React, Angular, Vue, etc.


Concentration to get this coding project done is a side effect that we can't get enough of as long we know how to deal with it

Step By Step guide to ultimate reprogramation


Pour connaitre les avantages que nous donnons veuiller le faire
```js
./styles/globals.css
./pages/_app.js
 ✓ Compiled in 1540ms (610 modules)
 ✓ Compiled in 1343ms (613 modules)
 GET /_next/data/development/blog/this-will-let-you-be-what-you're-suppose-to.json?slug=this-will-let-you-be-what-you%27re-suppose-to 200 in 240ms
 ✓ Compiled in 1210ms (611 modules)
 GET /_next/data/development/index.json 200 in 302ms
 ○ Compiling /_error ...
 ✓ Compiled /_error in 980ms (613 modules)
 GET /icons/wellbeing-icon.png 404 in 1125ms
 GET /icons/life-icon.png 404 in 1121ms
 GET /icons/peaceful-life-icon.png 404 in 1118ms
 GET /_next/data/development/blog/6.json?slug=6 404 in 76ms
 GET /_next/data/development/blog/6.json?slug=6 404 in 16ms
 GET /blog/6 404 in 26ms
 GET /blog/6 404 in 12ms
 GET / 200 in 63ms
 GET /icons/wellbeing-icon.png 404 in 44ms
 GET /icons/life-icon.png 404 in 35ms
 GET /icons/peaceful-life-icon.png 404 in 32ms
 ○ Compiling /blog ...
 ✓ Compiled /blog in 1625ms (1000 modules)
 GET /_next/data/development/blog.json 200 in 229ms
 GET /_next/data/development/blog/installation-et-configuration-de-docker-sur-linux-(-ubuntu-).json?slug=installation-et-configuration-de-docker-sur-linux-%28-ubuntu-%29 200 in 180ms
 GET /_next/data/development/blog.json 200 in 96ms
 GET /_next/data/development/blog/this-will-let-you-be-what-you're-suppose-to.json?slug=this-will-let-you-be-what-you%27re-suppose-to 200 in 50ms


These computer have been built to stand out at any level and go for as much 

Optimised To Do 24 7 Jobs And More

Est-ce Possible D'apprendre l'American English Tout En Etant Hors America est une question quise pose parmis tant de 

C'est Quoi Le Fondement de la recherche basique

# Installation et configuration de Docker sur Linux

## 1. Mise à jour du système
Avant de commencer, assurez-vous que votre système est à jour.


```bash
sudo apt update && sudo apt upgrade -y
```
## 2. Instalation des dependances necessaires
Installez les paquets requis pour permettre à Docker de fonctionner correctement.
```bash
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
```
## 3. Ajout de la clé GPG de Docker et du dépôt officiel

```bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```
## 4. Installation de Docker Engine
Mettre a jour les paquets et installez Docker
```bash
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io
```
## 5. Vérification de l'installation de Docker

Assurez-vous que Docker est installé correctement.

sudo docker --version

## 6. Configuration des permissions pour l'utilisateur

Ajoutez votre utilisateur au groupe docker pour éviter d'utiliser sudo à chaque commande Docker.
```bash
sudo usermod -aG docker $USER
newgrp docker
```
## 7. Test de Docker

Testez Docker en exécutant l'image hello-world.
```bash
docker run hello-world
```
---
# Installation d'un conteneur Docker

## 1. Recherche d'une image sur Docker Hub

Utilisez la commande suivante pour rechercher une image (par exemple, nginx).
```bash
docker search nginx
```

## 2. Téléchargement d'une image Docker

Téléchargez l'image choisie, ici l'image nginx.
```bash
docker pull nginx
```

## 3. Lancement d'un conteneur

Lancez un conteneur basé sur l'image téléchargée.
```bash
docker run -d -p 80:80 --name my-nginx nginx

-d : Exécute le conteneur en arrière-plan.

-p 80:80 : Mappe le port 80 du conteneur au port 80 de l'hôte.

--name my-nginx : Nomme le conteneur my-nginx.
```

## 4. Liste des conteneurs actifs

Vérifiez les conteneurs en cours d'exécution.
```bash
docker ps
```

## 5. Gestion des conteneurs

Arrêter un conteneur :
```bash
docker stop my-nginx
```

- Redémarrer un conteneur :

```bash
docker start my-nginx
```

- Supprimer un conteneur :

```bash
docker rm my-nginx
```
- Supprimer une image :

```bash
docker rmi nginx
```

---

## Gestion avancée des conteneurs

### 1. Création d'un fichier Docker Compose

Créez un fichier docker-compose.yml pour orchestrer plusieurs conteneurs. Exemple avec nginx et mysql :

```bash
version: '3.8'
services:
  web:
    image: nginx
    ports:
      - "80:80"
  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: example
```

### 2. Lancer les services avec Docker Compose

Démarrez les conteneurs définis dans le fichier docker-compose.yml.
```bash
docker-compose up -d
```

### 3. Arrêter les services

Arrêtez les conteneurs.
```bash
docker-compose down
```

---

Avec ce guide, vous pouvez installer Docker, configurer votre environnement, et commencer à travailler avec des conteneurs. Assurez-vous de personnaliser les commandes selon vos besoins.



It's a type of misunderstanding when it comes to builing our own foreign language skill

What Do You Need To Know Before You Go For Being Self-Taught

Once we've mastered the basic you will be prone to subdue the rest , mistake ,right? 

Not Only Learning Is Enough To Fall Into Place Easily

# JavaScript Fundamentals Course

<details markdown='1'><summary>Expand / Collapse</summary>
Take it to the palin
- Great bills
-  The lighter
- Make money

</details>

Welcome to the JavaScript Fundamentals Course! This course is designed to teach you JavaScript from the basics to advanced topics with practical code examples.

We’ll cover variables, functions, conditionals, loops, and much more!


## Introduction

JavaScript is the most popular language for web development. It allows you to build interactive and dynamic websites. Here’s the first piece of code to get started:


```js
// This is a simple JavaScript program
console.log("Hello, JavaScript!");
let greeting = "Hello World"; // String
let score = 100; // Number
let isCompleted = true; // Boolean

let fruits = ["Apple", "Banana", "Cherry"]; // Array
let person = { name: "John", age: 30 }; // Object

console.log(typeof greeting); // Output: string
console.log(fruits[1]); // Output: Banana
console.log(person.name); // Output: John
```
## Refreshner 
 
 we're going to have down bellow some more
---





Why is not the good question but how the have done such thing at all

Windows Is Officially A Linux Based OS ( Kernel)

## Introduction to Next.js 14

Next.js, the React-based framework by Vercel, continues to innovate with the release of version 14. It empowers developers to create fast, scalable, and feature-rich applications while simplifying complex workflows.

## What's New in Next.js 14?

### Improved App Router

Next.js 14 enhances the App Router, enabling seamless server and client components with improved hydration and streaming capabilities. These improvements significantly reduce Time to Interactive (TTI).

### Enhanced Performance

Performance optimization remains a priority, with features like automatic prefetching and optimized bundle splitting. The integration of Turbopack as the default bundler further boosts build speed.

### AI-Powered Features

Next.js 14 introduces AI-based tools like AI Routing Assistance, allowing applications to adapt routing dynamically based on user behavior.

## Setting Up a Next.js 14 Project

Follow these steps to create a new Next.js 14 project:

1. Install Node.js
Ensure you have Node.js 18 or higher installed.


2. Initialize a New Project

npx create-next-app@latest my-next-app
```bash
cd my-next-app
```

3. Start the Development Server
```bash
npm run dev
```
Your development server should now be running at http://localhost:3000.

Code Example: Building a Dynamic Web Page

Here's a simple example of building a dynamic blog page using the new App Router:

```jsx
// app/blog/[slug]/page.js
import { use } from 'react';

async function fetchPost(slug) {
  const res = await fetch(`https://api.example.com/posts/${slug}`);
  if (!res.ok) throw new Error('Post not found');
  return res.json();
}

export default function BlogPost({ params }) {
  const post = use(fetchPost(params.slug));

  return (
    <article>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </article>
  );
}
```
Key Highlights:

Dynamic Routing: [slug] allows dynamic URL handling.

Async Data Fetching: use(fetchPost) simplifies fetching and rendering.



---

## SEO Best Practices in Next.js 14

1. Optimize Metadata
Use the new <Metadata> component in the App Router to set SEO metadata:

export const metadata = {
  title: 'Next.js 14 Blog',
  description: 'Learn all about Next.js 14 with code examples and resources.',
};


2. Server-Side Rendering (SSR)
Leverage SSR for better search engine indexing:

```jsx
export async function getServerSideProps(context) {
  const data = await fetch('https://api.example.com/data');
  return { props: { data } };
}
```

3. Image Optimization
Utilize the <Image> component for responsive and lazy-loaded images.


4. Sitemap Generation
Automate sitemap generation using tools like next-sitemap.




---

## Additional Resources

1. Official Next.js 14 Documentation


2. Next.js GitHub Repository


3. Vercel's Blog on Next.js 14 Features


4. Introduction to Turbopack


---

## Conclusion

Next.js 14 elevates web development with its innovative features and seamless developer experience. Whether you're a beginner or a seasoned developer, this release has tools to make your applications faster, smarter, and more efficient.

Happy coding!

---

SEO Tip: Ensure this blog includes relevant keywords such as "Next.js 14," "React framework," "modern web development," and "Next.js tutorial."


Next.js 14 is a significant milestone for modern web development. In this blog, we'll explore its key features, walk through code examples, and provide resources to help you get started.

Next.js 14: A Comprehensive Guide with Code Examples 

4. Code Example: Building a Dynamic Web Page

# Table des matières

1. [Les bases de PowerShell](#les-bases-de-powershell)  
2. [Commandes de base](#commandes-de-base)  
3. [Variables et types de données](#variables-et-types-de-données)  
4. [Boucles et conditions](#boucles-et-conditions)  
5. [Fonctions](#fonctions)  
6. [Gestion des fichiers et répertoires](#gestion-des-fichiers-et-répertoires)  
7. [Modules et importation](#modules-et-importation)  


## Les bases de PowerShell

### Lancement de PowerShell
Pour ouvrir PowerShell :
1. Recherchez "PowerShell" dans le menu démarrer.
2. Cliquez sur **Windows PowerShell** ou **Windows PowerShell ISE** pour l'interface graphique.

### Cmdlets : Qu'est-ce que c'est ?
Les **cmdlets** (prononcées "command-lets") sont des commandes PowerShell intégrées au langage. Elles suivent généralement le format `Verbe-Nom`.

**Exemple :**
```powershell
Get-Process   # Obtenir la liste des processus actifs
```
### Commande de base
#### Obtenir de l'aide,Pour obtenir des informations sur une commande :
```powershell
Get-Help <Nom-De-La-Commande>
```
Exemple:
```powershell
Get-Help Get-process
```
#### Liste des cmlets disponibles
```powershell
Get-Command
```
Decouvrir la version de PowerShell
```powershell
$PSVersionTable.PSVersion
```
#### Variables et types de donnees 
Declaration de variables

## step-2-practice


### Boucles et conditions
```powershell
if ($condition) {
    # Instructions si vrai
} else {
    # Instructions si faux
}

Exemple:

if (5 -gt 3) {
    Write-Output "5 est plus grand que 3"
} else {
    Write-Output "5 n'est pas plus grand que 3"
}

foreach ($item in $collection) {
    # Instructions
}

Exemple:

$jours = @("Lundi", "Mardi", "Mercredi")
foreach ($jour in $jours) {
    Write-Output "Aujourd'hui, c'est $jour"
}

```


admin systeme job is now available to any one with just a GED

How do you want to build the infras of a single server 

## 1. Introduction to Tailwind CSS

Tailwind CSS is a utility-first CSS framework designed to speed up front-end development. Unlike traditional CSS, which involves writing custom styles for elements, Tailwind provides pre-defined classes for styling directly in your HTML.

With Tailwind, you can build beautiful, responsive designs without writing a single line of custom CSS.

## 2. Why Choose Tailwind CSS Over Pure CSS?
### 1. Faster Development

With Tailwind CSS, you can skip creating custom classes and jump straight into styling. Instead of juggling between CSS and HTML files, you apply styles directly in your HTML using Tailwind’s utility classes.

Example:
```html

<div class="card">Welcome to Tailwind!</div>
```

```css
/* CSS */
.card {
  background-color: #f8fafc;
  color: #1a202c;
  padding: 1rem;
  border-radius: 0.5rem;
}
```

```html
Tailwind CSS

<div class="bg-gray-100 text-gray-900 p-4 rounded-md">Welcome to Tailwind!</div>

Notice how Tailwind eliminates the need for a separate CSS file.
```
### 2. Consistency and Reusability

Tailwind ensures a consistent design system by using predefined spacing, colors, and typography scales. This removes the need to define custom values for every project, resulting in a unified and professional look.

### 3. Responsive Design Made Simple

Creating responsive designs with pure CSS can involve writing multiple @media queries, which gets repetitive. Tailwind’s responsive design utilities allow you to define breakpoints right in the class names.

Example:
```html
<div class="bg-blue-500 md:bg-green-500 lg:bg-red-500">
  Responsive Background
</div>
```

Here, the background changes based on screen size.
### 4. No More Naming Confusion

Naming CSS classes is often challenging. With Tailwind, you don’t need to worry about naming conventions; the utility classes describe exactly what they do.
* Code Comparison: Tailwind CSS vs. Pure CSS *

Here’s a comparison of creating a simple button with hover effects:

### Pure CSS
```html

<button class="btn">Click Me</button>
```
```css
/* CSS */
.btn {
  background-color: #4f46e5;
  color: white;
  padding: 0.5rem 1rem;
  border: none;
  border-radius: 0.375rem;
  transition: background-color 0.3s;
}

.btn:hover {
  background-color: #4338ca;
}
```
Tailwind CSS
```html
<button class="bg-indigo-600 text-white px-4 py-2 rounded-md hover:bg-indigo-700">
  Click Me
</button>
```
With Tailwind, everything is in one place, and there’s no need to switch files.

# 5. Conclusion

Tailwind CSS empowers developers to build faster, more consistent, and responsive designs without the hassle of writing custom CSS. By adopting this utility-first framework, you can streamline your workflow, maintain clean code, and create beautiful interfaces effortlessly.

If you haven’t tried Tailwind yet, now’s the time!

This blog post explores the advantages of using Tailwind CSS over pure CSS, with real-world examples and code snippets to help you make an informed decision.

Posts by peter nzana