DEV Community: Michal Štefaňák

Building Nexus Fleet: a roguelike Sea Battle with React Native

Michal Štefaňák — Tue, 29 Apr 2025 08:55:57 +0000

I'm excited to share the journey of creating my mobile game Nexus Fleet. It's a roguelike take on the classic Sea Battle, where each victory propels you into a new game with your surviving fleet, and strategic choices of new ships or powerful admirals with unique abilities heavily influence your chances of success. With 15 distinct admirals to discover, each run offers a fresh tactical challenge. Nexus Fleet is available now on both Android and iOS!

In this article, I wanted to dive into the technology stack behind Nexus Fleet and share some of the experiences I had during its development.

React Native

One of the primary motivations for choosing React Native was my existing familiarity with React, even while I'm experienced with Unity. The component-based architecture and the declarative approach to UI development felt natural and allowed me to leverage my web development skills in the mobile space. I was able to dive deeper into making custom game elements like Game management context, Notification context, unified Grid component or Actor (player/enemy) custom effect.

In main _layout.tsx file I wrapped everything in GameContext. This way game status and access to all game related informations are available anywhere. Here is a preview of available functions:

return (
    <GameContext.Provider
        value={{
            player,
            enemy,
            status,
            newGame,
            setGameStatus,
            admiralPool,
            secondChanceAdmiral,
            addedSecondChanceAdmiral,
            statistics,
            rewardAdmiral,
            setRewardAdmiral,
        }}
    >
        {children}
    </GameContext.Provider>
);

I wanted custom whole screen notification so I've made NotificationContext. It handles showing dismissable queued notifications even when switching screens with fade in and out animation. I feel proud on this piece of code. Here is a preview of final result:

Expo framework

To streamline the development process, I opted to use the Expo framework as it was suggested everywhere. After developing a big portion of my game I discovered I have to use EAS for build. My first emotion was disappointment, because I prefer to do task locally. I started thinking how to get rid of Expo. Fortunatelly I discovered I can still build locally for android while I use Expo. For those interested you need to run these commands:
npx expo prebuild
npx react-native build-android --mode=release

If you need to build signed bundle for Google play store check out this great manual: https://reactnative.dev/docs/signed-apk-android

Story for making iOS build is a bit different. I discovered I need apple device to make it happened. Which I don't have as windows user. I read something about running MacOS in virtual machine, but that does sound like a lot of hustle. However I realized I could use EAS. Limit 15 free builds should be enough. So I gave it a try and frankly, in the end I was thankful for this cloud tool, it became really helpful to build and submit iOS build. Now my package.json contains following scripts:
eas build --platform ios
eas submit --platform ios

Expo router and status bar packages were also very helpful to create required layout. And let me say, one of my favorite things with packages in this framework are icons. It includes all popular icon packages and you can use all of them. https://docs.expo.dev/guides/icons/

Visual and AI

As a developer with limited graphic design skills, the emergence of AI image generation tools has been a game-changer. For Nexus Fleet, I heavily relied on AI to create admiral portraits and background elements. These tools allowed me to quickly iterate on visual concepts and generate assets that fit the game's aesthetic without requiring extensive manual design work. This significantly sped up the development process and allowed me to focus on the gameplay mechanics and programming.

In the end I tried out Microsoft Clipchamp for the first time to make some promotional video. It's really practical and easy to use tool. You can check out the result on youtube:

Future plans

There are some ideas. I would like to add sounds, music, leaderboard, battle history log and some settings to customize UI. Maybe a multiplayer would be a great feature. We will see.

If you have some suggestions you can add them here: https://github.com/stefanak-michal/nexus-fleet-game/issues

PHP library and analytics controversy

Michal Štefaňák — Wed, 16 Apr 2025 08:37:39 +0000

My initial release of the PHP Bolt Driver aimed to empower developers with a seamless way to interact with graph databases directly from their PHP applications. However, despite its functional success in achieving this goal, the library didn't garner the anticipated level of recognition or reward. To gain a clearer picture of its adoption and usage, and to provide data that could be leveraged in future discussions or collaborations, I implemented anonymous analytics collection.

