Poplavskij Vladimir blog

The Way of Kings: A Journey into the Stormlight Archive

Vladimir Poplavskij — Sat, 08 Aug 2026 17:14:30 GMT

Brandon Sanderson is a master of his craft, and The Way of Kings, the first volume in his renowned Stormlight Archive series, is a testament to his skill. This epic high-fantasy novel transports you to Roshar, a world of relentless storms, enigmatic magic, and deep political struggles.

The Way of Kings

Roshar is a place where hardened warriors clash in battles of honor and desperation, ancient secrets simmer beneath the surface, and the fate of a world hangs in the balance. The Way of Kings weaves together the stories of three compelling characters: Shallan, a young scholar seeking forbidden knowledge; Dalinar, a battle-worn general searching for meaning; and Kaladin, an enslaved soldier fighting for survival.

Kaladin

Kaladin is one of Sanderson’s most memorable creations. Haunted by his past, he fights to protect his men against impossible odds. His journey of strength, honor, and determination amid unimaginable hardship will resonate deeply with readers.

Dalinar Kholin

Dalinar Kholin, the stoic and honorable brother of the late king, embodies the clash between tradition and change. Deeply influenced by the ancient text The Way of Kings, he anchors his beliefs in a strict code of honor. Dalinar’s struggle lies in reconciling the ideals of the past with the shifting, complex realities of the present. One principle at the heart of the book resonates especially strongly with him:

There can be no honor in a victory that forces you to abandon who you are.

It guides his actions even as it becomes a constant source of inner conflict.

The oath of the Knights Radiant

Life before death. Strength before weakness. Journey before destination.

These words form the oath of the Knights Radiant, an ancient order, and capture the central themes of The Way of Kings.

If you love rich world-building, unforgettable characters, and high-stakes adventure, The Way of Kings is a must-read. Embark on this epic odyssey and discover why Sanderson is considered one of the finest fantasy authors of our time.

Conclusion

The Way of Kings deserves its acclaim. Its intricate world-building, fascinating cultures, and distinctive names draw you in. But it is the flawed, resilient, and undeniably human characters who make this book an unforgettable journey. If you want a novel that will challenge your mind, tug at your heartstrings, and leave you longing to return to Roshar, The Way of Kings should be at the top of your reading list.

Find my other book notes and reviews at reading.poplauki.eu.

Essential OWASP Security Tools: Pre-Launch Website Checklist

Vladimir Poplavskij — Sat, 18 Apr 2026 12:00:00 GMT

List of the OWASP links:

Scanners

DNS

dns recon & research, find & lookup dns records

Headers

HSTS Checker

HTTP Strict Transport Security Test

Stoic daily practice

Vladimir Poplavskij — Sun, 12 Apr 2026 16:00:00 GMT

Morning Disciplines: Claiming the Day

The Stoic day begins with an intentional effort to claim the day before “the rush storms in” and obligations collide

The Morning Reminder: Practitioners are encouraged to remind themselves that they will encounter difficult people—“the busybody, the ungrateful, [and] arrogant”—and that their well-being should not be held hostage by anyone else’s character.
Setting Intentions: Morning rituals involve focusing on what is important and committing to live by values rather than moods, such as acting with self-discipline and honesty even when it is inconvenient.
Preparation: This is a time for readiness, where the student prepares their mind to respond with virtue to whatever the day holds

Throughout the Day: The Practice of Attention

Stoicism in daily life requires a constant “discipline of judgment” to ensure internal reactions are governed by reason

The Dichotomy of Control: At the heart of daily life is the simple, repetitive question: “Is this within my control?”. If an event—like traffic, the weather, or another’s behavior—is not under one’s control, the practitioner chooses to let it go and focuses solely on their own responses and actions.
The Stoic Pause: To avoid being “dazed by the rapidity of the impact” of external events, Stoics practice a deliberate pause. This brief interruption of an automatic reaction allows space to ask what is actually happening and prevents the mind from constructing a “story of harm” around neutral events.
The Watchtower Perspective: To counter the tendency to look at problems too closely, Stoics mentally “zoom out.” By viewing events as if from a high watchtower, individual problems shrink in significance and are seen as part of a shared, ordinary, and fleeting human condition.
Voluntary Discomfort: Practitioners may periodically choose to go without luxuries, wearing simple clothes or eating cheap fare, to remind themselves that happiness does not depend on possessions and to “stiffen the spine” for future hardships

Evening Reflection: Reviewing the Character

The day concludes with a period of reflection to assess one’s progress and character

The Review: Stoics look back at the day’s events to ask: “Did I remain patient? Did I show courage? Where did emotion take over?”.
Correction without Despair: If a practice falls short of principles, the goal is not to despair but to simply return to the practice after the failure.
Specific Exercises: One recommended exercise is to choose a single moment that was disturbing and write four short lines: what happened plainly, what was concluded about it, the “watchtower” or future view of the event, and what part was actually yours to manage

Ultimately, Stoic daily practice is about mastery of the self rather than the world, seeking to become a “limb of a larger body” that acts rationally and socially in the present moment

📡 Receiving Weather Forecasts from 433 MHz Sensors on Raspberry Pi with RTL-SDR

Vladimir Poplavskij — Thu, 09 Apr 2026 10:00:00 GMT

From Raw Radio Signals to Elegant Grafana Dashboards

At some point, checking the weather in an app stopped being enough. I wanted to know the temperature on the balcony—not from some cloud-based API, but from my own sensors, working in real time. That’s how the idea for a fully private weather monitoring system was born.

📡 1. Capturing Signals from the Air

The foundation of this project is the RTL-SDR dongle—a small radio receiver capable of intercepting transmissions from cheap 433 MHz sensors. With the help of rtl_433, I transformed raw radio signals into readable JSON data. This is the moment when “radio magic” becomes actionable data.

🔧 2. Smart Filter: Only My Sensors, Only What Matters

I didn’t want noise in the system. That’s why I created bridge.js—a small, clever Node.js script that:

Recognizes only my sensors (by model and ID),
Maps them to friendly names: kitchen, balcony, garden,
Converts temperature from °F to °C,
Publishes clean, standardized data to MQTT (weather/<name>),
Records the timestamp of the last signal,
Sends notifications when a sensor’s battery starts dying.

This isn’t just a filter—it’s my private “weather intelligence layer.”

🧠 3. A Backend That Understands Data

Next, the data flows into a NestJS-based backend. I built a custom MQTT client that:

Subscribes to weather/#,
Receives ready-to-use JSON data from bridge.js,
Updates a cache of recent readings,
Aggregates data and stores it in PostgreSQL.

The backend doesn’t need to know about radio protocols or sensor models. It receives clean, standardized data—and does what it does best.

🗄️ 4. Weather History in PostgreSQL

Each sensor generates multiple readings per minute. Instead of storing everything, the backend:

Buffers the data,
Calculates averages,
Saves elegant records to the weather_record table.

This keeps the database lightweight, fast, and ready for analysis.

📊 5. Real-Time Weather in My Home

Finally, everything lands in Grafana, where I created a set of dashboards:

Temperature charts segmented by sensor,
Humidity over time,
A diagnostic panel (battery status, last signal),
A quick view of recent values.

This isn’t just a chart—it’s my private “weather center,” running 24/7.

🎯 Final Result

I built a system that:

Receives radio signals from 433 MHz sensors,
Filters and normalizes the data,
Publishes it to MQTT,
Aggregates and stores it in the backend,
Displays it beautifully in Grafana.

Zero cloud. Zero vendor lock-in. Everything runs locally, quickly, and exactly how I want.

Stoic Guide to Inner Peace

Vladimir Poplavskij — Sun, 29 Mar 2026 20:00:00 GMT

The sources present fifteen ways to achieve tranquility (based on Seneca’s suggestions) and also discuss the technical structure of subordinate virtues that fall under the four cardinal virtues of Stoicism. While the specific count of “15 subordinate virtues” is not explicitly defined as a single canonical list in the sources, they provide a detailed list of fifteen practical suggestions for living virtuously and identify various subordinate virtues within the broader Stoic framework

The 15 Suggestions for Tranquility

These fifteen points are drawn from Seneca’s essay On Tranquillity of Mind and represent practical applications of Stoic virtue:

Get involved in the world: Actively engaging in daily activities and worthwhile work steadies the mind and counters restlessness.
Don’t let obstacles stop you: Practice perseverance and find alternative paths when blocked; even small services contribute to a quiet dignity.
Decide to be alive until you die: Commit to staying fully present and content regardless of whether your circumstances are harsh or pleasant.
Match your actions with your ability: Choose tasks you can carry well and avoid commitments that overwhelm your nature or abilities.
Be careful in choosing friends: Prioritize genuine companions and avoid “miserable people” who find something to complain about in everything.
Don’t go after possessions: Avoid the consuming pursuit of wealth and aim instead for sufficiency.
Live simply: Avoid display and extravagance; a simple life is easier to maintain and steadies the mind.
Handle life with skill: Use practice and skill to turn hardships into bearable circumstances rather than crushing weights.
Be willing to let go: Recognize that every human condition is temporary and avoid clinging too tightly to status, possessions, or life itself.
Avoid useless activities: Choose meaningful purposes and avoid aimless busyness that breeds distraction.
Be prepared for disappointment: Expect that things will not always go as hoped to strip disappointment of its power.
Be neither stubborn nor indecisive: Maintain the flexibility to adapt to changing circumstances or to withdraw when reason advises.
Don’t be guided by other people’s opinions: Ignore human folly and follow what reason demands.
Learn from other people’s courage: Observe how others face misfortune and strengthen your own heart through their example.
Be yourself, relax, have fun: Give the mind rest through walks, enjoyment, and meals in moderation

The Technical Structure of Subordinate Virtues

The sources explain that the four cardinal virtues—Wisdom (Prudence), Justice, Courage, and Temperance—each encompass several subordinate virtues. According to Arius Didymus, Prudence includes six subordinate virtues, Courage includes five, and Justice and Temperance each have four, totaling 19. Specific examples named in the sources include:

Subordinate Virtues of Justice: These include kindness (knowledge of how to do good), fair dealing, good fellowship, and piety. Other aspects include honesty, truthfulness, and faithfulness.
Subordinate Virtues of Temperance: This category includes self-control (enkrateia), orderliness (eutaxia), propriety, and modesty.
Subordinate Virtues of Courage: This includes magnanimity (greatness of mind or soul), perseverance (philoponia or “love of toil”), and patience (patientia).
Subordinate Virtues of Prudence (Wisdom): While the sources do not list all six, they define wisdom as the “master virtue” or “clear-sighted intelligence” that directs the others

Symmetric Key Encryption for Health Data: MigrainePulse Security Architecture

Vladimir Poplavskij — Sun, 22 Mar 2026 00:00:00 GMT

When building HealthTech products like MigrainePulse, one of the biggest challenges is ensuring absolute security and privacy of sensitive user data. Migraine attack history, medications taken, health records, and lifestyle details – all of this is highly personal information.

From day one, our philosophy was simple: user data belongs only to them. To ensure this, we implemented an advanced symmetric key encryption system ( angl. Symmetric Key Encryption) in the MigrainePulse architecture, which works together with isolated microservice solutions (Cloudflare Workers).

