DEV Community: Evgeniy Panov

React as template engine

Evgeniy Panov — Thu, 03 Sep 2026 20:11:13 +0000

In the previous article, we set up the project: we installed React, TypeScript, and Tailwind CSS.

Now let's start diving into React itself. And we'll begin with components.

React as a Templating Engine

What are templating engines? When working with plain HTML, we might run into repeating structures, for example, user cards:

<div class="user-card">
    <img src="..." alt="Alex">
    <h2>Alex</h2>
    <p>Backend developer</p>
</div>

<div class="user-card">
    <img src="..." alt="Maria">
    <h2>Maria</h2>
    <p>Designer</p>
</div>

<div class="user-card">
    <img src="..." alt="John">
    <h2>John</h2>
    <p>Web developer</p>
</div>

If we wanted to change the name style, we'd have to change it in every card. Templating engines allow us to break HTML into reusable elements (components).

We can pass data into components (to distinguish one user card from another). The components themselves can also be broken down into other components, forming a hierarchy.

You can think of components as custom HTML tags, for example:

<UserCard name="Maria" avatar="..." position="Designer"/>

A component can be anything from a small button to an entire section on a page.

Let's practice and create a page with comments. First, create a Components folder inside the src folder, and inside it, a Comment.tsx file. So the file path is src/Components/Comment.tsx.

function Comment() {
    return (
        <div>Text of comment</div>
    );
}

export default Comment

We simply created a function and exported it. If you're not familiar with import/export yet, here's an article about them.

Next, modify the src/App.tsx file:

import Comment from './Components/Comment.tsx'

function App() {
    return <>
        <Comment />
    </>
}

export default App

Run the server if it's not already running, and look at our page:

npm run dev

We should see "Text of comment" on the page.

So, a component is simply a function that returns something that looks a lot like HTML. This thing is called JSX, and under the hood, it gets transformed into a special JavaScript object.

Also, it's important that the component's name (our function) starts with a capital letter. By the way, App is also a component.

Now let's make our example a bit more complex. First, change App.tsx:

import {Comment} from "./Components/Comment.tsx";

function App() {
    return <>
        <h2 className="text-2xl font-bold text-center text-gray-800">Comments:</h2>
        <div className="max-w-2xl mx-auto p-4">
            <Comment
                avatarUrl="https://i.pravatar.cc/40?img=26"
                userName="Maria"
                createdAt="2 hours ago"
                content="Text of the comment"
                likeCount={14}
            />
        </div>
    </>
}

export default App

In essence, JSX is very similar to regular HTML, but there are some differences. First, we use <></> tags here.

According to React rules, a component must have only one root tag. We could have used a div instead, but empty tags allow us to avoid creating unnecessary wrappers.

Also, instead of the class attribute, we use className (because class is a reserved word). We're using class names from Tailwind.

Also, the like count is wrapped in curly braces. That's because what's inside curly braces is treated as a JavaScript expression. If we had written likeCount="14", "14" would have been treated as a string (and TypeScript's main purpose is to ensure type consistency).

Now let's change the comment component in Comment.tsx:

import React from 'react';
import { Avatar } from './Avatar';
import { CommentHeader } from './CommentHeader';
import { CommentContent } from './CommentContent';
import { CommentActions } from './CommentActions';

interface CommentProps {
    avatarUrl: string;
    userName: string;
    createdAt: string;
    content: string;
    likeCount?: number;
}

export const Comment: React.FC<CommentProps> = ({
        avatarUrl,
        userName,
        createdAt,
        content,
        likeCount = 0,
    }) => {
    return (
        <div className="flex gap-3 p-4 mb-4 border border-gray-200 rounded-lg shadow-sm">
            <Avatar src={avatarUrl} alt={userName} />
            <div className="flex-1">
                <CommentHeader userName={userName} createdAt={createdAt} />
                <CommentContent content={content} />
                <CommentActions likeCount={likeCount} />
            </div>
        </div>
    );
};

First, we import some components that we'll create shortly (meaning there should be an error right now - an attempt to import non-existent components). Then we declare the type for props. Props are the data passed into the component.

Looking ahead, if we pass data from a parent component, we cannot change it directly inside the child component. Next, we immediately export our component (remember, a component is a function). React.FC<CommentProps> is the function's type (its signature - argument types and return type).

Strictly speaking, it's not mandatory to specify this type, because TypeScript can infer the return type automatically. However, when passing props to components, it's highly recommended to specify the type so the IDE knows the structure of the props object.

Thus, in export const Comment: React.FC<CommentProps> = (...) => {...}, we're exporting a constant of type React.FC<CommentProps> and assigning it a function/component.

I hope you're familiar with arrow functions in JavaScript (yes, a component can also be an arrow function).

Next, we use destructuring syntax to unpack the props. Finally, we return JSX. Inside it, we use other components (which we'll create very soon) and pass arguments (props) that we received from the App component.

Now it's time to create the other components. Create these files:

src/Components/Avatar.tsx

import React from 'react';

interface AvatarProps {
    src: string;
    alt: string;
}

export const Avatar: React.FC<AvatarProps> = ({ src, alt }) => {
    return (
        <img
            src={src}
            alt={alt}
            className="w-10 h-10 rounded-full object-cover flex-shrink-0"
        />
    );
};

src/Components/CommentContent.tsx

import React from 'react';

interface CommentContentProps {
    content: string;
}

export const CommentContent: React.FC<CommentContentProps> = ({ content }) => {
    return <p className="text-sm text-gray-800 mb-2">{content}</p>;
};

src/Components/CommentHeader.tsx

import React from 'react';

interface CommentHeaderProps {
    userName: string;
    createdAt: string;
}

export const CommentHeader: React.FC<CommentHeaderProps> = ({
        userName,
        createdAt,
    }) => {
    return (
        <div className="flex items-center gap-2 mb-1">
            <span className="font-semibold text-sm">{userName}</span>
            <span className="text-xs text-gray-500">{createdAt}</span>
        </div>
    );
};

src/Components/CommentActions.tsx

import React from 'react';

interface CommentActionsProps {
    likeCount: number;
}

export const CommentActions: React.FC<CommentActionsProps> = ({ likeCount }) => {
    return (
        <button
            className="flex items-center gap-1 text-sm text-gray-500 hover:text-blue-600 transition-colors cursor-pointer"
        >
            <svg
                className="w-4 h-4"
                fill="none"
                stroke="currentColor"
                viewBox="0 0 24 24"
            >
                <path
                    strokeLinecap="round"
                    strokeLinejoin="round"
                    strokeWidth={2}
                    d="M4.318 6.318a4.5 4.5 0 000 6.364L12 20.364l7.682-7.682a4.5 4.5 0 00-6.364-6.364L12 7.636l-1.318-1.318a4.5 4.5 0 00-6.364 0z"
                />
            </svg>
            <span>{likeCount}</span>
        </button>
    );
};

The icon is from heroicons.

Now we can go to the page and see how it looks. And we can easily add another comment component in App.tsx, right below the first one, but with different data.

  <Comment
      avatarUrl="https://i.pravatar.cc/40?img=8"
      userName="Jhon"
      createdAt="50 minutes ago"
      content={"Text of the second comment"}
      likeCount={10}
  />

So, we've learned to use React to break HTML into reusable components. But using React only for this is like buying a high-end TV just for the weather forecast. In the next article, we'll uncover the true power of React.

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.