The implementation of analytics, even with a focus on aggregated, anonymous data, inevitably invites scrutiny. Despite prioritizing user privacy and aiming solely to gather broad usage patterns, I still encountered concerns regarding data collection. While I collect only two counts: number of executed queries and number of sessions, the default opt-in nature of the solution also contributed to friction. Users expressed concerns about automatic data collection, even with the assurance of anonymity, highlighting the sensitivity surrounding data practices.

Implementation

To minimize performance and requirements impact on the library's users, I opted for a local storage approach. The collected data is stored in a file within the system's temporary directory. This strategy avoids immediate network requests during library operations, ensuring minimal latency.

The core of the data handling resides within the FileCache class, an implementation of the PSR-16 cache interface. This allows for flexibility, enabling users to substitute the default FileCache with alternative caching solutions if preferred.

Addressing concurrency - file locking

A critical consideration was handling concurrent access to the data file. To prevent data corruption, I implemented file locking mechanisms within the FileCache class. This ensures that only one process can write to the file at any given time, maintaining data integrity. To learn more check the FileCache source code.

Asynchronous reporting - Mixpanel integration

To minimize the impact of data transmission on application performance, the collected data is sent to Mixpanel via an HTTP request during the library's initialization. This transmission occurs only if unsent data older than a day is detected. Once the data is successfully sent, it is deleted from the local file. This approach effectively avoids persistent network latency during regular library operations.

Popularity

Besides almost half million downloads with composer here are the current data, which are publicly available at mixpanel.

Screenshot from 25. april 2025

Why PHP file functions cannot finally evolve?

Michal Štefaňák — Wed, 05 Mar 2025 13:51:27 +0000

Seriously, why? Why, in the name of all what is holy in software development, do we still have to dance with the @ symbol and endless if ($result === false) checks when dealing with files? It's 2025 (or whatever year it is when you're reading this), and we're still playing whack-a-mole with warnings instead of having the clean, predictable behavior of exceptions.

Here it is, the silent treatment. We're just going to pretend that nothing bad could possibly happen. Because, you know, suppressing errors is always a good idea. (Spoiler alert: it's not).

$file = @fopen("myfile.txt", "r");
if ($file === false) { 
  // Oh crap, something went wrong. But what? Who knows! 
  // Maybe the file doesn't exist. Maybe the server is on fire. 
  // Time to consult the PHP manual for the 57 possible reasons why fopen() might fail. 
  // And then write a dozen different error handling scenarios. Fun times!
}

This is not error handling. This is error guessing. Let's be honest, symbol @ smells. It's the equivalent of saying "I know something might go wrong here, but I'm just going to ignore it and hope for the best."

Contrast this with a sane language, where working with file would throw an exception if something went wrong. FileNotFoundException, PermissionDeniedException, DiskFullException – beautiful, descriptive, and catchable. We could wrap the file operation in a try-catch block, handle specific errors gracefully, and write much cleaner code.

Let's leave @ symbol and false check where they belong: in the dusty archives of bad programming practices. The future of file handling shouldn't involve guesswork and suppressed warnings. It should be clean, clear, and exception-based. Please, PHP, for the sake of our sanity, give us exceptions!

Let me explain a ThingsDB Todo app demo

Michal Štefaňák — Mon, 05 Aug 2024 15:30:00 +0000

Some time ago I've discovered a database called ThingsDB. I was curious about it and I did some reading. I've discovered they support TCP connectivity but they didn't have driver for some specific platforms therefore I've developed a driver for it for javascript and for php.

When I worked on javascript driver I've realized, it would be possible to use ThingsDB directly from frontend without any backend or middleware. You can open websocket (TCP) connection from browser, so I reached out to the authors of ThingsDB and they added support for websocket (available from ThingsDB version 1.6). This way my javascript driver can be used from frontend (browser) and also from javascript based backend (ex. node.js). I wrote article here about my php driver where I have received interesting feedback. People wanted to see more of the potential of ThingsDB. Based on that I chose not to write article about my javascript driver right after I've finished it, but I've decided it would be best to make demo.

