DEV Community: Evgeniy Panov

Setting Up React Project

Evgeniy Panov — Mon, 24 Aug 2026 08:02:37 +0000

I decided to write my own guide on React.

In this section, we’ll set up a React project.

1 Download Node

First, we need to install Node.js (if it’s not already installed). Download it from the official website: https://nodejs.org/en

2 Create a Project

Open the terminal, navigate to the folder where you want to create the project, and run the following command:

npm create vite@latest my_project -- --template react-ts

Let’s break down this command in more detail:

npm is the Node.js package manager that runs the command.
create vite is a subcommand that launches the Vite project generator.
@latest is explicitly requests the use of the latest version of the create-vite package. This isn’t required (the latest version is installed by default), but it’s safer in case an older version is cached.
my_project - the name of the folder where the project will be created. After running the command, a directory with this name will appear. Of course, you can specify any name instead of my_project.
-- is a separator. Anything that follows it is passed to the create-vite script itself, rather than to npm, and is not interpreted as npm options.
--template react-ts is an argument for the generator: create a React project with TypeScript (react-ts).

TypeScript is a strongly typed programming language that compiles to JavaScript.

Next, the terminal will prompt you to choose a linter. A linter is a program that checks your code for errors.

> Which linter to use?
> │ ● Oxlint
> │ ○ ESLint

You can choose either one.

Next, you’ll be asked whether to run the project

Install with npm and start now?
│  ● Yes / ○ No

Yes, let’s run it and make sure everything works

Next, you’ll need to wait just a moment, and eventually you’ll see a message that looks something like this:

VITE v8.2.1  ready in 692 ms

➜  Local:   http://localhost:5173/
➜  Network: use --host to expose
➜  press h + enter to show help

We can navigate to the URL shown above.

Hooray! We’ve just deployed the project.

3. Installing Tailwind CSS

Tailwind CSS is a CSS framework.

Install it like this (don’t forget to navigate to the project folder, because we’re currently in its parent folder)
cd my_project
npm install -D tailwindcss @tailwindcss/vite

Tailwind isn’t a CSS file; it’s a framework for generating CSS on the fly (more precisely, during the build phase).

For example, it excludes unused CSS classes and supports special directives.

To do this, you need to connect Tailwind to Vite; you can do this in the vite.config.ts file

import {defineConfig} from 'vite'
import react from '@vitejs/plugin-react'
import tailwindcss from '@tailwindcss/vite'

export default defineConfig({
    plugins: [react(), tailwindcss()]
})

To apply the changes, you need to reload the dev server (stop it with Ctrl+C and run npm run dev again).

But that’s not all—you need to include the generated CSS.

4. Let’s connect TailwindCSS and clean up the project

The CSS that will be generated needs to be imported into the src/index.css file (this is where all CSS files are consolidated).

@import "tailwindcss";

Everything else in this file should be deleted.

This index.css is already imported in src/main.tsx (the application’s entry point).
Make sure the following line is present there:

import './index.css'

In src/App.tsx, delete everything and insert the following code

function App() {
  return <>Hello world</>
}

export default App

Delete the src/App.css file and the assets folder along with all its contents

5 Set up the favicon

The final touch is to set up the site’s icon. I like this site, it has lots of free icons. It requires you to credit the author, and I encourage you to do so, for example on the Credits page.

After downloading the icon you like, name it icon.png and place it in the folder public/. Delete the other two files (favicon.svg and icons.svg).

Now go to index.html (located in the project root) and replace the line
<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
with
<link rel="icon" type="image/png" href="/icon.png" />

In some browsers, the icon may not update immediately; if it doesn’t appear, clear your browser’s cache.

6 README, License, and Git

The README is the face of the project, so it’s important to pay attention to it. I delete the default contents. Here’s the structure I use:

# Project Name
badges (I’ll cover these in other articles)
description
## Screenshots
...
## How to Run (and Configure)
...
## How to Use

Next, create a License.md file and copy the license text from here. Note that you need to replace <YEAR>and <COPYRIGHT HOLDER> with the appropriate values.

Our project template is now ready! Now let’s add it to Git.

git init
git add .
git commit -m init

That's all for now. See you in the next post.

Swoole: an asynchronous framework for PHP

Evgeniy Panov — Sat, 27 Dec 2025 19:08:39 +0000

Swoole is a high-performance extension for PHP that radically changes the approach to server application development. Unlike the classic PHP-FPM model, Swoole implements asynchronous I/O processing, uses coroutines, and provides built-in support for WebSocket and various network protocols.

Installation options

Swoole is distributed through the PECL repository. To get started, you will need to install the basic components:

