DEV Community: Volodymyr Obrizan

What is Functional Programming?

Volodymyr Obrizan — Tue, 15 Apr 2025 09:14:35 +0000

Functional programming (FP) is a programming paradigm where computations are treated as the evaluation of mathematical functions rather than as a sequence of instructions that change state.

At the heart of FP are pure functions, immutability of data, and the absence of side effects. This approach helps create code that is clear, predictable, and easy to test.

Key Features of Functional Programming

Pure Functions — A function always returns the same result for the same inputs and does not alter any external state.
Immutability — Instead of modifying existing variables, new values are created. 3.First-Class Functions — Functions are treated as first-class citizens — they can be passed as arguments, returned from other functions, and assigned to variables.
No Side Effects — Functions do not affect the external environment: no file writing, no global state changes, no console output.
Recursion Instead of Loops — Recursion is often used instead of iterative constructs like for and while loops.
Expression-Oriented Programming — Everything is an expression that returns a value, rather than just a sequence of instructions.
Function Composition — Complex behavior is built by combining simple functions together.

Where Is Functional Programming Used?

Big Data Processing — Due to its suitability for parallel computation, FP is popular in big data tools like Apache Spark (Scala).
Financial and Scientific Applications — Where precision, predictability, and mathematical rigor are essential.
Web Services and APIs — Used in languages like JavaScript or Elixir to build scalable reactive systems.
Software Testing and Verification FP simplifies unit testing due to the predictability of pure functions.
Frontend Development — Libraries like React apply many functional programming concepts (e.g., pure components, immutable state).

For my Ukrainian-speaking followers

For anyone who wants to dive deeper into functional programming, I’ve translated the tutorial “Functional Programming in Python” (Функціональне програмування на Python) into Ukrainian, made the examples interactive, and added knowledge quizzes. It’s online and free.

Why Bitbucket Pipelines is Slow and How to Optimize

Volodymyr Obrizan — Tue, 30 Jul 2024 12:26:42 +0000

Bitbucket Pipelines can be slow due to poor CI infrastructure performance and the time-consuming process of installing dependencies for each build. Here's how to address these issues:

Performance Issues:

Infrastructure Delays: Delays in provisioning and build setup can occur, with performance inconsistencies noted in monitoring projects.
Dependency Installation: Installing libraries, tools, packages, and third-party dependencies each time consumes significant build time.

Optimization Approach:

Pre-configure Docker Image:

Dockerfile Creation: Move dependency installation commands to a Dockerfile.
Build and Push Image: Use Docker Buildx to create an image and push it to Docker Hub.
Update Pipeline: Modify bitbucket-pipelines.yml to use the new Docker image, eliminating repetitive setup steps.

Example Dockerfile:

FROM python:3.11.7-slim-bullseye
RUN apt-get update
RUN apt-get install -y build-essential postgresql postgresql-client curl
RUN curl https://dl.min.io/client/mc/release/linux-amd64/mc --create-dirs -o ~/minio-binaries/mc
RUN chmod +x ~/minio-binaries/mc
COPY requirements.txt .
RUN pip install --ignore-installed -r requirements.txt

Example Updated bitbucket-pipelines.yml:

image: dntl/1l2c-backend-for-tests:latest
pipelines:
  default:
    - step:
        script:
          - export PATH=$PATH:~/minio-binaries/
          - mc alias set testing-minio http://localhost:9000 root root-pass
          - mc admin user svcacct add --access-key "test_access_key" --secret-key "test_secret_key" testing-minio root
          - mc mb testing-minio/dean-testing
          - PGPASSWORD=root psql -h localhost -p 5432 -U root postgres -c 'create database dean_unit_tests_db;'
          - python -m pytest . --test_application_name=dean --junitxml=./test-reports/dean_out_report.xml
        services:
          - postgres
          - elasticsearch
          - minio

Results:

Setup Time Reduction: Dependencies are pre-configured, reducing setup time from several minutes to less than 10 seconds.

Overall Efficiency: Test execution time decreased significantly, saving valuable build minutes.

Conclusion:

By pre-configuring a Docker image, you can optimize Bitbucket Pipelines, ensuring faster and more reliable builds. This approach minimizes dependency on CI infrastructure performance and reduces the total build time.

For more detailed information, visit the full article here.

Why Programmers Have a Tough Job

Volodymyr Obrizan — Fri, 12 Jan 2024 08:44:42 +0000

In one of the projects we're developing, 85% of the code volume is from third-party libraries. That is, these are the libraries that need to be installed in the project so that the other 15% of the code can work with something. There are a total of 93 such libraries.

Since the software market is very large and attractive (hundreds of billions of dollars), there are many players, and the competition is frankly fierce.
Players try to innovate, create new features for products, make improvements, in order to stand out favorably from their competitors. In most cases, all these improvements are essentially complete nonsensical nonsense.

If you stop releasing new versions, you can quickly start losing market share. After all, a competitor will continue to vigorously imitate innovation every month, release versions, press releases, create news hooks, and speak at conferences.

Programmers have to adapt. With the release of each new version, they need to see how it differs from the previous one and update their current project. As a result, a good part of a programmer's time is spent not on solving the task at hand, but on upgrading libraries, tools, services, and fixing all the inconsistencies in integration that arise from this.

And this gets very tiresome quickly.

Can you stop and not update libraries? I do not advise it. Over time, old libraries stop being supported by their manufacturers. First, it becomes impossible to compile the product. And then even the compiled ones stop working. The second aspect: the market demands specialists who can work with modern technologies, not with Algol 68 or Delphi (remember how hyped that technology was?).

Yes, programmers are well paid. But if you consider motivation besides money, employees are also motivated by success: successfully completed projects, and in the short term - successfully closed tasks.

And there is also a big problem with this: if you need to constantly integrate new libraries with which there is no experience, then both the estimation of labor costs and the reliability of the solutions obtained suffer greatly. A programmer is forced to constantly study the features of new libraries, adapt to them. And the fact that it is impossible to predict the outcome of a task in terms of labor costs and reliability is very demotivating. A modern programmer rarely leaves work happy: "I completed my tasks and I did the job well".

This is one of the reasons why programmers burn out very quickly. It seems they are paid well, but the job is complete crap.