To understand basics of ThingsDB and this demo I suggest you to read continuosly as I explain specific features on the way. I expect you are familiar with programming in general, at least basics. And maybe some javascript and jQuery.

ThingsDB structure introduction

First things first. Let me shortly explain the structure.

ThingsDB contains collections. Collection contains data, procedures, tasks, data types and enums. There is also prior collection (scope) @thingsdb which contains user access accounts and it can also contains procedures and tasks. Lastly there is @node scope which is not important right now.

Data - persistent stored data
Procedure - like function, can have arguments and it can return value
Tasks - planned events, like cron
Data types - like classes, it can have properties and methods
Enums - enumerators

All named things like data, procedures, tasks, data types and enums are defined by developers implementing ThingsDB. New instance of this database only contains empty collection called @:stuff and user account admin. I use this collection as main one for this demo.

Talking to yourself

When you execute query or run procedure on ThingsDB, you have to specify on which collection it will run. That can be sometimes limiting and if you have a need to execute query or run procedure on another collection, there is a way how to achieve that. There is a module called thingsdb (book, GitHub) which allows you to access another collection from collection as specific user. My demo use this feature heavily when dealing with user accounts which is reason I mention it here. I have installed this module as explained in manual.

I'll explain permissions little bit later but fyi: User account I've made for this module has permissions Query, Change, Grant on collection @thingsdb and Change, Grant on collection @:stuff.

User accounts

I chose to use only ThingsDB and that means I had to use their user accounts. I had to deal with registration and login which was little bit tricky because of the absence of backend. Of course I could use some third party authentification server (auth0, etc.), but I didn't want to rely on anything else.

In the case somebody wants to implement 3rd party auth system, you can do HTTP requests from ThingsDB with Request module (book, GitHub).

To allow users to register I needed some user account to communicate with ThingsDB and execute the registration. But required credentials for this account would be published in javascript code which doesn't sound very secure. I didn't want to deal with all security problems but I wanted to implement at least the simple ones. ThingsDB support granting permissions for each user account against each collection specifically. Available permissions to grant are Query, Change, Grant, Join and Run.

Query - query ThingsDB
Change - allow execution of code which does change of data
Grant - allow granting permissions
Join - allow join rooms
Run - run stored procedure

I'm not able to use Query at all. Because with this command you can execute anything on ThingsDB and opening this to the client browser pose huge security problem. The path was clear, I had to use procedures and just allow Run for client.

Important information to know is the user accounts doesn't have only password but also access tokens (with expiration if needed).

Prepare ThingsDB for registration

I've created collection @:auth and user account with name aa (auth account) and I gave him permission Run over this collection. Collection @:auth contains only one procedure called register. All this means, the user aa can do only one thing which is to run procedure called register. Therefore his access token can be published.

Procedure register does create new account and grant required permissions. The code looks like this:

new_procedure('register', |email, password| {
    if (email.len() == 0 || password.len() == 0 || !is_email(email)) {
        raise('required values not provided');
    };
    thingsdb.query('@t', "
 if (has_user(email)) {
     raise('email already registered');
 };
 new_user(email);
 set_password(email, password);
 grant('@:stuff', email, RUN | CHANGE);
 ", {
        email:,
        password:,
    });
    nil;
});

I guess this is your first time seeing code from ThingsDB. It is familiar to another programming languages just with slight changes. What the procedure does:

Accepts two arguments
Verify arguments email and password
Use module thingsdb explained in section Talking to yourself to run query
- Check if email is already registered
- Create new user account and set password
- Grant required permissions

email:, can be a little bit confusing but it's a shorthand when you want to pass variable to argument and argument and variable has the same name.

@t is shortcut for @thingsdb scope.

Frontend implemention of registration

With everything ready at ThingsDB side I've created simple website with registration form and few lines of javascript. The code snippet which manages to run procedure inside of ThingsDB looks like this:

