DEV Community: Kiolk

Small Thing, Big Impact

Kiolk — Fri, 27 Feb 2026 20:18:55 +0000

Original by author

I will tell about a very obvious topic: trailing comma. Maybe many of you handle this and now even care about it, because it looks very natural to put a comma after the last parameter when you define a function or a class, or call them in the code. It is just my self-reflection, and I try to formulate and finalize this moment for myself.

Trailing comma is the basic concept now, but we need slightly back to understand why it rise. First programming language where comma as separator allows in syntax count the first version of Perl designed by Larry Wall (December 1987). It wasn't directly mentioned in documentation, but this syntax didn't cause any problem. It was explicitly documented only in Perl 4 (1991).

After this trailing comma step by step as a concept start appears in many languages, in most cases in limited scope (Python, Ruby, JavaScript, C#). This picture quickly change after invention Git in 2005. With increasing popularity this version control system, trailing comma transformed just from syntax convenience into a team collaboration optimization which allow small diff and less number of merge conflicts. Since this time most of modern languages have support very wide trailing comma (Go, Rust, Swift, Kotlin, TypeScript) or added limited support (C++, PHP).

Trailing comma make diff small. Original by author

Interesting fact, that trailing comma is very limited present in Java. From Java 4 it is allowed in enums, and from Java 8 in array initializers and annotation arguments. In Kotlin trailing appears from version 1.4 (2020).

Timeline of Trailing Comma Acceptance in Programming Languages. Created by NANO BANANO

So, why should we use a trailing comma when we write the code? To be honest, nothing forces us to do this. It does not matter whether we do or don't do this, our code will be successfully compiled and the program will be executed. The problem arises when we start working in a team on the same code base, especially when we try to do some stuff in parallel. Simple changes like adding new parameters in the constructor can cause a merge conflict in a place where it shouldn't be present logically, because this parameter itself doesn't conflict with the existing logic, or the logic was changed before. And this is really time wasting: solving merge conflicts, rerunning pipelines, or just switching branches on the local machine takes time (stashing progress, switching the branch itself, syncing the project, etc.).

If you don't care about trailing commas in your project, I am pretty sure you will face this problem many times on a repetitive basis.

The solution for this is very simple: just enable ktlint to force it to treat a missing comma as an error, and block the ability to merge a PR if this issue appears.

To make this rule obligatory for every team member, you should configure the .editorconfig file properly, which will be stored under version control and synchronize the configuration. You couldn't miss this, because these rules are enabled by default and will be active after ktlint configuration. If you want to mark this explicitly, you can add flags in the .editorconfig file.

…
ij_kotlin_allow_trailing_comma = true
ij_kotlin_allow_trailing_comma_on_call_site = true
…

As you can see, treating missing trailing commas is defined by two flags. One of them, ij_kotlin_allow_trailing_comma, is responsible for the trailing comma in declarations (constructor parameters, function parameters, etc.). The second one, ij_kotlin_allow_trailing_comma_on_call_site, is responsible for the trailing comma in calls, when we invoke a constructor, function, etc. In Kotlin code style, it is strongly recommended to use a trailing comma in declarations, but for calls it depends on team convention.

Trailing commas are entirely optional — your code will still work without them. The Kotlin style guide encourages the use of trailing commas at the declaration site and leaves it at your discretion for the call site. Kotlin coding conventions

I personally prefer to use trailing commas in both cases for consistency and for preventing merge conflicts, which I mentioned above. After ktlint configuration, you can simply format the entire codebase to add trailing commas in every place where they should be, using the simple command ./gradlew ktlintFormat, which does this for you automatically, and you can store all changes as a single commit. I would recommend doing this quickly and forcing the entire team to rebase on develop, because at the start it can lead to several merge conflicts when teammates pull the latest develop, especially if there are branches with a long history.

In addition to ktlint, you can enable adding the trailing comma as part of formatting behavior in Android Studio. Go to Settings → Editor → Code Style → Kotlin → Other (tab) → enable Use trailing comma. After this, every time you reformat code with Option + Command + L, a trailing comma will be added in the right place. By default, the trailing comma will be added only in declarations, but if you want to add it at call sites, you should add ij_kotlin_allow_trailing_comma_on_call_site = true flag in the .editorconfig file.

Another case where it is very useful is when we have several parameters and in one of the moments we need to sort them for any reason (I use keys: Option + Command + Arrow Up/Down). If this sorting operation involves the last parameters, in most of the cases it causes an error. It is easy to fix, but takes time to navigate and type.

Sorting parameters with and without a trailing comma

Also it makes code more consistent, where every line in the list of parameters looks similar, ready for future modification or even copy/paste.

The trailing comma itself does not affect the final compiled code and can be safely added to any project. It is a small improvement, but it makes your code more convenient and less prone to merge conflicts.

It is done, I finalize this question for myself, and will use this article as reference next time, when adding some proof for the need to use trailing commas in Kotlin code.

Developer Diary #33. Limitations

Kiolk — Thu, 05 Jun 2025 14:11:21 +0000

Over the last several years of my development career, I’ve often found myself forgetting how to do something I had successfully built just a few weeks earlier. Sometimes it’s a basic task; other times it’s specific syntax of a programming language.

It’s not a joke when you need several minutes on Monday to understand the code you wrote on Friday.

All of this points to one thing: the limitations of our mental capacity.

The human brain is a complex system. We cannot store more information than it can handle, and many factors influence how we remember things.

One major factor is age. When we are young, we can absorb a lot of new information. But as we get older, we lose some of that ability and need to put in more effort just to remember what we once learned easily.

In combination with the rapid growth of AI and ever-evolving technologies, it no longer makes sense to memorize every implementation detail. We simply don’t have the capacity for it.

Instead, we should focus on developing the skills to work with the tools that can perform these tasks — efficiently and accurately.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer Diary #32. HONY

Kiolk — Sat, 26 Apr 2025 19:52:41 +0000

Today I found an interesting thought that resonates with me and has fundamental significance. The author of the book “Humans of New York” shared how he reached the Idea of compiling photographs of strangers alongside their stories. This concept isn’t the result of pure inspiration; it is the result of almost five years of experimentation, practice, and trying different ideas. The final result is a good book with nice photos and very natural short stories.
This is a very good illustration that any idea to be great should past through evolution though iteration, practise, experimentation, and feedback loops. Our experience and ideas are just part of the result; the second part is practical, when we get our hands dirty.

This is suitable for many cases in our life, not just for projects. For example, when we set a goal to become a good and skilled developer or reach a senior level, we create a plan or roadmap of actions that we should follow to reach the final result. This is just a starting point; the real path involves a lot of practice, reading articles, completing tutorials, and finishing tasks. Working on that on a regular basis, analyzing our own and external feedback, we can achieve results that are different from our initial imagination.

Practice, practice and practice is the real path to reach the goal and shape the final result.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer Diary #31. Prompting an Android Application

Kiolk — Tue, 22 Apr 2025 18:39:04 +0000

Over the past few days, I’ve frequently seen posts about a new tool — Firebase Studio. It positions itself as an AI tool for faster prototyping. As usual, you write the prompt and get a result that you can publish and share with colleagues and friends. What caught my attention was the support for Android Studio, so I decided to try it.

I was surprised to see how it loads a virtual Android Studio and mirrors the regular interface in the browser. Just running this setup virtually takes around 30 second, and the result is an Android Studio instance with the Gemini plugin preinstalled and configured for the project. It’s not bad, especially if you want to quickly develop something on a slow machine — but it’s not the kind of setup that gives you the vibe or speed for fast iteration. The Problem isn’t with this tool — the issue lies in Android development itself, which requires a lot of resources, time, and addition tools that slow down the process.
It seems that building a mobile application solely through prompts and then improving it through prompting is not in the nearest future. Because it isn’t possible to achieve this without improving and simplifying regular mobile development. We can only speed up specific parts of development, for example, routine tasks, mocking specific screens, or solving particular business problems. This is a good article with examples of that point.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer Diary #30. Training Skills in Using AI Tools

Kiolk — Mon, 21 Apr 2025 20:04:42 +0000

I wrote several developer notes about AI and how it is changing our lives. Today, I want to formulate and share some basic ideas on how we can improve our AI usage skills in everyday life. Using AI tools has become as routine as using a mobile phone, and it has penetrated all spheres of our life. AI tools boost our productivity, but like any tools, we should use them correctly and efficiently. Once we use any AI tools, we tend to think we are experts, but we should train them like any other skill.

In one tech podcast, I heard a good suggestion: practice using AI tools at least 15 minutes every day. The main focus isn’t just on usage, but on thinking: how can I get some particular task done using AI? Identify a problem that can be solved with AI, find the right tools for it, and finally, implement it in practice. For example, I often need to create models that are for parsing JSON. The simplest way, just write a prompt and add JSON that need to convert and copy the output code and paste it in the correct place. Where is the possible optimization here?

First, this task is not unique, it is repetitive task, you can do it at least several times when you work on one project. As a result, you should write almost the same prompt every time. It is very complicated to get optimal result from the first time, it means that you should do several iterations because you get on expected result. After that, you can find out how the desired prompt should look at the initial step. As output of this work should be not only several classes but good structured prompt to get this result, and it is essential about what you care when you reach the goal. You should store structured and store this prompt for future using.

Second, you should use relative tool for specific task. The described result you can reach by regular chatbot, but it looks logically to use a specific IDE or plugin for this to reduce copy-paste work. What is the best for specific task, you can find just by practicing and playing around with different tool.

What is the key thought of all this, you shouldn’t think about using AI to get a quick result only, you should think as architect: What problem are you solving? What way are you doing this? How can you use it in a suitable and scalable way? You and I should not just use AI by training our skills in using it, and the right way do this by practice and in regular base.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer Diary #29. Time for Change

Kiolk — Wed, 19 Mar 2025 22:33:39 +0000

After the rapid growth of the tech market during COVID, when the demand for developers increases, the recent decline in demand was unpredictable. Several factors are responsible for this. After the shock of COVID and the recession, the rapid growth of AI tools, especially for developers, along with the strong trend of optimization and cost-cutting, are key reasons for this. It is not just a trend; it is our new reality. If you want to be a developer, it is not enough to just desire it; you must compete for your place. If you want to advance as a career leader, you should not just grow as a specialist; you must do and demonstrate more. You should change your way of growing and think differently.

I found a cool diagram that shows developers’ competence and their value in the current reality. I don’t know what data it is base on, but it matches my feelings. Hard skills are just foundation and the minimum requirement for any developer. Being a smart developer and knowing a lot of technical skills isn’t a limitation to growth as a developer. Now, you have access to that data through many AI tools. To do something outside your domain, you don’t need solid expertise; you just need basic knowledge, and with a broad set of tools, you can solve almost any problem. However, you should know how to use the tools.

How can you be more competitive in the current market and add value to your expertise? I have several ideas and insights relevant to the current moment. I am following them as I plan my growth as a specialist.

Grow your own developer brand.
Your expertise is a product that you sell to the employer. The value of this product is more visible when you work as a freelancer, and your portfolio is a tool to find good projects. At a time when many developers are looking for jobs and the number of open vacancies is low, it is crucial to be visible and recognizable among many similar, well-crafted CVs. How can you become more visible in this situation? Building your own developer brand is one solution.

What is a developer brand? In my opinion, it is your visibility as a developer beyond your CV. If you haven’t done anything in this direction, your visibility isn’t broader than a short text in the CV. You can check the value of your own visibility just by googling your name. I’m sure most of the link will point to different social media platforms if you are active on them. What about other materials that can present you as a developer? How many references are there on presentations, YouTube videos, or blog posts? Do you have your own blog? What about your reputation inside the local community that doesn’t rely on links?

All of these are key components of a developer’s brand and visibility. At the same time, it is not an MVP or a small product that you can build in a month. It is an idea or goal that you keep in mind and align your activities with.

Be Pro And Active
This idea is tightly connected with developing one’s own brand, but is more focused on actions and communication with the community. You should not just be a consumer of content but also contribute by creating something in response, making yourself more visible.

To be active means doing something that is greater than zero. Why is it important? Because anything greater than zero can produce a result, increase revenue, or cause an unexpected combination of circumstances in the future. What counts as an action? It can be anything: writing a comment on a podcast you listened to, providing feedback or asking questions, creating an issue with a description of a problem or a suggestion, or event asking questions at an in-person technical meeting. Other activities depend on your environment: participating or volunteering at a conference, writing articles, or creating content for a media platform. All of this acts like throwing stones into a pound; it causes waves on the surface of the water that can eventually multiply into something bigger.

Equally important is being a professional in a specific area. Firstly, you should focus on your main role and strive to be an expert in it. Activity in this area should be a primary goal.

Study AI
AI is a hot topic right now, and you should study its main concepts to stay relevant. This doesn’t mean you should completely switch your focus, but you should be familiar with it. In the near future, we will work not only on coloring buttons but also on integration of LLMs into our codebase. I remember an interesting presentation by a developer from Google Keyboard. He presented different ways they integrate new features with AI into keyboard application.

AI isn’t just about chat and image generation; it is much broader, and we, as developers, should know how it works. There is a lot of material on this topic. I am currently taking a course on AI agents on Hugging Face. The first part contains a good introduction to the topic.

Alongside AI tools available for developers, there are many resources you can use to build and prototype your own ideas. Now, you don’t need detailed knowledge of backend development to use models in a mobile application. You can use a serverless solution to integrate models. One option is Firebase, and another is Google AI Studio, both of which make this process especially easy.

Care About Value
The last but not the least point for growth and change is the relation to value. The value of any action or activity you do is important. This applies to all actions, whether personal or work-related activities. You should care about the value you will get as a result.

This seems obvious, but we often forget about it and focus only on the process. In software development, this is very valuable: the final result for customers and users is more important than just using modern frameworks and caring about perfectionism in the codebase. More important is thinking about the result you deliver than just completing the task in Jira. Maybe it comes with experience when you understand the value of time and the importance of not how you do something, but what you achieve as a result.

Thinking about the result is important in personal life too. Doing something efficiently or just caring about it is like doing something on a deeper level. This soft skill helps you to be more preferable to an employer, especially if he is the owner of a product or a startup, where results matter.

Conclusion
I like comparing the growth of AI to the invention of the book printing in medieval times. The handwriting of books, as well as the people who did this, became extinct in the following century. The honored position of the hand writer was replaced by the average role of a book printer in a small printing workshop. I feel the situation in the market develops in the same manner, and the role of the developer shift in the direction of a regular factory worker.

We cannot change this trend, but we can be more competitive, skilled, and creative. All of these suggestions are obvious, but they require effort and determination to implement. The current situation is challenging, and we should work hard if we want to move forward, grow as developers, and reach our goals.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer Diary #28. Wonder AI

Kiolk — Mon, 10 Mar 2025 23:59:23 +0000

I want to share with you an inspiring moment that happened to me yesterday. For one of my internal projects, I needed a simple jingle for a podcast about books and reading. I know there are several resources that specialize in such services, but I decided to use AI tools to generate music. Many sites advertise generating music from text prompts; I just chose one from the middle of the search results. My prompt was a very simple, "I need a jingle for a podcast about books". This service offered several free credits, enough to generate two tracks. The generation process took around 1 minute and resulted in a song with lyrics. I expected, no, I didn't expect any valuable result, but I was really surprised when I listened to this:

Firstly, I was surprised by the quality of the music and voice. I enjoyed it the first time I heard it. I recognize music that resonate for me. This is a superb result and 100% meets the prompt. Secondly, the lyrics have a very deep meaning and fully describe the topic. Every part of the song can be used as a separate piece to make the podcast sound more diverse.

Flip the pages hear the sound of time
Stories weaving words that climb
Whispered tales in a cozy nook
Welcome to the magic of every book

Bookshelf babble take the stage
Turn the chapter fill the page
Laughter wisdom stories to spare
A podcast world where books are everywhere

From paperbacks to leather spines
Mysteries thrillers and classic lines
Stories crackle voices ring
Dive on in it’s a podcast thing

Adventures waiting just one word away
From Austen’s romance to Hemingway
Gather ‘round it's the bookish delight
Unfold the tales under podcast light

Bookshelf babble take the stage
Turn the chapter fill the page
Laughter wisdom stories to spare
A podcast world where books are everywhere

So pull a chair and bring your ear
Bookshelf babble is right here
Through every genre chapter and hook
We’re talking life one book by book

Lastly, the melody is very memorable, but I don't recognize any popular songs that were used as a base for this. I'm not an expert in music, but I feel this song has an uniqe sound. I tried to check its originality with Shazam, but it couldn't find anything similar.

I'm very surprised by the result. The quality of AI models that used under the hood of these types of services is very impressive. Additionally, I wonder how it reduces effort I would otherwise spend to achieve the same result. I know, this approach has limitation but for some task it is very suitable. It really unlocks our creativity when we think not about how it's made, but what we want to create.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer Diary #27. AI Trap

Kiolk — Mon, 03 Mar 2025 22:28:59 +0000

Over the past year, I’ve tried different tools based on AI. I used it for code review in pull requests. I explored some IDE tools and used AI for code generation by prompting. Of course, I also experimented with several chatbots from the major players in the market. I found it quite enjoyable, especially at the start when you prompt and get results almost immediately. It reminded me of the excitement I felt when I first created my own “Hello world” program, though I also remember what came next. I had several pet projects with messy of spaghetti code, where all functionality was placed in one class. I think AI models perform better than I did at my first attempt, but it’s still so painful to understand such code. It becomes doubly complicated when working with unfamiliar technology. I know the approach to understanding; I should go back to the beginning and proceed step by step, but it feels like writing the program by yourself.
They asked an AI engine to recreate “a salmon swimming down a river”, and here’s what it guessed it would look like. Tread in Reddit

Another issue with these tools is their lack of accuracy. When you write code regularly, you do this through iteration. Any problems with code appear during development, such as compilation errors or crashes during execution, etc. However, generated code mostly works, but the big question is validating this work. You should properly test it. Unfortunately, you can find many incorrect pieces of data at this step.

Personally, the efficiency of these tools lies in solving small, concrete tasks that can be simply described in one or two sentences when you have a clear vision of what you expect to get as a result. It is important for quick validation of output. These tools are extremely effective for solving boring and typical tasks, such as creating a mapper or model base on JSON, etc. I like to use it as an alternative to searching and googling. Now it is a new standard for looking for information; you don’t need to spend a lot of time trying to extract information from different resources. Sometimes, when someone asks me for help and the answer is very clear, I want to ask: “Did you try to find the answer in ChatGPT?”
Cool service, Let Me Google That For You
AI tools are very powerful, but we should avoid becoming dependent on them. The value of our existing experience is increased, and we should care more about our skills in troubleshooting and problem-solving. Stay focused and don’t fall into the AI trap.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer diary #26. Remote Test Lab

Kiolk — Wed, 05 Feb 2025 23:44:13 +0000

Today, I worked on a floating bug that reproduces on a QA device but doesn’t appear on mine. I tried multiple devices, ran the application on both an emulator and a simulator, and also tested on an iPhone. The result was the same everywhere - the bug didn’t reproduce.

My main assumption was that this is a device-specific behavior. To prove it, I needed to run the application on the exact same device. Fortunately, the device model isn’t rare - it’s a Samsung S24.

I decided to try a service that Samsung provides for testing applications on real devices. It is a great tools for checking the functionality of Android applications on popular Samsung devices. Additionally, the service offer nearly 2.5 hours of free usage daily, which is enough for this type of testing. The portal has an intuitive interface that makes it easy to interact with the device. You can easily install your application by simply uploading APK file. You can also remotely connect to the device, debug it, and retrieve logs. It is a very useful service, and I appreciate Samsung for providing it.

I installed the latest version of the application on the same device mentioned in the issue description and ran it. The bug didn’t reproduce. While this is not a reason to close the ticket, it does require further investigation into the device settings and surrounded environment. The Issue remains open, and the investigation is ongoing.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer diary #25. Communication

Kiolk — Tue, 04 Feb 2025 22:33:00 +0000

Communication is a very important soft skill whose value has increased with the exponential growth of AI tools for developers in the last several years. Good hard skills alone are not enough to guarantee a good position. Today, you should be flexible and willing to step outside your main domain to solve a wide range of problems. Additionally, you must be actively involved in communication with customers and project managers.

How can you train soft skills in communication? I want to share my exercises that have helped me improve in this area.

Improving writing skills. A great way to train yourself to correctly formulate your thoughts while aligning with English grammar is through writing. Try to practice not only when necessary, such as writing documentation or to responding to work emails, but also regularly: write blog posts, comment on articles, or simply keep a diary.
Participating in speaking club. Join a reading club, start you own community on Clubhouse, or use an online app to practice English with others. These are excellent ways to improve your ability to keep conversations alive and engaging for participants. Additionally, such exercises are especially useful if you are shy about public speaking.
Managing a children’s sports club. This may not be suitable for everyone, but if you have the opportunity to be an assistant coach for a children’s sports team, don’t miss it! Children are very different, and you cannot use the same approach for everyone. You must analyze and adjust your methods. Motivation and positive feedback are essential in this kind of communication. Additionally, you may encounter many conflict situations that you will need to manage.

These are my exercises that have helped me improve my communication, conflict resolution, and management skills. They are not easy and require stepping outside your comfort zone. However, this is critical for growth - both in speed and quality. As a bonus, you will gain new experience and have a lot of fun! How do you develop your communication skills? Feel free to share your tips in comments.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer diary #24. Refactoring

Kiolk — Fri, 24 Jan 2025 21:41:32 +0000

I’ve spent several hours refactoring my Flutter code. Why did I do this? The key reason was the complicated existing logic. My code seemed like a spaghetti, with dependencies leaks through specific layers. The main reason why it happened was the use of new libraries, and I was focused on implementation rather than the quality of the code. In the face of new functionality, I felt real fear because I understood it would be complicated.

I decided to refactor my code by focusing on layers of responsibility. First of all, I extracted several interfaces with clear boundaries of their responsibility. I did this in parallel with existing code to avoid large refactoring when nothing working. I did this step by step. At the same time, I kept the part clear that should be variable and will play a role as a different strategies. For the creation several objects, I selected the builder pattern for clarifying creation.

As a result, I got a clear code with lower coupling and clear division by layers of responsibility. I wondered how easy It was to add new functionality. I just added a new strategy and implemented the required functions. It will be so easy to add new feature in the future. Refactoring is an important part of the development, especially, when you focus on adding new functionality. My code isn’t optimal; I think, I should do an additional round of refactoring to make it better. It should be an iterative process.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.

Developer diary #23. Chip War

Kiolk — Mon, 20 Jan 2025 17:18:45 +0000

I’m fascinated by the book “Chip War”. I haven’t completed it yet, but I’m thrilled by the first part. This book was written by Chris Miller and was first published in 2022. The author, in a simple and interesting way, shows a brief history of the development of semiconductors and how new technologies, companies, and products were founded, grew and went bankrupt around it. I found out a lot about the current state of this industry and how it came to be.

There are several ideas from this books. The cost of innovative tools for producing new advanced chips is so high that it isn’t profitable. As a result, many companies decided to stop investing in it. I got a clear explanation of why Nvidia chips are the best at the moment, but they don’t fabricate them; they just order them.

This book is pretty good. I recommend it, especially for developers. It helps to understand a new abstraction layer on top on the technologies we work with.

You can find me in X, GitHub, medium or LinkedIn. Thanks for your time and see you in next post.