In this article, we invite you to take a technical look under the hood and learn how our protection mechanisms work.

Why Standard Solutions Are Not Enough?

Most applications today use encryption during data transmission (TLS/SSL) and encryption at rest (encrypted databases). However, if the entire system (database and main server holding encryption keys) is compromised at the same time, the data can become exposed.

To avoid this, we separated the actual data from the keys needed to decrypt it in the MigrainePulse system.

Architecture Foundation: SymmetricKeyService

In our backend system (using a NestJS monolith), a special SymmetricKeyService module manages encryption and decryption of sensitive data.

How does it work in practice?

Single Key Principle: Symmetric encryption means the same unique key is used to both encrypt and decrypt data. Each user has a unique key assigned to them, which even we do not have in our main database.
Payload Encryption: When a user saves a new health record (e.g., adds a new migraine attack), the data reaches our server. SymmetricKeyService takes this sensitive payload, encrypts it using an advanced algorithm (e.g., AES-256-GCM), and only then saves it to the database. Only a meaningless string of characters is stored in the database.
User Identification: User session and data access are tightly tied to JWT (JSON Web Tokens) and Supabase authentication. The user verifies their identity, and the encryption key belonging to them is only provided upon verified login.

Additional Defense Layer: Cloudflare Worker

A natural question arises – where are the encryption keys stored if not in the main database?

Here we called upon Cloudflare Workers technology.

In our architecture, encryption keys are managed through a completely isolated, Edge network infrastructure. The solution described in doc/backend/cloudflare-worker.md ensures that the main API server and database never store the keys themselves in long-term memory.

Integration Benefits:

Decentralization: Since keys are stored and managed in a separate cloud infrastructure (Cloudflare), a potential hacker would not suffice to compromise our main server. They would need to simultaneously overcome two completely different, mutually isolated systems.
Speed (Low Latency): Cloudflare Workers operate on a global Edge network (closest to the user), so requesting a key from them (for authorized decryption) adds only minimal delay while maintaining application performance.
Strict Access Control: The Worker is configured so that it only hands over keys upon receiving correctly signed and verified requests from our SymmetricKeyService, checking all CORS and IP restrictions.

Summary

MigrainePulse is not just a tool for tracking data. It is a secure space. By combining robust NestJS architecture (symmetric-key.service.ts) with the decentralization provided by Cloudflare Workers, we created a system where the user’s personal information remains locked even in the worst-case scenarios.

For us, “Security First” is not just a marketing slogan – it is the engineering foundation on which the entire MigrainePulse system is built. Because when we talk about health, there is no room for privacy compromises.

Do you have questions about our technical architecture? Join the discussion in the comments or try MigrainePulse yourself!

Migraine Pulse – moving data schema to backend

Vladimir Poplavskij — Sun, 15 Mar 2026 00:00:00 GMT

Summary: This article describes moving the data schema from frontend to backend in the Migraine Pulse app. You’ll learn how we implemented a dynamic schema using NestJS, JSON schema validation, and how it simplified the data export/import process.

As I mentioned in the introductory post about the app - the first version was a prototype. A React application where I imported JSON format stored locally. It would populate the app with my migraine incidents, symptoms, etc. I would refine certain things, modify (add data). At the end, I would do an export to have the latest changes.

At the same time, I would check and refine the required fields for each element.

Later I started building a backend which already had a connection to the database. But when creating NestJS modules, I took into account the schema I worked out above.

However, until now the schema format itself was described statically on the settings/DataManagement page.

I decided to make it dynamic, i.e., when fields change or are added, so you don’t have to manually edit the page every time.

Implementation

The first step is simple - create a new NestJS data-management module with service and controller.

nest g module data-management 
nest g service data-management
nest g controller data-management

The service returns a JSON schema object.

import { Injectable } from '@nestjs/common';
import Ajv from 'ajv';
import addFormats from 'ajv-formats';
import {
  dtoToJsonSchema,
  ClassType,
  JsonSchema,
} from './utils/dto-to-json-schema';
import { CreateIncidentDto } from '../incidents/dto/create-incident.dto';
import { CreateTriggerDto } from '../triggers/dto/create-trigger.dto';
import { CreateSymptomDto } from '../symptoms/dto/create-symptom.dto';
import { CreateMedicationDto } from '../medications/dto/create-medication.dto';
import { CreateLocationDto } from '../locations/dto/create-locations.dto';
import {
  CreateWaterDto,
  CreateBloodPressureDto,
  CreateHeightDto,
  CreateSleepDto,
  CreateWeightDto,
} from '../health-logs/dto/create-health-logs.dto';
import { DataValidationResponse } from './interface/validation.interface';

@Injectable()
export class DataManagementService {
  private ajv: Ajv;

  constructor() {
    this.ajv = new Ajv({ allErrors: true });
    addFormats(this.ajv); 
  }

  getSchema() {
    const incidentObjectSchema = dtoToJsonSchema(
      CreateIncidentDto as ClassType<unknown>,
    );

    incidentObjectSchema.properties = incidentObjectSchema.properties ?? {};
    incidentObjectSchema.properties.id = { type: 'string' } as JsonSchema;
    incidentObjectSchema.properties.createdAt = {
      type: 'string',
      format: 'date-time',
    } as JsonSchema;

    let existingRequired = Array.isArray(incidentObjectSchema.required)
      ? incidentObjectSchema.required
      : [];
    let requiredSet = new Set<string>(existingRequired);
    ['userId', 'type', 'startTime', 'datetimeAt'].forEach((r) =>
      requiredSet.add(r),
    );
    incidentObjectSchema.required = Array.from(requiredSet);

    const incidentsSchema: JsonSchema = {
      type: 'array',
      items: incidentObjectSchema,
    };

    const rootSchema: JsonSchema = {
      type: 'object',
      properties: {
        incidents: incidentsSchema,
        triggers: triggersSchema,
        symptoms: symptomsSchema,
        medications: medicationsSchema,
        locations: locationsSchema,
        healthLogs: healthLogsSchema,
        exportedAt: { type: 'string', format: 'date-time' },
        version: { type: 'string' },
      },
      required: [
        'incidents',
        'triggers',
        'symptoms',
        'medications',
        'locations',
        'healthLogs',
        'exportedAt',
        'version',
      ],
      additionalProperties: false,
    };

    return rootSchema;
  }
}

In the controller, return the JSON schema object from the service. It’s accessible with USER role, since that page is only accessible to logged-in users.

import { Controller, Get } from '@nestjs/common';
import { DataManagementService } from './data-management.service';
import { Roles } from '../auth/decorators/roles.decorator';
import { Role } from '../auth/enums/roles.enum';

@Controller('data-management')
export class DataManagementController {
  constructor(private readonly dataManagementService: DataManagementService) {}

  @Roles(Role.USER)
  @Get('schema')
  getSchema(): object {
    return this.dataManagementService.getSchema();
  }
}

Integrate the newly created into the settings/DataManagement page.

export const getDataSchema = async (token: string) => {
  const response = await fetch(`${env.MIGRAINE_BACKEND_API_URL}/api/v1/data-management/schema`, {
    headers: getHeaders(token),
  });

  if (!response.ok) {
    throw new Error('Failed to fetch data schema');
  }

  return response.json();
};

And the first step provides the ability to modify not HTML, but JSON schema, to describe it and split into parts. Add versioning. Validate files before importing to not break the data structure.

Schema validation service and controller

Add new npm packages for validation using json schemas.

pnpm add ajv ajv-formats

import { Injectable } from '@nestjs/common';
import Ajv from 'ajv';
import addFormats from 'ajv-formats';
import {
  dtoToJsonSchema,
  ClassType,
  JsonSchema,
} from './utils/dto-to-json-schema';
import { CreateIncidentDto } from '../incidents/dto/create-incident.dto';
import { CreateTriggerDto } from '../triggers/dto/create-trigger.dto';
import { CreateSymptomDto } from '../symptoms/dto/create-symptom.dto';
import { CreateMedicationDto } from '../medications/dto/create-medication.dto';
import { CreateLocationDto } from '../locations/dto/create-locations.dto';
import {
  CreateWaterDto,
  CreateBloodPressureDto,
  CreateHeightDto,
  CreateSleepDto,
  CreateWeightDto,
} from '../health-logs/dto/create-health-logs.dto';
import { DataValidationResponse } from './interface/validation.interface';

@Injectable()
export class DataManagementService {
  private ajv: Ajv;

  constructor() {
    this.ajv = new Ajv({ allErrors: true });
    addFormats(this.ajv); 
  }

  getSchema() {
    // Above content
  }

  validateImportData(data: unknown): DataValidationResponse {
    const schema: JsonSchema = this.getSchema();
    const validate = this.ajv.compile(schema);
    const isValid = validate(data);

    if (!isValid) {
      return { isValid: false, errors: validate.errors };
    }
    return { isValid: true };
  }
}

Helper function mapValidatorToSchema to convert DTO to JSON schema.

import 'reflect-metadata';
import { getMetadataStorage } from 'class-validator';

export interface ClassType<T = unknown> {
  new (...args: unknown[]): T;
}

type PrimitiveTypeName = 'string' | 'number' | 'integer' | 'boolean' | 'null';

export interface PrimitiveSchema {
  type: PrimitiveTypeName;
  format?: string;
  enum?: (string | number | boolean | null)[];
}

export interface ArraySchema {
  type: 'array';
  items: JsonSchema;
}

export interface ObjectSchema {
  type: 'object';
  properties?: Record<string, JsonSchema>;
  required?: string[];
  additionalProperties?: boolean;
}

export type JsonSchema = PrimitiveSchema | ArraySchema | ObjectSchema;

interface ValidationMetadataLite {
  propertyName: string;
  type: string;
  constraints?: unknown[];
  each?: boolean;
}

interface MetadataStorageLite {
  getTargetValidationMetadatas(
    targetConstructor: Function,
    targetSchema?: string,
  ): ValidationMetadataLite[];
}

function asMetadataStorage(obj: unknown): MetadataStorageLite | null {
  if (obj && typeof obj === 'object' && 'getTargetValidationMetadatas' in obj) {
    const cast = obj as any;
    if (typeof cast.getTargetValidationMetadatas === 'function') {
      return cast as MetadataStorageLite;
    }
  }
  return null;
}

function mapValidatorToSchema(
  meta: ValidationMetadataLite | undefined,
  designType?: Function,
): JsonSchema {
  if (!meta) {
    if (designType === String) return { type: 'string' };
    if (designType === Number) return { type: 'number' };
    if (designType === Boolean) return { type: 'boolean' };
    if (designType === Array)
      return { type: 'array', items: { type: 'string' } };
    return { type: 'object', additionalProperties: true };
  }

  switch (meta.type) {
    case 'isString':
      return { type: 'string' };
    case 'isNumber':
      return { type: 'number' };
    case 'isInt':
      return { type: 'integer' };
    case 'isBoolean':
      return { type: 'boolean' };
    case 'isDateString':
      return { type: 'string', format: 'date-time' };
    case 'isUUID':
      return { type: 'string', format: 'uuid' };
    case 'isEmail':
      return { type: 'string', format: 'email' };
    case 'isArray':
      return { type: 'array', items: { type: 'string' } };
    case 'isEnum': {
      const maybeEnum = Array.isArray(meta.constraints?.[0])
        ? (meta.constraints[0] as (string | number | boolean)[])
        : undefined;
      const schema: PrimitiveSchema = { type: 'string' };
      if (maybeEnum) schema.enum = maybeEnum;
      return schema;
    }
    default:
      if (designType === String) return { type: 'string' };
      if (designType === Number) return { type: 'number' };
      if (designType === Boolean) return { type: 'boolean' };
      if (designType === Array)
        return { type: 'array', items: { type: 'string' } };
      return { type: 'object', additionalProperties: true };
  }
}