const thingsdb = new ThingsDB();
thingsdb.connect()
  .then(() => thingsdb.authToken(localStorage.getItem('aa')))
  .then(() => thingsdb.run('@:auth', 'register', [
    $('#email').val(), 
    $('#password1').val()
  ]))

It performs authentification with token (for aa user account)
Runs procedure register

I keep access token of user aa in browser localStorage.

To see whole implementation look here:

Login

After user is able to register, next step was to implement login action. For login password is required but it would be not very safe to store user password in browser. The solution is to generate access token (with expiration) after login and return it to client, where it can be stored in browser (ex. sessionStorage). So I've created procedure in @:stuff collection where registered user account has required permissions.

new_procedure('login', || {
    email = user_info().load().name;
    if (is_email(email)) {
        thingsdb.query('@t', "new_token(email, datetime().move('days', 1));", {email: })
            .then(|token| token);
    };
});

Creation of token has to be called on @thingsdb scope, in that case I use thingsdb module again. The javascript code snippet to call this procedure looks like this:

const thingsdb = new ThingsDB();
thingsdb.connect()
  .then(() => thingsdb.auth($('#email').val(), $('#password').val()))
  .then(() => thingsdb.run('@:stuff', 'login'))
  .then(token => {
    sessionStorage.setItem('token', token);
    window.location.href = './overview.html';
  })

Obtained access token is stored in sessionStorage.

Here you can check whole login page which contains login form and required javascript code:

Overview

After login user is redictered here where he has some account actions and list of his Todos. That required to specify structure, how Todo data will be stored and for this purpose we can use data types. I created Todo type which has name, user_id and items. Item type has description, checked status and Todo reference. Connection between Todo and Item is made with both ways relation (book, docs). Both types are defined in @:stuff collection.

new_type('Item');
new_type('Todo');

set_type('Item', {
    description: "'str',"
    checked: 'bool',
    todo: 'Todo?',
});
set_type('Todo', {
    name: 'str',
    items: '{Item}',
    user_id: 'int',
});

mod_type('Item', 'rel', 'todo', 'items');

In this piece of code you can see how the types are made, what properties with data types does they have and set up of relation between them.

But this is just definition. We need to store Todos somewhere. For that we create property directly on collection @:stuff like this. Without the dot it would be just variable and it won't be persistent.

.todos = set();

Now after the data structure is ready, let's go through each action.

Todos

Upon loading of overview page, request to load Todos of users to ThingsDB is made. First we need a procedure on @:stuff collection which returns list of Todos:

new_procedure('list_todos', || {
    user_id = user_info().load().user_id;
    .todos.filter(|t| t.user_id == user_id);
});

Filter is function available to call on set.

Now we can call this procedure with javascript code snippet like this (processing received data is omitted):

const thingsdb = new ThingsDB();
thingsdb.connect()
  .then(() => thingsdb.authToken(sessionStorage.getItem('token')))
  .then(() => thingsdb.run('@:stuff', 'list_todos'))
  .then(todos => { })

You can check the whole implementation here:

Password change

For this action I've created procedure update_password which requires to use thingsdb module again. User accounts are stored in @thingsdb scope.

new_procedure('update_password', |password| {
    email = user_info().load().name;
    if (is_email(email)) {
        thingsdb.query('@t', 'set_password(email, password);', {
            email:,
            password:,
        });
    };
});

I use html dialog tag to enter a new password and the javascript code snippet to handle it is very simple:

thingsdb.run('@:stuff', 'update_password', [$('#password1').val()])

I don't have to call authToken again because websocket connection is still open from the request to load Todos.

You can check the whole implementation here:

Delete account

Procedure for this action removes not only user account but also his Todos. It looks like this:

new_procedure('delete_user', || {
    email = user_info().load().name;
    if (is_email(email)) {
        .todos.remove(|todo| todo.user_id == user_id);
        thingsdb.query('@t', 'del_user(email);', {email: });
    };
});

Remove is another function which can be called on set.