sudo apt update
sudo apt install php php-dev php-pear

After completing the installation, you need to add the line extension=openswoole.so to the php.ini configuration file.
An alternative method is to use Composer:

composer require openswoole/core

Docker is suitable for an isolated development environment. You can use a ready-made PHP image with Swoole or create your own using Dockerfile:

FROM php:7.4-cli
RUN pecl install openswoole && docker-php-ext-enable openswoole

Assembling and launching the container:

docker build -t php-swoole .
docker run -p 9501:9501 -v $(pwd):/app -w /app php-swoole php your-script.php

Swoole Architecture

Swoole is built on a multi-process architecture with a clear separation of duties.

The master process coordinates the work of the entire system. It spawns reactor threads to handle networking, launches the process manager, and handles system signals.

Reactor threads run inside the master process and manage network connections. Using epoll or kqueue mechanisms, they asynchronously receive data from clients and send it for processing.

The process manager monitors the lifecycle of worker processes, controls their status, and restarts them if necessary.

Workers execute the main business logic of the application. They receive requests through reactor threads, process them, and generate responses.

Task Workers are designed to perform heavy operations that can block the main thread: lengthy calculations, calls to external APIs, and other resource-intensive tasks.

Request lifecycle:

A client request arrives at the main process's reactor thread
The reactor thread passes the data to a worker process
The worker process either handles the request itself or delegates tasks to task workers
The result is returned to the client via the reactor thread

Syntax basics

Creating an HTTP server begins with initializing an instance of OpenSwoole\HTTP\Server. Event handling is implemented through the on method, and sending a response is implemented through the end method of the Response object:

$server = new OpenSwoole\HTTP\Server("127.0.0.1", 9501);
$server->on("request", function ($request, $response) {
    $response->end("Hello World\n");
});
$server->start();

Coroutines are used for asynchronous programming, which are launched by the go or co::run functions.
WebSocket servers are configured similarly to HTTP servers with open, message, and close event handling.
The configuration of task processes looks like this:

$server->set(['task_worker_num' => 4]);
$server->on('task', function ($server, $taskId, $data) {
    // task processing logic
});

$server->on('finish', function ($server, $taskId, $returnValue) {
    // actions after completion
});

TCP/UDP servers and clients
The OpenSwoole\Server class is used to create TCP/UDP servers. Parameters are configured using the set method:

$server = new OpenSwoole\Server("127.0.0.1", 9501);
$server->set(['worker_num' => 4]);
$server->on('receive', function ($server, $fd, $reactor_id, $data) {
    $server->send($fd, 'Received: '.$data);
    $server->close($fd);
});
$server->start();

The OpenSwoole\Coroutine\Client class is used for client connections, providing non-blocking network operations:

use OpenSwoole\Coroutine\Client;

co::run(function() {
    $client = new Client(SWOOLE_SOCK_TCP);
    if (!$client->connect('127.0.0.1', 9501, 0.5)) {
        echo "Connection failed: {$client->errCode}\n";
    }
    $client->send("Hello World\n");
    echo $client->recv();
    $client->close();
});

HTTP and WebSocket with coroutines

An HTTP server is created using the OpenSwoole\HTTP\Server class. Coroutines allow multiple requests to be processed in parallel without blocking:

use OpenSwoole\HTTP\Server;
use OpenSwoole\Http\Request;
use OpenSwoole\Http\Response;

$server = new Server("0.0.0.0", 9501);
$server->on("request", function (Request $request, Response $response) {
    $response->end("Hello, Swoole HTTP!");
});
$server->start();

The WebSocket server provides bidirectional communication via TCP. The open, message, and close events allow you to control the entire connection lifecycle:

use OpenSwoole\WebSocket\Server;
use OpenSwoole\Http\Request;
use OpenSwoole\WebSocket\Frame;

$server = new Server("0.0.0.0", 9502);
$server->on("open", function (Server $server, Request $request) {
    echo "New connection:  {$request->fd}\n";
});
$server->on("message", function (Server $server, Frame $frame) {
    echo "Message received:  {$frame->data}\n";
    $server->push($frame->fd, "echo: {$frame->data}");
});
$server->on("close", function ($ser, $fd) {
    echo "Connection closed: {$fd}\n";
});
$server->start();

Practical examples

A WebSocket server with routing and SSL support demonstrates Swoole's capabilities for creating secure real-time applications. Routing allows you to separate the logic for processing different types of requests, while SSL provides traffic encryption.
An HTTP server with a routing system and validation shows how to implement a REST API with authentication and processing of various HTTP methods.
Detailed documentation and additional examples are available on the official project website.