export function dtoToJsonSchema<T = unknown>(
  dtoClass: ClassType<T>,
): ObjectSchema {
  const rawStorage = getMetadataStorage();
  const storage = asMetadataStorage(rawStorage);
  const metadatas: ValidationMetadataLite[] = storage
    ? storage.getTargetValidationMetadatas(dtoClass as unknown as Function, '')
    : [];

  const byProp = new Map<string, ValidationMetadataLite[]>();
  for (const m of metadatas) {
    const prop = m.propertyName;
    const arr = byProp.get(prop) ?? [];
    arr.push(m);
    byProp.set(prop, arr);
  }

  const properties: Record<string, JsonSchema> = {};
  const required: string[] = [];

  for (const [prop, metas] of byProp.entries()) {
    const designType = Reflect.getMetadata(
      'design:type',
      dtoClass.prototype,
      prop,
    ) as Function | undefined;

    const isArray = metas.some((m) => m.type === 'isArray');
    if (isArray) {
      const eachMeta = metas.find(
        (m) => m.each === true && m.type !== 'isArray',
      );
      const itemsSchema = mapValidatorToSchema(eachMeta, undefined);
      properties[prop] = { type: 'array', items: itemsSchema };
    } else {
      const preferredOrder = [
        'isDateString',
        'isEnum',
        'isNumber',
        'isInt',
        'isBoolean',
        'isUUID',
        'isEmail',
        'isString',
        'isObject',
      ];
      let chosen: ValidationMetadataLite | undefined;
      for (const t of preferredOrder) {
        chosen = metas.find((m) => m.type === t);
        if (chosen) break;
      }
      if (!chosen) chosen = metas[0];

      const propSchema = mapValidatorToSchema(chosen, designType);

      const hasNested = metas.some((m) => m.type === 'nestedValidation');
      if (
        hasNested &&
        designType &&
        designType !== Object &&
        designType !== Array
      ) {
        properties[prop] = dtoToJsonSchema(designType as ClassType<unknown>);
      } else {
        properties[prop] = propSchema;
      }
    }

    const isOptional = metas.some((m) => m.type === 'isOptional');
    const hasNotEmpty = metas.some((m) => m.type === 'isNotEmpty');
    if (!isOptional && hasNotEmpty) required.push(prop);
  }

  const schema: ObjectSchema = {
    type: 'object',
    properties,
    additionalProperties: false,
  };
  if (required.length) schema.required = required;
  return schema;
}

Controller endpoint for file validation.

import { 
  Controller, 
  Get, 
  Post, 
  UploadedFile, 
  UseInterceptors, 
  BadRequestException 
} from '@nestjs/common';
import { FileInterceptor } from '@nestjs/platform-express';
import { DataManagementService } from './data-management.service';
import { Public } from '../auth/decorators/public.decorator';

@Controller('data-management')
export class DataManagementController {
  constructor(private readonly dataManagementService: DataManagementService) {}

  @Roles(Role.USER)
  @Get('schema')
  getSchema() {
    return this.dataManagementService.getSchema();
  }

  @Roles(Role.USER)
  @Post('validate-upload')
  @UseInterceptors(FileInterceptor('file'))
  validateFile(
    @UploadedFile() file: Express.Multer.File,
  ): DataValidationResponse {
    if (!file) {
      throw new BadRequestException('No file uploaded.');
    }

    if (file.mimetype !== 'application/json') {
      throw new BadRequestException('Uploaded file must be a JSON file.');
    }

    try {
      const fileContent: string = file.buffer.toString('utf-8');

      const jsonData: unknown = JSON.parse(fileContent);

      const validationResult: unknown =
        this.dataManagementService.validateImportData(jsonData);

      if (validationResult instanceof Error) {
        throw new BadRequestException(validationResult.message);
      }

      return validationResult as DataValidationResponse;
    } catch (error) {
      ErrorExceptionLogging(error, DataManagementController.name);
      throw error;
    }
  }
}

Frontend usage example:

const checkUploadedFile = async (file: File) => {
  const formData = new FormData();
  formData.append('file', file);

  const response = await fetch(`${API_URL}/api/v1/data-management/validate-upload`, {
    method: 'POST',
    body: formData,
  });

  const result = await response.json();

  if (result.isValid) {
    console.log("File is perfect! Proceed with import.");
  } else {
    console.error("Validation failed:", result.errors);
  }
};

Here full code changes - backend and frontend

The Depth Paradox: Why Intellectual Isolation is the New Currency of Success

Vladimir Poplavskij — Sat, 14 Mar 2026 00:00:00 GMT

This article emerged from studying Cal Newport’s groundbreaking book “Deep Work: Rules for Focused Success in a Distracted World.” Newport, a computer science professor at Georgetown University, argues that the ability to focus without distraction on cognitively demanding tasks is becoming increasingly rare—and increasingly valuable—in our knowledge economy. This exploration distills the core insights from his research, framed through the lens of practical application for modern professionals.

The Depth Paradox: Why Intellectual Isolation is the New Currency of Success

The Distraction Epidemic: Drowning in Functional Insignificance In the contemporary landscape of knowledge work, a quiet crisis is unfolding. Most professionals are drowning in a sea of functional insignificance—trapped in a state of perpetual motion that yields nothing of lasting value. We have mastered the art of “being busy” while our capacity for meaningful output withers. This friction arises from a fundamental failure to distinguish between two types of effort: Deep Work and Shallow Work. Deep Work refers to professional activities performed in a state of distraction-free concentration that push your cognitive capabilities to their absolute limit. These efforts create new value, improve your skill, and are notoriously difficult to replicate. Shallow Work, conversely, involves non-cognitively demanding, logistical tasks often performed while distracted. In the new economy, the capacity for depth is becoming increasingly rare at the exact moment its market value is skyrocketing. It is no longer a mere habit; it is a superpower.
The Deep Work Advantage: Mastery in the New Economy To survive the shift toward an automated and hyper-competitive economy, one must master two essential skills: the ability to learn complex things quickly and the ability to perform at an elite level with both quality and speed. Neither of these can be achieved through the fragmented attention of shallow effort. As a researcher of cognitive performance, I argue that depth is the fundamental mechanism of value creation. To achieve this, one must choose a structure for their concentration. The Monastic method involves radical isolation to focus on a single high-level goal. The Bimodal method allows for a clear division of time between deep stretches and periods for everything else. Finally, the Journalistic method involves shifting into a deep work state instantly whenever a pocket of time opens up. Regardless of the method, the goal is the same: “Deep work is focusing on professional activities without distraction so that cognitive abilities to unfold as much as they can. Only through such efforts are new values created and skills developed.”
The Busy Trap: The Path of Least Resistance Why do we struggle to choose depth? The answer lies in the Principle of Least Resistance. In the absence of clear feedback on how specific behaviors impact the bottom line, we instinctively choose whatever is easiest in the moment. We aren’t necessarily lazy; we are cognitively unanchored. Because modern knowledge work lacks the visible output of a factory line, workers revert to industrial-age metrics: doing as much as possible as visibly as possible. This “visible busyness” serves as a psychological mask. We mistake the volume of sent emails for the value of our output, choosing the shallow path of least resistance over the rigorous, often lonely path of cognitive depth.
The Productive Power of Idleness: An Entrepreneurial Strategy High-intensity focus requires a commitment to what many would call “idleness.” However, the high-performer views rest not as a luxury, but as a prerequisite. To achieve peak results, one must adopt an entrepreneurial mindset— seek results like a businessman —which recognizes that downtime is fuel for insight. Neurologically, the mind does not necessarily need total cessation of activity; it needs a change of pace to restore the energy required for Deep work. To integrate rest into a high-performance system, follow these four principles:

Focus on significant goals: Direct your energy toward a small number of crucial targets.
Lead indicators: Measure behaviors that drive success (e.g., hours spent in deep work).
Scoreboard: Maintain a visible record of wins to maintain motivation.
Cadence of accountability: Establish a regular rhythm for reviewing performance.

The Craftsman’s Approach to Technology Most individuals select their digital tools based on the Any-Benefit Principle: if a tool offers any marginal advantage, they feel justified in using it. This is a trap that leads to cognitive fragmentation. Craftsman’s Principle offers a more rigorous alternative:

“Use a tool only if its positive impact on core goals significantly outweighs the negatives.”

Consider the author Michael Lewis. His core professional goal is to write stories that change worldviews. To achieve this, his essential steps are patient, deep research and thoughtful writing. When viewed through this lens, a tool like Twitter (X) offers a marginal benefit (staying “informed”) that is dwarfed by the negative impact on his capacity for deep research. To break your tool dependency, try a 30-day “digital fast.” Afterward, ask: Would those thirty days have been significantly better if I had been using this service? Did anyone care that I was gone? If the answer is “no,” the tool is a hindrance to your depth.

High-Quality Leisure: The Mind Needs Change, Not Rest Many professionals lose their focus to “vampire websites” during their off-hours because they fail to plan their leisure. As Arnold Bennett observed, the mind is not like a limb that needs to cease movement to recover: “The mind can work without ceasing and hard; it does not tire like a hand or a foot… Everything it needs is change, not rest (excluding sleep).” An unplanned evening creates a vacuum easily filled by shallow distractions. By structuring your free time with intentional, demanding activities—reading, complex hobbies, or deep social connection—you protect your cognitive capacity. Intentional leisure ensures that when the workday begins, your mind is refreshed and ready for high-intensity concentration.
The Radical Art of Ignoring Email Communication is often the greatest enemy of cognitive integrity. To maintain your depth, you must adopt the “Professor’s Principle” of radical selectivity. Choose to ignore any message that meets these criteria:

It is vaguely formulated or difficult to answer directly. The proposal is uninteresting or irrelevant to your core goals. No positive result will come from responding, and nothing bad happens if you don’t.

Furthermore, utilize targeted email management. Instead of a back-and-forth volley, provide a “process-centric” reply that closes the loop. Consider the common “coffee meeting” request. Instead of saying “Sure, when?” which triggers a 10-email thread, reply: “I can meet on Tuesday at 10:00 AM at the cafe on 5th Street. If that works, I’ll see you there; if not, please suggest two other times that work for you.” This makes the sender work harder and frees your mind from the “open loops” that drain attention.

Conclusion: The Courage to Be Less Busy Success in the modern era is not awarded to those who can work the longest hours or respond to the most notifications. It is reserved for those who have the courage to protect their cognitive depth. By ruthlessly rejecting the shallow, you do not just save time—you gain the energy required to create something meaningful. Reducing superficial work is not about doing less; it is about becoming the type of professional who can produce results that are impossible in a state of constant distraction. As you look at your calendar, ask yourself: which shallow habits are you willing to sacrifice to reclaim your superpower?