I had to use thingsdb module again. User accounts are stored in @thingsdb scope.

Call of this procedure can be done easily with javascript code snippet:

thingsdb.run('@:stuff', 'delete_user')

I don't have to call authToken again because websocket connection is still open from the request to load Todos.

Look at the whole implementation here:

Create Todo

User need a way to create new Todo. For that reason I made page new_todo and overview contains link to it. Form to create todo consist of todo name and items (descriptions). I decided to store new Todo with items in two steps, because originally I wanted to allow editing of Todo (which in the end didn't happen). Therefore I've created two new procedures.

new_procedure('create_todo', |name| {
    t = Todo{
        name:,
        user_id: user_info().load().user_id,
    };
    .todos.add(t);
    t.id();
});

new_procedure('add_todo_items', |todo_id, items| {
    todo = thing(todo_id);
    if (todo.user_id != user_info().load().user_id) {
        raise('Not yours');
    };
    todo.items.clear();
    items.each(|i| {
        item = Item{
            checked: false,
            description: "i,"
        };
        todo.items.add(item);
    });
});

First procedure to create todo returns it's id and second procedure deletes all items and adds new ones. I think if you read until here you are already getting hang of it and I don't have to explain .todos.add() or items.each() (set add, thing each).

What is new here is thing(todo_id). You can get reference to any thing (thing is like instance of class/data type) from collection by id. You don't have to know where is stored, you can just get it. Thing has assigned id when is stored persistently.

To perform defined action you just have to call it with javascript code snippet:

thingsdb.run('@:stuff', 'create_todo', [$('#name').val()])
  .then((todo) => thingsdb.run('@:stuff', 'add_todo_items', [
    todo, items.length ? items.map(function () {
      return $(this).val();
    }).get() : []
  ]))

Look at the whole implementation here:

Todo detail

Overview page shows list of user Todos. By clicking on it user is redirected to page where he can see Todo items, change their status and delete whole Todo list.

Load Todo data

To load one specific Todo I've created new procedure:

new_procedure('list_todo', |todo_id| {
    todo = thing(todo_id);
    if (todo.user_id != user_info().load().user_id) {
        raise('Not yours');
    };
    return todo, 2;
});

Now you are propably asking why there is return todo, 2;? With return you can set depth of data you want to return. With number 2 here returned data contains not only Todo itself, but also Items the Todo has relation with.

Because Todo id is passed as uri get parameter, the javascript code snippet to call this procedure looks like this:

thingsdb.run('@:stuff', 'list_todo', [
  parseInt(location.search.match(/id=(\d+)/)[1])
])

Look at the whole implementation here:
todo.html
todo.js

Change Todo item status

I render todo items as checklist, so to change status of item I've created new procedure:

new_procedure('mark_item', |item_id, checked| {
    item = thing(item_id);
    if (item.todo.user_id != user_info().load().user_id) {
        raise('Not yours');
    };
    item.checked = checked;
    nil;
});

Because you can also uncheck, not only check item, javascript code snippet has to be like this:

thingsdb.run('@:stuff', 'mark_item', [
  parseInt(this.id),
  $(this).is(':checked')
])

Look at the whole implementation here:
todo.html
todo.js

Delete Todo

If we want to delete Todo, we don't have to delete items because they are not stored separately. If Todo is removed, no other reference exists for its items and they are automatically removed.

new_procedure('delete_todo', |todo_id| {
    todo = thing(todo_id);
    if (todo.user_id != user_info().load().user_id) {
        raise('Not yours');
    };
    .todos.remove(todo);
});

Now the javascript code snippet is simple:

thingsdb.run('@:stuff', 'delete_todo', [
  parseInt(location.search.match(/id=(\d+)/)[1])
])

Look at the whole implementation here:
todo.html
todo.js

Installation guide

To simplify usage of this demo you can run ThingsDB in docker described in README.

Next simply open install.html which creates everything required in this ThingsDB instance and store access token of aa user to localStorage.

That's it. I hope I gave you basic insight into this technology. If you like my work you can buy me a tea.

No AI was used to generate this content, only the cover picture.

Lively Search Input with Animated Border Progress

Michal Štefaňák — Sat, 01 Jun 2024 08:52:03 +0000

Ever stared at a blank search bar, willing it to return results faster? We've all been there. I've decided to explore a unique search input design that adds a touch of interactivity and user feedback to the search process in my graph database administration tool.

The Power of Visual Feedback

A static search bar provides little indication of progress. My design incorporates a dynamic border that animates while the search is ongoing. This visual cue informs the user that the system is actively processing their request, reducing the perception of wait time and improving the overall user experience.

Behind the Scenes

This animation is achieved using CSS preprocessor code, specifically Sass. The clippath is used to define the animation, creating a clipping effect that progresses around the border of the search input.

@keyframes clippath
  0%, 100%
    clip-path: inset(0 0 95% 0)
  15%
    clip-path: inset(0 95% 0 0)
  50%
    clip-path: inset(95% 0 0 0)
  65%
    clip-path: inset(0 0 0 95%)

.border-progress
  &::after
    content: ""
    position: absolute
    top: 0
    left: 0
    right: 0
    bottom: 0
    border: 2px solid var(--bulma-link)
    transition: all .5s
    animation: clippath 3s infinite linear
    border-radius: var(--bulma-input-radius)

Solution is implemented in project using Bulma css framework

See it in Action

Explore More & Support Open Source

If you're looking for a user-friendly web interface to explore and manage your graph database, or you want to try this search input by yourself, consider checking out cypherGUI.

If you like it you can buy me a tea at

ThingsDB and PHP

Michal Štefaňák — Fri, 29 Mar 2024 14:25:18 +0000

Maybe you never heard about ThingsDB. Me neither until last month. First thing should be some introduction of ThingsDB. At their website you can read:

ThingsDB is an open-source Stored-State-Distributed-Interpreter (SSDI) solution written in the C programming language. It is designed to provide a powerful and scalable platform for storing, managing, and processing data. ThingsDB is particularly well-suited for applications that require real-time data processing, high availability, and fault tolerance.

I'm not going to lie, it seemed intruiging to me and I started thinking about what project I can build with it. But I saw immediately there are only few available drivers for communication besides standard HTTP API. I always prefer using socket connection because it's faster than making HTTP requests. It was the same case like when I decided to build client for communication with Neo4j (Bolt).

Fortunately they provide well made documentation and that made my job easier. It took few days and driver was working very well. I've learned a bit about ThingsDB while doing that, which gives me more knowledge for building my project around it. My driver is available at github as opensource: thingsdb-php.

Easiest way is to install it into your project is with composer. Driver is made with simple approach. You just create new instance of class ThingsDB. It will immediately connect to provided uri and afterwards you can start communicating with ThingsDB. In the beginning there is just few methods needed:

auth - most important one, you need to authorize
authToken - same as auth but this one is for token authorization
query - sending query to database
run - run a procedure available in database

The simplest example of using my driver looks like this:

use ThingsDB\ThingsDB;
$thingsDB = new ThingsDB();
$result = $thingsDB->auth();
// on successful login $result will be true
$message = $thingsDB->query('@:stuff', '"Hello World!";'); 
// $message will contain "Hello World!"

auth accepts arguments for username and password but ThingsDB default "admin" and "pass" is set as default value. Sending simple "Hello World!" is send back to us. But you can do way more.

There is a lot of stuff you can do directly in ThingsDB. Go ahead and check their documentation.

Let me show you another example using run method for executing procedures:

use ThingsDB\ThingsDB;
$thingsDB = new ThingsDB();
$result = $thingsDB->auth();

// check existing procedure, destroy it if it exists
$exists = $thingsDB->query('@:stuff', 'has_procedure(procName);', ['procName' => 'multiply']);
if ($exists) {
    $thingsDB->query('@:stuff', 'del_procedure(procName);', ['procName' => 'multiply']);
}
// create procedure
$thingsDB->query('@:stuff', 'new_procedure(procName, |x, y| x * y);', ['procName' => 'multiply']);

// call procedure
$result = $thingsDB->run('@:stuff', 'multiply', [4, 5]);
// $result will be int(20)

For simplicity of example I'm not checking every query response and also I didn't surround the logic with try catch.

If you want to see more examples, you can head to tests directory of repository.

Are you asking what more the driver can do? ThingsDB supports rooms which you can join, leave and most importantly, you can listen for emit. This way different actions can be invoked across all connected clients. Here is a set of available methods for this:

join - join room(s)
leave - leave room(s)
emit - emit an event in room
listening - Listen for incoming events

listening should be used with caution. It will pause php execution and just waits for communication coming from database. You can decide how long you want to wait for incoming message. If you run php script with max_execution_time=0, you can even wait indefinitely.

I hope you like it and will give it a try. If you do and you would like to support me, you can give a GitHub star to my repository at thingsdb-php or you can click on donate button. Even so you if you wish to support ThingsDB you can do the same at their repository at ThingsDB.

I'm also working on javascript driver (link) but there is still few bumps on the road. Hopefuly it will be resolved soon.

My passion for the world of graph databases

Michal Štefaňák — Sat, 16 Mar 2024 12:12:03 +0000

The world of programming has always fascinated me and with hand in hand goes data and databases. I used mostly relational databases in my life but when I discovered graph database my perspective changed. There's something truly special about graph databases. They offer a unique way to store data, represent and explore connections, which makes them perfect for dynamically evolving systems. That's why I'm incredibly excited to share my journey into this dynamic field!

This technology area is still developing and that opened up opportunities for me to contribute. My first major contribution is a PHP Bolt driver. This might sound technical, but it essentially allows your php backend to communicate seamlessly with any graph database that uses the Bolt protocol. Think of it as a bridge between your code and the database, enabling smooth communication. My goal? To create a low-level library that supports all Bolt protocol versions and stays up-to-date with the latest specifications. This ensures your code can seamlessly interact with evolving graph database technologies. This opened a door for others and php community can now appreciate multiple tools.

Driver is available at Bolt. Don't be confused by neo4j-php organization. Neo4j created GitHub organization for php community, but they do not provide official support. It serves as hub and you can find more libraries there.

This dedication for staying relevant earned the project significant recognition within the community. I was thrilled to receive the Graphie Award as MVP in the ecosystems, highlighting the driver's impact on developers working with graph databases.

I didn't stop there. Graph databases hold immense potential, but the Cypher query language can be a barrier for those new to the field. I wanted to make graph databases more approachable, even for those without these knowledges. Tool which will ease transition for everybody who wants to manage and administer data in graph database. I was thinking about it for few years. But then it finally happened and cypherGUI was born! This user-friendly administration tool provides a graphical interface for managing your data in graph database, specifically designed to demystify graph databases for everyone. You can view nodes, relationships, and properties – all neatly organized in tables. Plus, you can create, edit, and delete data with ease, even search across all properties. But cypherGUI goes beyond the basics. It is showing you executed cypher queries what gives a opportunity to learn it. Of course it allows you to write own cypher queries and see the results in various formats, including tables, JSON, and even in the natural way of graph databases which is a visual graph!

Project is available at cypherGUI. Recently I spent many hours on adding new features and now it gaves even more mature impression.

My passion for graph databases extends beyond creating tools. I'm actively involved in the community, collaborating with inspiring folks at Neo4j and Memgraph. We exchange ideas, provide feedback, and offer support – it's a fantastic way to stay on the cutting edge of this technology. Unfortunately I haven't yet connected with the Amazon Neptune team which means I haven't been able to provide test coverage for Neptune graph database just yet, but I'm hopeful for future collaborations!

Speaking of sharing my knowledge, I've had the incredible opportunity to present my work at conferences in Berlin, Zagreb, and even online (ex. Nodes 22, Neo4j Live)! These experiences have been incredibly rewarding, allowing me to connect with other like-minded individuals and share my enthusiasm for graph databases.

As you can see my journey in this fascinating world is going on for some time and I believe is far from over. I'm constantly learning, building and improving my tools. If you share my excitement for graph databases, I'd be thrilled for your support! My projects are available as opensource and I will appreciate if you consider giving my projects a star on GitHub, or if you're feeling generous, a donation would mean a lot to me. Every bit of support helps me to keep working on these projects.

Why Elegance in Code Takes a Backseat to Functionality

Michal Štefaňák — Tue, 12 Mar 2024 11:57:04 +0000

For programmers like myself, there's a certain allure to craft beautiful code. Lines that sing with logic, functions that unfold like origami, and a structure so clear it practically comments itself. We spend hours wrestling with efficiency, readability, and best practices, convinced that this dedication will be rewarded. But then reality hits. You encounter the behemoths of the software world - wildly successful applications with codebases that would make a purist weep.

This is certainly my experience. I meticulously wrote code, prioritizing quality and readability, sometimes even above all else. Yet, here I am, surrounded by popular programs whose functionality reigns supreme despite their, shall we say, less than stellar internal design. It begs the question: in this world of hidden code, does the pursuit of programming perfection actually matter?

The truth is, functionality is king. A program, like a car, can be a masterpiece of engineering under the hood, but if it doesn't get you where you need to go, it's all for naught. Users don't experience the elegance of your code, they experience the results. If those results are fast, reliable, and solve their problems, the inner workings become irrelevant.

This doesn't negate the value of well-written code entirely. Clean, well-documented code is easier to maintain, debug, and expand upon. But there's a balance to be struck. Spending hours crafting the perfect solution when a simpler, albeit less beautiful approach would suffice, might be a waste of resources.

So, what's the answer for a programmer caught between the desire for perfection and the pressure for results? Perhaps it's about finding the sweet spot. Writing code that prioritizes functionality while still keeping readability and maintainability in mind. Recognizing that there can be beauty in efficiency, even if it's not the striking kind.

At the end of the day, the code we write exists to serve a purpose. If it fulfills that purpose effectively, then it's a success, regardless of whether it wins any code beauty contests. The true art of programming might lie not in creating a masterpiece for others to see, but in crafting a powerful tool that silently works its magic behind the scenes.

PHP & graph database?

Michal Štefaňák — Fri, 02 Feb 2024 13:49:28 +0000

Are you a PHP developer looking to break free from the limitations of relational databases and explore the exciting world of graph databases? Look no further than the Bolt Driver, an open-source gem that seamlessly connects your PHP projects to Neo4j, Memgraph and Amazon Neptune.

Why Graph Databases Rock for PHP Developers?

Model Complex Relationships: Say goodbye to rigid schemas and embrace a flexible data structure that mirrors real-world connections. Graph databases are perfect for social networks, recommendation systems, fraud detection, and more.
Boost Performance: Experience lightning-fast query execution, especially for complex graph traversals. Handle massive datasets with ease and ensure smooth performance for your demanding applications.
Unlock Powerful Insights: Leverage the inherent strengths of graph databases to uncover hidden patterns and connections within your data. Gain deeper insights and make informed decisions that drive your business forward.

The Neo4j Bolt Driver: Your PHP Gateway to Graph Power

This open-source driver is meticulously crafted to provide:

Effortless Communication: Establish fluent connections between your PHP applications and Neo4j databases with intuitive and well-documented APIs.
Flexibility and Extensibility: Choose from various connection methods and driver configurations to match your project's specific needs. Easily extend the driver's capabilities with custom extensions.
Vibrant Community: Tap into the collective knowledge and support of a thriving community of developers and Neo4j enthusiasts.

Ready to Dive In?

Head over to the Bolt Driver repository on GitHub (https://github.com/neo4j-php/Bolt) to:

Explore the driver's features and documentation.
Get started with installation and usage guides.
Support project through donations or GitHub star.
Contribute to the project's growth and development.

Join the graph database revolution and empower your PHP projects with the Bolt Driver!