Migraine Pulse – my journey creating a personal migraine tracking app

Vladimir Poplavskij — Wed, 11 Mar 2026 22:00:00 GMT

Part One. How It All Started

Sometimes I suffer from migraine attacks – sometimes severe. I’d heard that keeping an attack diary was worthwhile. In 2024, after one particularly severe attack, I started writing text descriptions with dates and symptoms. In parallel, I began testing various apps where I tried to record the same events.

Why Existing Apps Didn’t Suit Me

First, what I didn’t like about existing apps – their handling of personal data was insufficiently transparent. And security was also questionable.

Second, they lacked import and export capabilities for my own data. Few formats and no standards.

Third, there was no flexibility to add my own attack logic. Or another resource with data I specifically needed, like magnetic storm forecasts or their history.

That’s when I decided to create my own migraine diary to track symptoms. And not just that.

What I Learned Building This Project

Building this project, like building anything, I learned new technologies and tools. I tried services I hadn’t used before in work or in other personal projects.

One of the first things I used was creating a frontend prototype. It remained almost unchanged.

The second thing I used for brainstorming, prototype generation, and rewriting monotonous code was AI. Here I tried ChatGPT, Khoj (Gemini, Claude Sonnet), and Google Antigravity services.

I made the service code – backend and frontend – publicly available, because I believe everyone should have the opportunity to take it and modify it for themselves. Either to help me improve. Or to suggest and add new functionality.

What’s Coming in the Future?

I’ll add more various reports and a module that will analyze only your data and, based on them, warn about increased probability of migraine or headache.
Translation into other languages – first would be Ukrainian, Lithuanian, and Polish.
Gender selection and adding women’s cycles.

A demo environment where you can try it out without entering much information – you can find it by following this link.

The documentation page is here.

The official product of the program, which will have my personal functionality and more integrations – you can find it here.

Conclusion

In future blog posts, I’ll tell you more details about each feature. Also about interesting discoveries I made building this product.

Good luck and health!

How to Find Tranquility in a Turbulent World Seneca\’s Stoic Strategies

Vladimir Poplavskij — Sat, 28 Feb 2026 16:00:00 GMT

We live in a world that feels like it’s constantly shouting. Between the polarized political landscape, the relentless ping of social media notifications, and the rising temperature of public discourse, “inner peace” can feel like a luxury reserved for monks on a mountaintop.

But according to the Roman philosopher Seneca, tranquility isn’t about the world falling silent; it’s about finding a “smooth flow” within yourself while the storm rages outside. Based on his timeless essay On Tranquillity of Mind, here is how we can reclaim our headspace in 2026.

The Trap of Idleness vs. Purposeful Action

Many people believe that peace is found in doing nothing. Seneca argues the opposite: Boredom is the enemy. When we retreat into idleness, our minds begin to eat themselves.

Stay in the Game: If your main path is blocked—be it a career setback or a personal disappointment—don’t just quit. Find a different way to contribute. As Seneca says, “The services of a good citizen are never useless.”
Activity with Intent: Avoid “aimless busyness.” Running in circles isn’t progress. Choose a meaningful goal and keep your eyes on it.

Know Your Heavy Lifting

A major source of our modern burnout is overcommitment. We try to carry the weight of the world, our careers, and our social feeds all at once.

Check Your Load: Before taking on a new project or emotional burden, ask: Am I stronger than this load? If the weight exceeds your capacity, you won’t find peace; you’ll find resentment.
The “Sufficiency” Sweet Spot: We are obsessed with more. More followers, more money, more gear. Stoicism teaches us to aim for enough. Simplicity isn’t about deprivation; it’s about the freedom that comes from not needing to guard a mountain of “stuff.”

Curate Your Circle (And Your Feed)

Negativity is contagious. Seneca warns that “mixing what is healthy with what is sick” breeds disease—and that applies to your social circle.

Selective Friendship: You don’t need perfect friends, but you should avoid those who “delight in misery.” If your inner circle (or your digital feed) is a constant source of gloom, your tranquility doesn’t stand a chance.
Ignore the Gallery: Public opinion is a fickle beast. If you live your life based on what “they” think, you are a slave. Do what reason dictates, and let the critics shout into the void.

Building Your Psychological Armor

Tranquility isn’t a stroke of luck; it’s a practiced skill. We can build resilience by changing how we perceive “bad” luck.

Strategy	Stoic Principle	Modern Application
Anticipation	Premeditatio Malorum	Expect things to go wrong. If you aren't surprised by a setback, it loses its power to hurt you.
Flexibility	Adaptability	Don't be rigid. If your plans change, change with them. A tree that bends in the wind doesn't snap.
Letting Go	Temporality	Remember: every human condition is temporary. This "disaster" will eventually be a footnote.

The Art of the Reset

Finally, Seneca reminds us that we aren’t machines. Authenticity is exhausting if you’re always performing.

Be yourself. Trying to maintain a “perfect” persona is a fast track to mental exhaustion. Take time to walk outside, enjoy a meal without your phone, and let your mind rest. Rest isn’t an indulgence—it’s the fuel that allows you to return to the world with a “heart of courage.” The Takeaway

Your internal state is the only thing you truly own. The world might be turbulent, but your mind doesn’t have to be. By matching your actions to your abilities and keeping a flexible spirit, you can achieve that “smooth flow” Seneca promised.

40 Provocative Questions for Deep Self-Reflection

Vladimir Poplavskij — Wed, 28 Jan 2026 23:29:37 GMT

Provocative Questions for Yourself

Many of us need a good shake-up from time to time to tear ourselves away from a semi-automatic, routine state. The list of provocative questions below is sobering and allows you to look at your life from different angles, become a little more mindful, understand what is important, where opportunities are hidden, and much more. There are no single “correct” answers to them, and not all can be answered immediately. But the very search for answers will help you know yourself and your needs, reflecting on what often remains out of sight.

What will people say at your funeral? And who will be attending?
Which of your habits stand between you and happiness?
You are standing at the gates of heaven, and they ask you: “Why should we let you in?” How would you answer?
If you lost everything today, how would you act? To whom would you turn for help? How would your actions and habits change?
Are there people who mean a great deal to you? When was the last time you told them?
What would you change in your life if you knew you would never get sick and never die?
You have a million dollars, but today is the last day of your life. What do you do?
How would you describe yourself in five words?
What are the chances that you have already missed something important that you will regret for the rest of your life?
What conclusions could be drawn from this?
If you could be guaranteed to possess three skills right now, what would they be? Most importantly — why?
If you could be guaranteed to get rid of three habits, which ones? How do they hinder you today and why haven’t you gotten rid of them yet?
If you could relive three moments from the past, which ones? What is special about them?
If you knew how to find an approach to and influence every person in the world, what would your path to success look like? What would you achieve and how?
What is the first thought that comes to mind when you encounter a very difficult problem or failure?
Do you believe that your anger, irritation, and rage are solely your fault?
How many hobbies did you have five years ago and how many do you have now? If there is a difference, what is the reason?
What are the three main events of your life? You made three key decisions and now live completely differently than you could have. Why did you do it and are you happy with the choice?
What were you doing the last time you were so engaged that you lost track of time?
Do you try to look for answers to life’s questions as they arise, or do you just let them go?
Why are you motivated in the morning but lose motivation by evening? Conversely, what exactly were you doing when you wanted nothing in the morning but were full of enthusiasm by evening?
If karma visited you, would it help or punish you? For what specifically and in what ways?
What do you owe yourself?
What do you owe your family and friends?
When you think about the future—does it frighten or inspire you?
Do you believe you should help yourself first or a person in need? In which specific cases?
What makes you special?
How many people do you truly love? What do you do for them and how often?
Describe the best adventure of your life.
Where would you like to live? Why haven’t you moved there yet?
Do you believe more in logic or creative thinking?
Whom do you admire and why?
If you found out when and how you would die, how would your life change now?
What is honor? Does it matter to you?
Which is better: living ten years with excellent health or thirty years with mediocre health?
If you didn’t waste any time from this moment forward, what would you achieve?
Which areas of your life do you control?
Are you more often inside your comfort zone or outside of it?
Do you consider yourself a hero or a villain?
Which scientists do you consider villains and why?

The philosopher Voltaire urged us to judge a person by the questions they ask. This is good and sound advice because through questions one can learn much: from the ability to get to the heart of things to personal priorities. Learn to ask the right questions, including to yourself—it is also a kind of art. Constantly ask yourself why something happened and how to solve a particular problem.

Modernizing Your TypeScript Project: Migrating from TSLint to ESLint (Flat Config)

Vladimir Poplavskij — Sun, 25 Jan 2026 14:00:00 GMT

Introduction

TSLint has been deprecated for years, but many legacy projects (and their forks) still rely on it. In this post, I’ll show you how we migrated our repository to ESLint using the modern Flat Configuration, improving both performance and developer experience.

Why Migrate?

Deprecated Stack: TSLint no longer receives updates.
Improved Performance: ESLint (especially with Flat Config) is significantly faster.
Modern Ecosystem: Better compatibility with modern tooling (Prettier, Jest, VS Code).
Stricter Type Safety: Catch common bugs like floating promises and unsafe type assignments.

The Migration Journey

Step 1: Out with the Old

I started by clearing out the legacy TSLint packages and the tslint.json file.

pnpm remove tslint tslint-config-prettier
rm tslint.json

Step 2: In with the New

I installed the core ESLint dependencies and the new typescript-eslint toolkit.

pnpm add -D eslint typescript-eslint globals

Step 3: Configuring for the Future

The new eslint.config.mjs setup is much cleaner and more modular. Here’s a snippet of our final configuration: Link

Step 4: Fixing the Fun Stuff

The migration revealed several hidden issues in our codebase:

Floating Promises: Discovered several unawaited calls that could cause race conditions.
Type Safety: Tightened up areas where any was being used loosely.

Results

[*] Faster linting: Noticeably faster.
[*] Better DX: Integrated seamlessly with our IDEs.
[*] Cleaner Code: Caught several bugs that TSLint missed.

Conclusion

Don’t wait! Migrating to ESLint is an investment in your project’s long-term health. The Flat Config system makes the setup more intuitive than ever.

Follow my journey at Fastify API with TypeScript

OWASP in practice — auditing my NestJS monolith

Vladimir Poplavskij — Wed, 21 Jan 2026 20:00:00 GMT

Here is base checklist to analyse:

Authentication & Session Management

JWT Strategy: Verify that JwtStrategy correctly extracts the Bearer token from the request headers and validates the sub (user ID) against your database.

Secret Key Management: Ensure that JWT_SECRET and SUPABASE_JWT_SECRET are not hardcoded but are managed via secure environment variables in your deployment environment.

Token Expiration: Confirm that JWTs have a reasonable expiration time set in your AuthConfig to minimize the window for token misuse if compromised.

Supabase Integration: Since you use Supabase for auth, ensure your SupabaseService properly handles the AUTH_CLIENT_OPTIONS and that the service role key is never exposed to the client.
Authorization (RBAC & Ownership)

RBAC Guard Logic: Audit RbacGuard to ensure it correctly checks both roles and permissions metadata before granting access to controllers.

Ownership Checks: In IncidentsService, you have logic to check if a user owns an incident before they can update or delete it. Ensure this “Ownership Guard” pattern is consistently applied across all services (e.g., Symptoms, Medications, Triggers).

Public Decorator: Check all routes marked with @Public() to ensure they are intended to be accessible without authentication.
Data Protection & Encryption

Symmetric Encryption: Your SymmetricKeyService uses aes-256-cbc for encryption. Verify that:

- The ENCRYPTION_KEY is exactly 32 bytes.

- The Initialization Vector (IV) is unique for every encryption operation to prevent pattern matching.

Hashing: Your IncidentsService uses createHash('sha256'). While SHA-256 is fast, ensure it is being used for data integrity and not for password storage (which Supabase handles).

Exception Filters: Your AllExceptionsFilter is designed to catch all errors. Ensure that in production mode, it does not leak internal stack traces or database query details to the end-user.
Input Validation & API Security

Global Validation Pipe: Ensure main.ts has app.useGlobalPipes(new ValidationPipe({ whitelist: true })) enabled to strip any properties from the request body that are not defined in your DTOs.

CORS Configuration: Review the CORS settings in main.ts. Ensure that only your dashboard domain (https://migrainepulse.com) is allowed in production, rather than using *.

Helmet/Security Headers: Check if helmet is implemented in main.ts to set security-related HTTP headers (e.g., X-Content-Type-Options, X-Frame-Options).
Infrastructure & Deployment

Environment Isolation: Confirm that env/.env.example is the only environment file in your repository and that actual .env files are ignored by git.

Database Connectivity: Ensure your Mongoose connection uses TLS/SSL when connecting to your production MongoDB instance.

Dependency Audit: Regularly run pnpm audit to check for known vulnerabilities in your project’s dependencies.

CI/CD Secrets: Verify that secrets like SLIPLANE_API_KEY used in your GitHub Actions are stored as encrypted repository secrets and not in plain text.

The Power of Not Having an Opinion Online

Vladimir Poplavskij — Sat, 27 Dec 2025 16:02:00 GMT

You don’t have to have an opinion about everything on the internet. Some things are simply none of your business.

In today’s hyper-connected world, we feel pressured to weigh in on every trending topic. However, true digital freedom comes from realizing that your silence is just as valuable as your voice. Protect your peace by choosing what deserves your energy and what doesn’t.

9 Behavioral Signs of Truly Promising People

Vladimir Poplavskij — Wed, 29 Oct 2025 20:00:00 GMT

The importance of your social circle is obvious. However, how to find valuable or promising people is an open question. Here is a selection of telling behavioral signs.

They are not dragged down by their environment or desires. They are independent and know how to decline, reasonably adhering to their priorities.
They don’t chase the crowd. They look at things a little differently. They respect the concept of “individuality.”
They are not afraid to ask questions. They fuel their curiosity and are open to discussion. They don’t aggressively try to impose their views as the only correct ones.
They don’t participate in small talk and meaningless chatter. They don’t care what someone is cooking for dinner, who is dating whom, what someone wore, or what a celebrity said.
They prefer solitude to big parties. They understand the difference between false satisfaction and true pleasure.
They are easily irritated by stupid, aggressively insistent, and toxic people. They avoid such people at all costs.
They know how to explain things easily and clearly. They are expressive with their ideas and can make sketches and diagrams if needed for clarification.
They avoid superficial knowledge. They study things from different angles and genuinely enjoy unfamiliar, alternative points of view.

If you stumble upon someone who fits the description of at least 2-3 points, that is the person you need. Their company will help you achieve success faster. Accordingly, the more such people in your environment, the better.

Why You're Stuck: 7 Reasons to Stop and Start Moving

Vladimir Poplavskij — Thu, 25 Sep 2025 19:00:00 GMT

Each of us has certainly had a moment in life when we felt like we were standing still. We dream of great things, we make plans, but for some reason, reality doesn’t keep up with our ambitions. This article isn’t meant to demotivate you, but to shed light on uncomfortable truths that may be the key to unlocking your true potential. Prepare to confront the seven reasons that may be the source of your lack of progress. Ready for an honest conversation with yourself?

You haven’t lost enough. You’re too comfy in your average life and don’t even try. You talk about learning new things instead of actually doing them.
You care too much what others think. You adjust yourself to fit in, focusing on what you own instead of what you do.
You think you’re smarter than you are. You’ve just learned the same stuff as everyone else to pass tests, but real knowledge comes from real life.
You don’t read. You only read what you have to, or nothing at all. You’d rather watch TV than learn something new or understand different perspectives.
You’re not curious. You just soak up whatever news is spoon-fed to you, never questioning anything or digging deeper.
You don’t ask questions. You don’t challenge authority or even yourself. You just survive in monotony.
The truth pisses you off. You’re living with your head in the clouds, ignoring reality, and you’re probably annoyed by this article right now. You’re the only one stopping yourself from doing awesome stuff.

By Raymmar Tirado

What dou You think about these reasons?

Fixing JNLP `libnsl.so.1` Error on Fedora Linux

Vladimir Poplavskij — Thu, 03 Jul 2025 08:00:00 GMT

When attempting to launch Java Web Start (JNLP) applications on recent Fedora Linux installations, experienced users may encounter a javaws execution error similar to:

javaws: error while loading shared libraries: libnsl.so.1: cannot open shared object file: No such file or directory

This issue typically arises because the libnsl (Network Services Library) package, while crucial for some legacy Java applications or specific JDK components, is no longer a default dependency or is deprecated in its traditional form on modern Linux distributions like Fedora. Consequently, a clean JDK installation might not include this library by default.

The Solution

The resolution is straightforward: explicitly install the libnsl package using DNF.

Install libnsl: Execute the following command in your terminal:
```
sudo dnf install libnsl
```
Rerun Your JNLP Application: After the libnsl package is installed, retry launching your .jnlp file:
```
javaws start.jnlp
```
The application should now execute without the libnsl.so.1 error.

Context and Explanation

The libnsl library historically provided an interface for network services, including functionalities related to NIS (Network Information Service). While its direct role has diminished in modern system architectures, certain older applications, or specific implementations within the Java Development Kit (JDK), might still carry dependencies on it. When these applications are invoked on systems where libnsl is not present, the javaws binary (part of the JDK) fails to load due to the missing shared object. Manually installing it ensures all necessary dependencies are met for legacy Java Web Start applications to function correctly.

This fix is applicable across various Fedora versions where this dependency omission might occur, ensuring smooth operation of JNLP applications for those requiring them.

Helpful Fedora Resources: Manage Your Linux System with Ease

Vladimir Poplavskij — Tue, 01 Jul 2025 12:00:00 GMT

Welcome to our comprehensive collection of helpful resources designed to make managing your Fedora Linux system straightforward and efficient. Whether you’re a new user looking for installation guidance or an experienced administrator seeking advanced tips, this page offers a curated selection of articles, tutorials, and tools. Dive in to learn how to master package management, configure your desktop, troubleshoot common issues, and unlock the full potential of your Fedora workstation or server. We aim to equip you with the knowledge and resources necessary to confidently navigate and optimize your Fedora experience.

List of the Fedora links:

Fix Fedora "Transaction Failed" Updates: Beginner's Guide

Vladimir Poplavskij — Tue, 01 Jul 2025 08:00:00 GMT

So, you’re updating your Fedora Linux system, and suddenly, DNF throws a “Transaction failed” error, specifically mentioning file conflicts like those pesky VLC plugins. Don’t sweat it! This article is your friendly guide to understanding and fixing these common update problems, even if you’re new to Linux.

Problem: Your Fedora update failed with a message similar to:

Transaction failed: Rpm transaction failed.
 - file /usr/lib64/vlc/plugins/codec/libfaad_plugin.so from install of vlc-plugins-base-1:3.0.21-24.fc41.x86_64 conflicts with file from package vlc-plugins-freeworld-3.0.21-2.fc41.x86_64

Understanding the Error: This error indicates that two different packages are trying to install the exact same file (/usr/lib64/vlc/plugins/codec/libfaad_plugin.so) on your system.

vlc-plugins-base: This is likely the official Fedora package for basic VLC plugins.
vlc-plugins-freeworld: This package is almost certainly from the RPM Fusion Free repository, which provides multimedia codecs and other software not included in Fedora due to licensing restrictions.

The conflict arises because both packages contain libfaad_plugin.so, which is a plugin for AAC audio decoding. Since RPM Fusion Free often provides more comprehensive multimedia support, it’s common to have both, leading to this conflict during updates.

Goal: To resolve this, you need to ensure that only one version of the conflicting package (or the package providing the conflicting file) is installed. In most cases, if you’re using RPM Fusion, you’ll want to prioritize the RPM Fusion version as it often provides broader codec support.

Method 1: Directly Remove the Conflicting Fedora Package (Recommended)

This method involves removing the vlc-plugins-base package, which is likely the one causing the conflict with the more feature-rich vlc-plugins-freeworld from RPM Fusion.

Identify the conflicting packages: The error message explicitly states them:
- vlc-plugins-base-1:3.0.21-24.fc41.x86_64 (likely from Fedora’s official repositories)
- vlc-plugins-freeworld-3.0.21-2.fc41.x86_64 (from RPM Fusion)
Remove the vlc-plugins-base package: Since vlc-plugins-freeworld is intended to provide the necessary VLC plugins (and often supersedes vlc-plugins-base in functionality), we can remove the vlc-plugins-base package directly. DNF should handle the dependencies by letting vlc-plugins-freeworld take over.

sudo dnf remove vlc-plugins-base

What to expect: DNF will list the vlc-plugins-base package for removal. It might also show that vlc (the main VLC player package) might be re-evaluated to depend on vlc-plugins-freeworld if it doesn’t already.
Review the output carefully. Ensure it’s only removing vlc-plugins-base and potentially adjusting VLC’s dependencies.
If prompted, type y and press Enter to confirm the removal.

Clean DNF metadata (optional but recommended): After removing packages, it’s good practice to clean DNF’s cache.

```
sudo dnf clean all
```

Retry the system update: Now that the problematic vlc-plugins-base package is removed, try the system update again.
```
sudo dnf update --refresh
```

This should now complete successfully.

Method 2: Reinstalling VLC to Ensure RPM Fusion Dominance

If Method 1 doesn’t fully resolve it, or if you want to ensure VLC is entirely sourced from RPM Fusion, you can reinstall it.

Remove all VLC-related packages:

This will remove both the Fedora and RPM Fusion versions of VLC and its plugins.
```
sudo dnf remove 'vlc*'
```
- Review the list carefully! Make sure you’re not removing anything critical that you don’t intend to.
Clean DNF metadata:
```
sudo dnf clean all
```
Install VLC (it should pull from RPM Fusion if enabled): If RPM Fusion Free is correctly enabled, dnf install vlc should pull the RPM Fusion version of vlc and its associated vlc-plugins-freeworld by default, as RPM Fusion packages often have higher priority or specific dependencies.
```
sudo dnf install vlc
```
- Verify during installation: DNF should indicate that it’s installing vlc and vlc-plugins-freeworld. Look at the “From repo” column in the transaction summary to confirm the packages are coming from rpmfusion-free or rpmfusion-free-updates.
Retry the system update:
```
sudo dnf update --refresh
```

Summary:

Now you’re ready to tackle “Transaction failed” messages like a pro! This guide walked you through solving common dnf update problems in Fedora Linux, giving you the confidence to maintain your system with ease.

Helpful Resources to Learn JavaScript on GitHub

Vladimir Poplavskij — Sun, 29 Jun 2025 12:00:00 GMT

Welcome to me curated list of excellent GitHub repositories that can help you learn JavaScript, from the very basics to advanced concepts. GitHub is a treasure trove of learning materials, code examples, and interactive projects.

List of the JavaScript links:

Unmasking Neuroticism: 5 Traps to Recognize in Yourself & Others

Vladimir Poplavskij — Sat, 28 Jun 2025 16:18:57 GMT

Have you ever felt a persistent unease, a gnawing feeling that something isn’t quite right, even when outwardly everything seems fine? Or perhaps you’ve observed patterns in others that just don’t add up? It’s possible you’re encountering the subtle, yet powerful, influence of neuroticism.

Neuroticism, at its core, is often a consequence of unresolved inner conflicts. It’s a complex psychological landscape where our internal struggles project outwards, sometimes twisting our perceptions and interactions in unexpected ways. Today, we’re going to explore five common “traps” that individuals prone to neurotic patterns often fall into, and crucially, how to recognize them in yourself or those around you.

1. The Claim to Love: When Connection Becomes a Crutch

We all seek love and connection, but for a neurotic individual, the very definition of love can become distorted. What might be labeled as “love” is often something else entirely – a desperate need, a parasitic reliance, or a desire for possession.

How it manifests:

Needing others to live your life: An inability to function independently, relying on another person to fulfill basic needs or provide a sense of purpose. It’s not about shared life, but a fundamental inability to live one’s own life.
Parasitic existence: Depending on someone else to meet your needs because you’re unable or unwilling to satisfy them yourself. This isn’t mutual support; it’s a one-sided drain.
Possession for prestige: A desire to “own” another, especially if that person holds significant power, prestige, or wealth. The perceived “love” is less about the individual and more about what they represent for your own self-importance.

Understanding the impact: This trap leads to relationships built on unstable foundations, often causing immense strain and dissatisfaction for both parties. It’s a love that suffocates rather than liberates.

2. The Claim to Kindness: Submissiveness Masquerading as Virtue

Kindness is a beautiful trait, but like love, it can be misconstrued within a neurotic framework. Here, what appears as “kindness” can actually be a deep-seated submissiveness, a suppression of genuine feelings driven by fear.

How it manifests:

Suppressed aggression: Rather than expressing legitimate anger or frustration, a neurotic individual might repress these aggressive impulses out of an overwhelming fear of judgment or rejection.
Obsequious behavior: An excessive desire to please, even at personal cost, not out of true altruism but from a desperate need for approval. This isn’t genuine empathy; it’s a strategic move to avoid disapproval.

Understanding the impact: This trap prevents authentic self-expression and can lead to resentment brewing beneath a facade of niceness. It also makes it difficult for others to truly connect, as the kindness feels more like a performance than a heartfelt gesture.

3. The Claim to Omniscient Interest: When Intellect Dominates Emotion

For some neurotic individuals, particularly those disconnected from their feelings and emotions, there’s a strong belief that everything can be solved through pure reason. This often translates into a facade of knowing everything or being intensely interested in a wide array of topics.

How it manifests:

Over-reliance on intellect: A conviction that logical analysis can resolve all problems, often dismissing the role of emotions, intuition, or interpersonal dynamics.
Profession as a shield: Dedication to a profession or cause, not for its inherent value, but as a means to achieve material well-being, prestige, or power. The true motivation is hidden, even from oneself.
Surface-level engagement: A broad, but often shallow, interest in many things, serving as a way to avoid deeper emotional introspection or genuine vulnerability.

Understanding the impact: This trap can create an emotional vacuum, leading to a life that feels intellectually rich but emotionally unfulfilling. It can also make it challenging for others to form deep connections, as genuine emotional exchange is avoided.

4. The Claim to Honesty and Justice: Aggression Dressed as Integrity

This trap is more common in aggressive neurotic types. What they present as unwavering honesty and a commitment to justice is often a thinly veiled expression of their own aggression, disguised as moral superiority.

How it manifests:

Brutal “honesty”: The inability to “sugarcoat” or be tactful is presented as a virtue, but it often serves as an outlet for hostility, intended to demean or put others down rather than to offer constructive truth.
“No” as a weapon: Saying “no” is not an assertion of healthy boundaries or strength, but a desire to humble, suppress, or undermine others. It’s about control, not conviction.
Moral grandstanding: A tendency to loudly declare their own rectitude while aggressively pointing out the perceived flaws or injustices of others.

Understanding the impact: This trap creates a toxic environment, eroding trust and fostering conflict. It’s not about genuine integrity; it’s about using the guise of honesty to assert dominance and express aggression.

5. The Claim to Suffering: Unconscious Motives Behind Misery

Neurotic individuals are prone to suffering, but this suffering often feels beyond their control, or at least, its true origins are obscured. To an external observer, their misfortunes might seem exaggerated or overly dramatized. However, there are often hidden motives behind this suffering.

How it manifests:

A cry for attention/support: Suffering can be an unconscious plea for notice, care, or validation from others.
Misattributing the cause: A neurotic person might believe they are suffering due to guilt, when in reality, the pain stems from not living up to an idealized self-image.
Loneliness masked as heartbreak: Believing one is suffering from unrequited love, when the true underlying cause is an inability to tolerate solitude due to an internal fragmentation.
Exaggerated drama: While the pain is real to the sufferer, their description of it often appears disproportionate to the actual events, leading others to feel confused or exhausted.

Understanding the impact: This trap can lead to a cycle of perpetual victimhood, where genuine self-understanding and growth are hindered by unconscious manipulation or misinterpretation of one’s own pain. It also makes it difficult for others to offer effective support, as the true needs are not being articulated.

Recognizing the Threads of Neuroticism

These five traps, while distinct, often interweave, leading to complex moral dilemmas and interpersonal challenges for the neurotic individual. They are, ultimately, consequences of unresolved internal conflicts – a person split into parts, unable to fully integrate their experiences and emotions.

Understanding these patterns is the first step towards untangling them. If you recognize these traits in yourself, it’s an invitation to explore your inner landscape with curiosity and compassion. If you see them in others, it can foster a deeper understanding, allowing you to interact with greater awareness and empathy. The path to breaking free from these invisible chains begins with recognition.

Source

psiholog_natakoshulko

Cynical Truths: Uncomfortable Realities About Life and Relationships

Vladimir Poplavskij — Mon, 23 Jun 2025 12:00:00 GMT

Introduction to Cynicism

Cynicism, at its core, is a philosophy rooted in questioning societal norms and perceived truths. It’s about stripping away illusions and facing the world with a critical, often skeptical, eye. While it can be seen as pessimistic, cynicism can also be a pathway to a more authentic and self-aware existence. Cynics value virtue and reason, often rejecting conventional desires for wealth, power, and fame.

11 Cynical Truths

By constantly forgiving everyone, you help evil to establish itself in impunity. Turning a blind eye to wrongdoing only allows it to flourish.
Exaggerated point: God will not call you. You are responsible for your actions and their consequences.
Life failures are a necessity. They are inevitable and provide valuable lessons for growth.
- Example: Failing a test teaches you the importance of preparation.
Money, no matter how you look at it, is the main thing. Financial stability often dictates opportunities and quality of life.
Even the biggest failure has an excuse. People will always find a way to rationalize their shortcomings.
- Example: Blaming a bad economy for a failed business venture.
“Always say yes” is not a good rule. Setting boundaries is crucial for self-preservation and prevents exploitation.
You are not the first in line for the injustice of this world. Suffering is a universal experience, and recognizing this can foster empathy.
- Example: Witnessing discrimination highlights systemic inequalities.
Everyone wears masks. People present different versions of themselves depending on the situation.
It’s worth reviewing your friends list. Not all relationships are beneficial, and some may be detrimental to your well-being.
- Example: Cutting ties with friends who consistently bring negativity into your life.
No one thinks the same way as you. Embrace individuality and understand that perspectives vary widely.
Every person uses you in their own way. Recognizing this doesn’t have to be negative, but it’s important to be aware of the dynamics in your relationships.
- Example: A colleague seeking your expertise to advance their own project.

Summary

These cynical truths may seem harsh, but they offer a clear-eyed perspective on the realities of life. By acknowledging these truths, you can navigate the world with greater awareness, protect yourself from manipulation, and make more informed decisions. Embracing a bit of cynicism can lead to a more authentic and resilient existence.

The Double-Edged Sword of Desire: Why "Be Careful What You Wish For" is Timeless Wisdom

Vladimir Poplavskij — Sun, 15 Jun 2025 12:00:00 GMT

“That’s a big takeaway from history, and it leads to a realization that will always be true: Be careful what you wish for.”

– “Same as Ever: A Guide to What Never Changes” Morgan Housel

This powerful quote distills a truth as old as humanity itself. We often chase desires with unwavering focus, convinced that their attainment will bring ultimate happiness. Yet, history, personal experience, and profound philosophical traditions consistently reveal a paradox: getting exactly what we want can sometimes lead to unforeseen difficulties, deeper dissatisfaction, or even regret. Both Stoicism and Mindfulness offer invaluable frameworks for understanding this intricate relationship with our desires, guiding us toward a more discerning and peaceful approach to life.

Stoicism: Mastering the Inner Citadel Against External Desires

Stoicism, an ancient philosophy focused on virtue, reason, and living in harmony with nature, provides a robust framework for understanding the pitfalls of unexamined desires. Its core principle, the Dichotomy of Control, teaches us to distinguish between what is within our power (our thoughts, judgments, and actions) and what is not (external events, other people’s opinions, health, wealth). Wishing excessively for things outside our control is, to a Stoic, a direct path to suffering.

For example, consider the desire for fame or public recognition. You might pour your energy into a creative project, dreaming of accolades and widespread appreciation. A Stoic would caution against this fervent wish. Why?

External Dependency: Fame is an external “indifferent.” It’s not inherently good or bad, and crucially, it’s not something you can control. You can create the art, but you can’t control how others react to it.
Vulnerability to Fortune: If your peace of mind hinges on public approval, you become enslaved to the fickle whims of others. What if the project flops? What if success brings unwanted scrutiny or pressure? Seneca, a prominent Stoic, warned extensively about the dangers of seeking popularity, as it often compromises one’s integrity and inner peace.
Compromising Virtue: The intense longing for external validation can subtly erode your commitment to virtue. You might find yourself making choices based on what’s popular rather than what’s right or authentic to your craft.

Instead of wishing for fame, a Stoic would advise internalizing your desires: wish to produce your best work, to act with integrity, and to apply yourself diligently. True satisfaction comes from the virtuous effort itself, not from the external outcome.

Mindfulness: Observing the Transient Nature of Longing

Mindfulness, deeply rooted in Buddhist traditions, emphasizes cultivating present moment awareness without judgment. When it comes to desires, mindfulness encourages us to observe them as transient mental events, rather than immediately clinging to them or acting upon them. The problem isn’t the desire itself, but our attachment to it and the mistaken belief that fulfilling every desire will lead to lasting happiness.

Consider the wish for a specific career promotion. You might spend countless hours dreaming about the new title, the higher salary, the perceived prestige.

Attachment to Impermanence: From a mindful perspective, even if you secure the promotion, the initial elation is fleeting. New stresses, greater responsibilities, or the realization that the role isn’t what you imagined often follow. Your happiness becomes dependent on an external condition, which is inherently unstable and subject to change.
Suffering from Non-Attainment: If the promotion doesn’t materialize, your intense wish and attachment can lead to profound disappointment, anger, or a sense of failure. Your mental peace is disrupted by clinging to a future scenario that didn’t unfold as desired.
Missing the Present: While consumed by the longing for a future promotion, you might overlook the present value of your current work, the opportunities for learning and growth in your existing role, or the simple joys of your daily life. Your mind is constantly pulled away from the richness of the “now.”

A mindful approach would involve:

Observing the desire: Noticing the wish for promotion as a thought or feeling, without getting swept away by it. “Ah, there’s the thought about wanting that promotion.”
Non-attachment: Working diligently towards your goals, but cultivating an acceptance of whatever outcome arises. Your inherent worth isn’t tied to the promotion.
Focus on the process: Finding satisfaction in the effort, the learning, and the engagement with your current tasks, regardless of the future reward. Understanding that true contentment comes from within, not from external achievements, which are by nature impermanent.

The Unshakeable Truth? Embracing Justification's Limits in the Face of Münchhausen

Vladimir Poplavskij — Sun, 08 Jun 2025 13:18:57 GMT

Dive into the profound challenge of the Münchhausen Trilemma and explore how we can find robust understanding even when faced with the limits of justification. This post unpacks the infinite regress, circular reasoning, and dogmatism, offering insights into practical ways to build knowledge and make decisions when absolute certainty remains elusive. Discover how embracing epistemological humility can lead to more resilient beliefs and a clearer path forward.

Examples

Here are some clear, relatable examples for each part of the Münchhausen Trilemma:

An Endless Chain of Reasons (Infinite Regress):
- Example: Imagine a child repeatedly asking “Why?” about everything.
  - “Why is the sky blue?”
  - “Because of how light scatters in the atmosphere.”
  - “Why does light scatter like that?”
  - “Because of the wavelength of blue light and the size of air molecules.”
  - “Why do light and molecules behave that way?”
  - …and so on, potentially forever, without reaching an ultimate, self-evident first principle. Each answer requires another explanation.
Circular Reasoning (Arguing in Circles):
- Example: A classic example is the “Bible is true because it says it’s true, and it says it’s God’s word, so it must be true.”
  - “How do you know the Bible is true?”
  - “Because the Bible says it’s the word of God, and God would not lie.”
  - “How do you know God would not lie?”
  - “Because the Bible says God is truthful.”
  - The justification for the Bible’s truth relies on the Bible’s truth itself, creating a closed loop without external validation.
Make Some Unproven Assumptions (Dogmatism):
- Example: Someone firmly believing that all alternative medicine is inherently fraudulent, simply because they “know” that traditional medicine is the only valid form of healing, without having researched or considered any evidence for alternative practices.
  - “I refuse to even consider acupuncture; it’s just quackery.”
  - “But have you seen any studies on its effectiveness for pain relief?”
  - “Doesn’t matter. It’s not ‘real’ medicine, and I don’t need evidence to know that.”
  - This person stops the chain of justification by declaring a certain premise (only traditional medicine is valid) as a self-evident truth, not requiring any further proof or inquiry.

So, how do we operate in the face of these seemingly intractable challenges? The key lies not in overcoming the trilemma in an absolute sense, but in understanding its implications and adopting more pragmatic and resilient approaches to justification. For the infinite regress, we learn to accept “sufficient justification” for a given context, often relying on widely accepted scientific consensus, practical utility, or community agreement as a temporary bedrock. To counter circular reasoning, we must cultivate a rigorous commitment to external validation, constantly seeking independent evidence or different perspectives to break the self-referential loop. Finally, to avoid falling into dogmatism, we embrace intellectual humility, remaining open to new evidence, challenging our own assumptions, and critically evaluating the foundations of our beliefs, even those we hold dear.

Summary:

This post boldly tackles the Münchhausen Trilemma, a foundational challenge to how we justify knowledge. We unpack its three inescapable paths: the infinite regress of reasons, the pitfalls of circular reasoning, and the rigid stance of dogmatism, illustrating each with clear, relatable examples. Rather than seeking an impossible absolute truth, the article proposes a practical framework for navigating these epistemological hurdles. It advocates for embracing “sufficient justification” within specific contexts, actively seeking external validation to break circular logic, and cultivating intellectual humility to guard against unproven assumptions. Ultimately, this piece empowers readers to build more resilient beliefs and make informed decisions by understanding and intelligently operating within the inherent limits of human justification.

The Spectrum of Motivation: Material and Non-Material Drivers

Vladimir Poplavskij — Thu, 15 May 2025 20:18:57 GMT

What truly drives us to be productive? It’s rarely just about the paycheck. This diagram breaks down the core elements of motivation, revealing the spectrum from tangible rewards to intangible drivers that influence our engagement and output. Let’s explore the key categories:

Stop Wishing, Start Doing: Stoic Quotes to Ignite Action and Focus

Vladimir Poplavskij — Sun, 11 May 2025 12:00:00 GMT

You don’t need more time, you need less distractions.
You don’t need motivation, you need self-control.
You don’t need more resources, you need resourcefulness.
You don’t need luck, you need preparation.
You don’t need to be busy, you need to be focused.
You don’t need to know everything, you just need to start.
You have everything you need.

How to Stop Comparing Yourself to Others and Find Your Own Path: Philosophical Reflections on the Meaning of Life

Vladimir Poplavskij — Mon, 30 Dec 2024 21:10:49 GMT

Comparing ourselves to others is a habit instilled in us from early childhood. We learn to see ourselves through the eyes of others, to be the object of someone’s assessment, to strive to meet external expectations. This is how a meaningless race begins, in which we lose ourselves.

But it’s worth asking: is there a final goal in this race? Can we truly find fulfillment by trying to catch up to others’ successes, changing ourselves according to someone else’s standards?

We are rarely taught to follow the path of our own soul, to seek the unique within ourselves, to be in agreement with ourselves. How often do we allow the external world to become our guide, forgetting that true freedom is not the right to be like everyone else, but the right to be oneself?

Victory can only be called genuine when it is the result of an internal choice, a response from the heart, a movement of our own will. Only by stepping beyond imposed stereotypes can we begin to live our real life, and not just play a social role.

Everything else is just an attempt to stay afloat on the surface of familiar scenarios, never allowing ourselves the question: “Who am I, really?”

If you want to move closer to your essence, try taking a step:

Live from the inside out, not the outside in.
Allow yourself to be responsible for your feelings and decisions.
Give up comparison and competition—choose exploration and acceptance.
Don’t explain yourself to the world—the world needs your presence, not your report.
Work thoughtfully, not by exhausting yourself.
Awaken your creative power; allow it to lead.
Fill every action with meaning and attention.
Allow yourself to create the meaning of your life—don’t look for a ready-made one, but give birth to your own.

Implementing Web Speech API: Advanced Text-to-Speech with SpeechSynthesisUtterance in JavaScript

Vladimir Poplavskij — Mon, 30 Dec 2024 12:00:00 GMT

This article details the process of converting text to speech using the SpeechSynthesisUtterance API in JavaScript. This robust API provides granular control over the voice, pitch, and rate of synthesized speech, making it an optimal choice for developing accessible web applications and enhancing user engagement.

Introduction: Leveraging the Web Speech API for Text-to-Speech

The SpeechSynthesisUtterance API serves as a fundamental component of the Web Speech API, designed to convert textual content into spoken audio within web applications. This API offers comprehensive control over the voice characteristics, including pitch and rate, enabling developers to create accessible and highly engaging user experiences.

Core Functionality: Understanding `SpeechSynthesisUtterance`

The SpeechSynthesisUtterance object represents a speech request and is the primary interface for configuring synthesized speech. Its constructor accepts a string, which is the text to be spoken.

const utterance = new SpeechSynthesisUtterance('Text to be spoken.');

Key properties of the SpeechSynthesisUtterance object allow for granular control over the output:

text: The string of text that the SpeechSynthesisUtterance will synthesize.
lang: The language of the utterance, specified as a BCP 47 language tag (e.g., en-US, es-ES).
voice: A SpeechSynthesisVoice object that defines the voice to be used. If not specified, the browser will use its default voice.
pitch: The pitch of the voice. A value between 0 (lowest) and 2 (highest), with 1 being the default.
rate: The speed at which the utterance is spoken. A value between 0.1 (slowest) and 10 (fastest), with 1 being the default.
volume: The volume of the utterance. A value between 0 (silent) and 1 (loudest), with 1 being the default.

Speech operations are managed by the window.speechSynthesis interface, which provides methods such as speak(), pause(), resume(), and cancel().

Practical Implementation: Basic Text-to-Speech

The following example illustrates a basic implementation of the SpeechSynthesisUtterance API to synthesize the text ‘Hello, world!’ into spoken audio: JavaScript

const utterance = new SpeechSynthesisUtterance('Hello, world!');
utterance.pitch = 1.5; // Sets the pitch to 1.5 (range 0 to 2)
utterance.rate = 1.2; // Sets the speech rate to 1.2 (range 0.1 to 10)

window.speechSynthesis.speak(utterance);

For comprehensive documentation regarding the SpeechSynthesisUtterance API, consult the official MDN Web Docs: https://developer.mozilla.org/en-US/docs/Web/API/SpeechSynthesis

Managing Voices: Asynchronous Loading and Selection

In recent Chrome versions, the window.speechSynthesis.getVoices() method may initially return an empty array upon page load. This behavior occurs because Chrome asynchronously fetches the list of available voices from its servers. To ensure voices are populated prior to text synthesis, it is imperative to implement a callback mechanism that awaits the completion of voice loading. The following code snippet demonstrates this approach:

window.speechSynthesis.onvoiceschanged = () => {
  const voices = window.speechSynthesis.getVoices();
  console.log('Available voices loaded:', voices);

  // Example: Selecting a specific voice
  // const desiredVoice = voices.find(voice => voice.name === 'Google US English');
  // if (desiredVoice) {
  //   utterance.voice = desiredVoice;
  // }
};

This code snippet utilizes the onvoiceschanged event to ensure the voices array is populated before attempting to access or select a specific voice for text-to-speech operations. The voices array can then be iterated to identify and assign the desired voice to the SpeechSynthesisUtterance instance.

Advanced Use Cases and Considerations

The SpeechSynthesisUtterance API facilitates a wide range of advanced web application features:

Accessibility Enhancements: The SpeechSynthesisUtterance API can be leveraged to provide auditory feedback for user interactions, guiding users through intricate processes or conveying critical notifications, thereby enhancing accessibility for individuals with visual impairments or cognitive disabilities.
Interactive User Interfaces: Implement voice-controlled interfaces, enabling users to navigate web pages, select options, and execute commands through spoken input, fostering a hands-free or alternative interaction paradigm.
Educational Platform Integration: Convert static, text-based educational content into dynamic audio lectures, thereby broadening accessibility and diversifying learning modalities for various demographics.
Personalized User Experiences: Customize the vocal characteristics and stylistic attributes of the synthesized speech to align with specific brand identities or user preferences, thereby creating highly differentiated and engaging web applications.

Browser Compatibility and Asynchronous Voice Loading

The SpeechSynthesisUtterance API is widely supported across modern web browsers. Below is an overview of its compatibility status:

Chrome: Fully supported from version 4 and up.
Firefox: Fully supported from version 2 and up.
Safari: Fully supported from version 3.1 and up.
Edge: Fully supported from version 12 and up.
Opera: Fully supported from version 10 and up.

Note on Voice Consistency: It is important for developers to be aware that the availability and quality of synthesized voices can vary significantly across different browsers and operating systems. This necessitates robust testing across target environments and potentially offering users a selection of available voices within the application.

Conclusion

The SpeechSynthesisUtterance API provides a powerful and flexible mechanism for integrating text-to-speech capabilities into web applications. By mastering its core functionalities and understanding key considerations such as asynchronous voice loading, developers can create more accessible, interactive, and engaging user experiences. Its broad browser support further solidifies its position as a valuable tool in modern web development.

Resources: Demos and Further Reading:

Live Demo: https://wirtaw.github.io/speech_synthesis/
MDN Web Speech API Synthesis Examples: https://mdn.github.io/dom-examples/web-speech-api/speak-easy-synthesis/
Smashing Magazine Article: https://www.smashingmagazine.com/2017/02/experimenting-with-speechsynthesis/
GitHub Repository Example: github.com/Drunkula/twitchtoolsglitch

The Difference Between Being Alone and Loneliness

Vladimir Poplavskij — Sun, 29 Dec 2024 20:44:16 GMT

Social isolation can affect your mental health if you are not used to spending time with yourself. However, even this can be adapted to and enjoyed.

Many thinkers over the centuries have emphasized the importance of coming to terms with this state. Michel de Montaigne once even wrote: “The greatest thing in the world is to know how to belong to yourself.”

Solitude encourages the imagination and makes it possible for serious thoughts to appear in people’s heads that go beyond the usual routine and force the convolutions to move.

Loneliness, on the other hand, is a negative experience. Self-pity, thoughts of a wasted life, sadness torment. And if you are really interested in your self-development, then it does not hurt to turn this feeling into positive and constructive.

The first step to being happy alone with yourself is accepting the situation. You need to ask yourself questions, turning loneliness into a constructive pastime: what do I really value in life? What do I need most? What do I need to do with…? What’s next?

The second step is to keep your mind and body in constant tone. You need your body to calm your brain. You need feelings to organize your thoughts. Do not feed yourself with empty chatter and empty dramatic thoughts that only worsen the situation.

You don’t have to run from anything. Instead of running away from what is, you should notice what is right under your nose. It sounds a bit complicated, but think about it.

Try starting a journal and writing down thoughts about what interests you. Write poetry. Download Duolingo and delve into some new language. Start writing your autobiography or a book. Visit a virtual museum. Learn something new through YouTube or take a course that will help accelerate your career growth and expand your competence. Anything.

Being happy alone with yourself is a constant striving to be better mentally, socially and emotionally for yourself and your loved ones.

Today’s topic is a bit complicated, but relevant - no offense. And we will end it with a wise saying: “You cannot be lonely if you like the person you are alone with.”

Finding Inner Peace in a Crazy World

Vladimir Poplavskij — Sun, 29 Dec 2024 12:00:00 GMT

One day you stop fussing and trying to prove something to someone, you look with a smile at the world around you with all its madness, you don’t rush to please people, you don’t rush to give advice or judge or save anyone, you stop answering calls from people who haven’t admired or interested you for a long time, you look at the sky more than at who is busy with what and how they live, you remember what inspires you regardless of the circumstances, you don’t apologize, you don’t explain, you don’t argue, you don’t waste time on the uninteresting and temporary, and you discover incredible peace and many things that you didn’t notice before in the pursuit of meeting someone’s ideas or meeting someone’s expectations. Comfort within is more precious than any temptations of temporary pleasure. More precious than any temporary people and temporary things. Everything you like is personal, and the personal belongs only to the person you see in the mirror. The rest is empty speculation and conjecture of those who are trying to see something else in you.

You are your own best ally in how to be yourself and be happy in this crazy world.

Source: Tatiana Marach

Stop Doing This: Habits That Kill Success

Vladimir Poplavskij — Sat, 21 Dec 2024 12:00:00 GMT

Stop being a people-pleaser. It’s impossible to please everyone, and it’s stressful. It’s better to have a small circle of close contacts than many acquaintances you need to appease. You want to be successful, not a sycophant, right?
Stop hanging out with nasty people. Your environment either pulls you up or tramples you further into the ground. Choose who to be friends with and who to surround yourself with practically. Avoid garbage.
Stop watching porn so often (men). Not only is it addictive, but with each orgasm, you lose strength - you ejaculate not only semen but also your motivation. It’s better to save energy and spend your time more wisely.
Stop needing to talk when you’re bored. Don’t know what to do? Don’t call someone for the sake of hour-long conversations about nothing. Instead, read/listen to a book or do something you’ve been putting off for days. Get rid of the need to fill the silence with empty chatter. Fill it with your own depth.
Stop caring about the opinions of others. It’s beyond your control. And if you can’t control it, why worry and fret? It’s a waste of time. Be independent and free yourself from the shackles of approval - they hinder your path to success. Not all your actions will be approved by others, so boldly ignore them. Approve of yourself.
Stop being in destructive relationships. Does your partner constantly pressure you? Constantly provoke quarrels and scandals? Is there no constructiveness in the relationship? Don’t hope for the best; move on. Break up. Spare your nerves; you’ll need them later.
Stop relying on miracles or luck. 99% of all results depend on your efforts, perseverance, and ambitions. Why would you rot in the shadows for 60 years, hoping for a miracle, if you can create that miracle yourself in a shorter time?
Stop procrastinating. If you need to do something, do it. Don’t think that tomorrow you’ll find a compromise with yourself and want to do something worthwhile. Do what’s necessary immediately. Don’t deceive yourself, and don’t put obligations in the back burner. By doing this, you’re only delaying your success.

4 foundations for self-discipline

Vladimir Poplavskij — Sun, 15 Dec 2024 08:18:57 GMT

1. Too many responsibilities - a destructive break to pieces. Do only what you want to do no matter what. Ignore the irrelevant.

Each commitment that you shoulder affects willpower. If there is too much excess, it will not stand and you will break.

2. Start the day with the most important thing. Something meaningful can be done in the first hour after waking up.

If you don’t want to load yourself with something significant early, do something small. It’s better than just sticking to the phone.

3. Be sharp and serious about yourself. If you forgot to do something, do not wish yourself, but punish yourself for the offense. Not with a whip, of course.

Sacrifice sleep to complete what was promised, for example. So the burden is off your shoulders, and self-confidence increases.

4. Routine correction. Plan as much as possible. Stick to the schedule until the very end of the day, do not shirk. When planning, you must take into account your priorities and adhere to their implementation.

The more habits and rules you introduce into your routine, the less you have to strain to maintain self-discipline. It will become the same effort as going to the toilet - by default, successful.

A strong and reasonable schedule is a must-have for outstanding people. Sooner or later, you still have to take control of the days. And it is better if you come to this yourself, and not forced by circumstances. There will be experience.

Self-restraint and sacrifice

Vladimir Poplavskij — Sun, 08 Dec 2024 12:00:00 GMT

It may be that the taste for self-restraint which these creeds, however false, have instilled in mankind has been of some use in strengthening the human race.

For the strength of the generic and individual character consists chiefly in the capacity to sacrifice the present to the future, to scorn the temptations of an ephemeral pleasure for a more distant and lasting satisfaction.

The more this faculty is exercised, the more exalted and strong becomes the character; and the highest heroism is attained by those who, in order to preserve or win liberty and truth for other, perhaps distant, ages, renounce the pleasures of life, and even life itself.

The Foundation of the Pyramid of Success

Vladimir Poplavskij — Sun, 08 Dec 2024 08:18:57 GMT

Mdina: Unveiling the secrets of Malta's Silent City

Vladimir Poplavskij — Sun, 22 Oct 2023 07:58:13 GMT

Step back in time as you wander through the captivating streets of Mdina, Malta’s enchanting Silent City. Discover its rich history, admire its captivating architecture, and soak in its tranquil atmosphere. From ancient fortifications to captivating museums, Mdina offers a unique and unforgettable experience.

Nestled atop a hill in the heart of Malta, Mdina stands as a captivating relic of a bygone era. Known as the Silent City, Mdina exudes an aura of tranquility that is both enchanting and mesmerizing.

Mdina castle.

As you pass through the imposing Mdina Gate, you are instantly transported back in time. The narrow, winding streets are lined with magnificent palazzos, their honey-colored facades adorned with intricate details. The air is filled with a sense of history, whispering tales of the many civilizations that have graced this ancient city.

Mdina’s rich history dates back to the Bronze Age. Over the centuries, it has been ruled by Phoenicians, Romans, Arabs, Normans, and the Knights of St. John. Each civilization has left its mark on the city, creating a unique blend of architectural styles.

Among the must-see attractions in Mdina are:

Mdina Cathedral: A stunning example of Sicilian Baroque architecture, Mdina Cathedral is a feast for the eyes. The interior is adorned with opulent decorations, including intricate marble carvings and gilded artwork.
Mdina Dungeons: Descend into the depths of Mdina and explore the city’s eerie dungeons. These subterranean chambers were once used to hold prisoners, and their atmosphere is still one of mystery and intrigue.
Palazzo Falson: This magnificent palace offers a glimpse into the lives of Mdina’s noble families. The opulent interior is filled with fine art, furniture, and artifacts.
Mdina Glass: Mdina is renowned for its exquisite glassblowing tradition. Visit Mdina Glass to see skilled artisans create beautiful works of art from molten glass.
Bastions of Mdina: The bastions that surround Mdina offer breathtaking views of the surrounding countryside. Take a stroll along the bastions and enjoy the panoramic vistas.

As you wander through Mdina’s enchanting streets, take the time to savor the city’s tranquil atmosphere. The absence of cars and the hushed whispers of the wind create a sense of serenity that is truly unique.

Mdina is a place where time seems to stand still. It is a city that invites you to slow down, to relax, and to simply be. So come and explore the Silent City, and let its magic transport you to another era.

Open jnlp file on Fedora

Vladimir Poplavskij — Sat, 14 Dec 2019 18:09:20 GMT

How to open an jnlp file on Fedora

I have on laptop Fedora 30 (x64) For an online service connect need to start - specific start.jnlp file.

Google help me find information - what my system need JDK Next step install java on my Fedora 30, because it not installed yet.

By this instruction done JDK installation.

Reboot. Run system upgrade

sudo dnf update

Try to run start.jnlp

javaws start.jnlp

Got terrible error

javaws: error while loading shared libraries: libnsl.so.1: cannot open shared object file: No such file or directory

Ok. Let’s install libnsl package

sudo dnf install libnsl

And next try. Voila it works.