Blog

I recently read Concurrency in Go by Katherine Cox-Buday. In the “Queuing” section, there was a discussion of how we can use Little’s Law to predict our pipeline’s throughput, given sufficient sampling. I honestly wondered why I had not come across this simple idea before, after finishing that part. As I understand it, it can potentially be used in almost any situation where a queue is involved. Not just message queues, even things like physical queues. So I thought I’d write an intuitive explanation to help it stick and share the idea.

Configurations exist to allow a program to behave differently without modifying its code. You have a program, you configure it, run it, and it behaves accordingly. In a way, they are like function inputs, but at the application level. They tend to reflect and affect how a system works under the hood. This also makes them closely related to the complexity of our applications. Thinking this way, I cannot think of configurations as just simple inputs. That is why I wanted to think about this topic a bit more and write down some thoughts.

An example of an expression that returns true in JavaScript. Here, 2 + "2" becomes "22", and 2 * "11" becomes 22. In the end, "22" == 22 returns true. 🙂 I sometimes see people say that programming languages like JavaScript, PHP, and Perl do not have types. Well, that’s simply not true. Yes, these languages do not enforce types at compile time. They are also not very strict about what you can do with those types. But they still have type systems. Every value has a type during execution. I think that if we define a type as “a classification of a value that determines how it can be used and how it behaves in operations,” then we can also say that it has types. Which means almost all of the mainstream programming languages you have heard of are already typed! JavaScript already supports types like strings, lists, numbers, and so on.

Having my own homelab was something I wanted to try for a long time. However, I just couldn’t get started. Mostly because I kept overthinking it. How will I handle dynamic IPs? Do I need something like a local DNS on my router for that? Even if I solve things inside the home, how am I supposed to access it remotely? Do I need port forwarding at the NAT layer? And what about TLS certificates, how do I even manage those without using a public certificate authority?

I developed a web extension called Mark Scroll Positions about 1.5 years ago. I built it both to solve my own need and to experiment. If you are interested in how it looked and the original idea, you can check Introducing: Mark Scroll Positions. But long story short, other people started using it after I published it, even though I did not have high expectations for it. I received some comments on both Firefox and Chrome. A few users even went to GitHub and opened issues.

It has been about a year since I decided to learn Go, and more than half a year since I started working at an HFT company that uses it. This is not a very long time with the language, but some of my developer friends have already asked me about my impressions of Go. In this blog post, I want to share my overall experience with it. I will first explain why I felt the need to switch to Go in the first place. Then, I will describe what I did to learn it and how I improved over time. Finally, I will discuss my current impressions of Go, including what I like, what I do not like, and whether I would recommend it to others based on their goals.

I built my own Corne keyboard around six months ago, in July. I have been using it ever since. Although I am no expert on split keyboards, I accumulated a fair amount of observations during this whole process. I thought that if I wrote down my experiences, they might still be of interest to people who are considering whether to try a split keyboard. Or, if they are already using one, maybe they can also benefit from some of the tricks that helped me a lot. So, here it is: a blog post about how and why I built my own Corne keyboard, the things I learned and applied to improve my ergonomics over the last 6 months.

ℹ️ Disclaimer This post was written while Go 1.25 is the mainstream release. Some implementation details may change as the Go team continues to refine the garbage collector. Still, the ideas here should remain useful for building an intuition about what happens under the hood and why certain design choices exist. If you need the most up-to-date specifics, always refer to the official Go source and release notes.

Some people think having an organized environment is the result of frequent organizing. My personal journey of becoming more organized actually makes me question this belief. Yes, we can organize things at fixed intervals. However, in practice, I find it too difficult to make this effectively work. To me, the fixed intervals approach associates organizing with costs. You now have a new chore to remember when the time comes. You also keep letting disorder build up until it’s time to clean. So the work sucks more when the time comes and you become more likely to say things like “I’m so tired from work right now, I should rest and put this off.”

I think “Fake it till you make it” is very poor advice if you read it literally, and otherwise, it is simply badly phrased advice. If you take it literally, it encourages people to present themselves as something they are not. If you don’t see any problem with this, then why not phrase it more directly as: “It’s OK to manipulate others until you get what you want?” At least that wording captures the Machiavellian intent.

Around a year ago, I published a blog post explaining my overall experience Switching from Arch to NixOS. You can read it if you’re interested in my early experiences, but, to give you a spoiler, that post ends with me saying: Unfortunately, though, I don’t think the benefits I’ve gotten in this one month of using NixOS so far justified the cost I’ve initially spent and continue to spend learning Nix and NixOS. — Ultimately, whether the benefits of learning a particular technology outweigh the costs depends on how much you take full advantage of its features. So, I believe that if I experiment with more setups, try different programs, or start managing servers with Nix, I will begin to see a better return on this investment from what I have learned so far. :)

A friend recently sent me a tweet of Tsoding, a recreational programmer who creates cool videos on YouTube that I also enjoy watching. The tweet is as follows; Stop obsessing over splitting code into files. I end up grepping codebases anyway. I literally don't care where you put your functions. miniaudio.h is a single file with 92k LOC and it's fine. File is an OS construct anyway. pic.twitter.com/4zLXGrXEzA — Тsфdiиg (@tsoding) February 14, 2025 Although I don’t fully agree with him, I understand the message to some extent. That is, you can work just as efficiently in a single file as you would in a repo with split files. I agree that it is possible, especially if you are someone like Tsoding.

This essay presents a list of reflections on my attempts to create a simple workflow for building front-end applications using vanilla JavaScript. I first discuss what it was like to code when I first started programming and the things that I enjoyed about it. Then I walk through several approaches I tried in the pursuit of simplicity and also share the problems I ran into meanwhile. Later, I show how we can make use of libraries such as Hyperscript and Snabbdom to resolve those issues without giving up on our simplicity ideals.

You can quickly try the app through hnstats.rugu.dev Or, see the source code kugurerdem/hn-domain-stats I like hanging out on Hacker News, reading essays. I also enjoy submitting essays I like that haven’t already been shared there. This way, the author gets recognition and others get to read something they might enjoy too. Plus, more karma never hurts. 😀 For that, I’ve been using an extension called What HN Says. The extension basically lets you see whether an HN discussion already exists for the page you’re viewing. If it does, it lists them and lets you open them in a new tab; If not, it makes submitting the link easy by opening the HN submission page with the title and URL prefilled. Despite being a simple app, I’ve been using it for a while and enjoying it.

I frequently come across people thinking, ‘Why bother learning something if AI will do it better than me in the future?’ Alongside this thought, I also noticed a rise in pessimism. I believe this pessimism originates from three misconceptions: (1) overlooking the difference between instrumental and intrinsic value, (2) underestimating our ability to adapt to change, and (3) losing sight of what essentially matters. Focus More on Intrinsic Value Some things need to be done by specifically you. Not because they can’t be done by other beings, but because they are good for you when you do it yourself.

For me, whether AI can be beneficial or not is out of the question, and I am not here to discuss that in much detail. I already heavily use tools like aider (a terminal-based alternative to Cursor), autocompletion assistants such as copilot, and conversational LLMs like claude, chatgpt, and deepseek all the time. So, I truly believe there’s immense value these tools can provide, and I’m not here to discourage anyone from using them. They’ve already proven their worth to me in many ways.

I can’t remember when I truly realized the power of writing. But as far as I remember, I’ve been trying to use writing as a tool for putting order to the chaos in my mind since high school. Currently, I have a diary with about 325 pages (assuming each page consists of 500 words). And there’s probably at least an equal amount other writings I wrote for different purposes but deleted in the end. The first entry dates back to 2017, meaning I’ve been writing regularly for around 8 years. That’s a lot of time, but I don’t regret a single moment. Because I know for sure that the positive impact writing has had on my mind far outweighs the effort.

I recently wrote a short essay called Linux Asceticism, and it got a lot of attention on platforms like Hacker News and Reddit. I also received an email from Brodie Robertson, telling me that he would soon release a video on his main channel about my essay. He also invited me to be a guest on his Tech Over Tea podcast series. It really surprised me to see a Linux content creator that I was already following not only featuring my essay but also inviting me to his podcast to discuss it. Despite not trusting my English speaking abilities as much as my writing, I told him I’d love to be a guest. I shared my concerns about not being very fluent in English and wanting to prepare beforehand. We briefly talked about the podcast format, and the topics we could cover, and set a date for the recording.

I’ve been using NixOS for about six months and am generally satisfied with my experience. However, in this essay, I won’t talk about how great NixOS is, but rather about one common issue that many users, including myself, have faced or will face in the future. In NixOS, most pre-compiled programs will not work out of the box. In this essay, I’ll share my experiences on this issue and explain why it happens, along with some approaches I’ve found very helpful to overcome it. Hopefully, this will help others avoid some of the frustrations I’ve encountered.

Most well-known living philosophies -such as Cynicism, Epicureanism, Stoicism, Buddhism, and Sufism- advocate some form of Asceticism. This could involve various acts such as fasting, deliberately confronting personal fears, or even something as subtle as choosing not to pour salt on food. But regardless of the specific way that these practices are pursued, the main goal remains the same: Strengthening your body and mind to make yourself indifferent to and indifferent from the things that are outside your control. That is to say, turn yourself into someone who can handle hardships with as few possessions as possible.

When you interact with a text file using an editor, what you see doesn’t necessarily reflect the data stored in the file. Sure, the contents of plain text files are byte codes encoded in formats like ASCII, UTF8, or UTF16, and these byte codes are the ultimate source of truth. But in the end, it’s still your text editor that chooses how to interpret and represent that ultimate source of truth - binary codes into something recognizable to you. This means that two different files could look the same, or the same file might appear differently depending on the editor(s) you use.

When we encounter new information that conflicts with our current beliefs, we typically follow one of the preceding options: Ignore the new information. Place it into your existing belief system, regardless of whether it is consistent with your other beliefs. Create an ad hoc explanation to keep our beliefs intact. Adjust or revise our existing beliefs. Since the last option is typically the most demanding, and humans are programmed through evolution to conserve energy, people usually choose the first two options unless the information is crucial to their survival.

Up until now, I was not aware that concurrency and parallelism were actually different things since they are often used interchangeably by some. I just learned that this is not the case while reading Chapter 9 of the book “Clojure for the Brave and True.” This made me want to learn more about concepts related to concurrency and parallelism, especially concerning the programming language I know best: JavaScript. So this essay is basically a collection of notes I made during this learning process.

In this essay, I share some tips that I’ve found particularly beneficial for my own debugging experience. Hope it helps the reader as well. If you have any cool tips you’d also like to share, feel free to share them. I might include them in the essay and give you credit for it. Writing Logs to STDERR I’ve noticed that developers, myself included, often instinctively write debug logs to STDOUT. While this might not cause problems if the program’s output isn’t intended for other programs to consume, it becomes crucial when managing multiple scripts that depend on each other (such as when one script writes to a file that another reads).

I’ve switched my desktop computer environment from Arch Linux to NixOS and used it for about a month. I want to share my migration experience in case it might interest or even help others. I also want to thank my friends Onur and Mert for encouraging me to switch to NixOS and providing help. Why Migrate from Arch in the first place? As someone who likes playing with tools to understand how they work as well as to match my preferences and ergonomic choices, I find myself frequently changing many configurations on my system. However, it didn’t take long for me to realize that I need a system to save and possibly automate these configuration processes to save time in the future.

ℹ️ Disclaimer This post was written when Mark Scroll Positions was first built. Since then, it has been modernized by a lot, and the application does not look as it’s been showcased in here. Still, the ideas here should remain useful for building an intuition about how it works. Try the extension in Chrome or in Firefox See the source code kugurerdem/mark-scroll-positions I like reading blog posts a lot. While some of them are short and easy to read, most of them are long and require more time to finish. When reading those long essays, I take a break most of the time. Thus, when I re-open an essay, I often lose the original place where I was reading. And if I can remember where I was, then I manually scroll back there. This makes the reading experience less smooth and more time-consuming.

A significant amount of my time of the day is spent interacting with computers and cell phones. Some of these are due to habits (like having a feeling of missing out), some are due to reasons related to dopamine (like watching movies, tv-series or content which are supposed to be fun), and some are related to work (software development) or productivity (writing, communicating, researching). So, I am regularly exposed to all kinds of stimulants that are available on the internet.

I usually enjoy listening to certain types of ambient music or sounds when doing repetitive tasks or even when meditating. In the comment section of these kinds of videos, there are often people spreading love and writing nice things to each other. After consuming so many videos of this kind, I’ve started to predict that these kinds of comments would be present in a video even before opening them. Sometimes, it felt like I was reading those comments without even opening them.

My mother recently mentioned that her phone is continually opening certain windows and prompting her to use services she doesn’t need. After checking her phone and doing some online research, I found out that many others have also complained about this issue. Apparently, she was referring to pop-ups triggered by a pre-built program called “SIM Menu”. This program basically allows operators to send notifications and even generate pop-ups on your phone. And the frustrating part is that most of these pop-ups seem to promote irrelevant services. If you accidentally click “OK” when one of these pop-ups appears, you get charged by your provider. It is a carefully set up trap designed to make you accidentally subscribe to their unnecessary services and pay money.

For those who may not be aware, Neovim is to me what a lightsaber is to a Jedi. It forms an essential part of my routine, as I use it for nearly all my tasks involving text. Be it drafting an essay, sending an email, or coding, Neovim is my go-to tool. Moreover, I have a deep admiration for the UNIX philosophy and its command-line interface programs. It’s quite fascinating to observe how these small, uncomplicated UNIX programs, designed to do one thing flawlessly, interact effectively using piping mechanisms. Tools like sed, grep, awk, count, cut, and many others, often prove to be incredibly useful for text processing.

In this essay, I describe how I made a Node.js module to listen to keypresses across the system on Linux machines using X. This experience helped me grasp how the OS and Window Managers handle keyboard inputs, clarifying the reasons behind an unexpected behavior I had encountered before, which I also mention in the essay. If you’re interested in learning more about how keyboard events are handled, this essay might be of interest to you.

I’ve recently been involved in a fintech project that demands high performance, posing various challenges related to a solid understanding of low-level concepts, concepts that are primarily relevant to the inner workings of the tools and protocols used beneath the surface. One challenge involved separating two tasks into different processes: The main process, responsible for constructing the necessary business state from incoming messages through a specific socket connection. The monitoring process, allowing users to track relevant changes in the state.

This blog post is a review of my journey into software development up until 2023-09-22. It is not intended to be a series of detailed explanations/guidelines for my career choices. Consider it more like personal reflections on events that shaped me as a developer. So, take the things that I say here with a grain of salt. My First Introduction to Programming I used to hang out with my cousin a lot when I was around 6 or 7 years old. He would always develop something cool whenever I saw him using his computer.

Typing Fast is Important It is often mentioned that the bottleneck in building software projects is not one’s typing ability but ability to think clearly, and to design the architecture effectively. Afterall, if typing speed was so essential to programming, the time difference between rewriting an already existing project with that of creating it from scratch would not be as high as it is. While I agree that typing speed is not essential to programming, I cannot relate on how this fact is used by lots of people to justify their thinking of typing fast being not important for the development process.

About a year ago, I was invited to a pair coding session at the startup where I was working. The developers were receiving consultancy from a strange person. At one point, he took control of the screen sharing while reviewing some of the pull requests that had been made to our codebase. When he shared his screen, there was nothing but a black screen. Suddenly, a terminal screen appeared with his keystrokes and he quickly began examining the codebase, providing feedback on people’s code at a speed I had never seen before. He was able to jump between different files in an instant, examining the diffs that were made in different git commits.

This essay was originally written for the ‘Introduction to Philosophy I’ (PHIL103) course at Bilkent University, where we delved into various branches of philosophy, including consciousness. It reflects some of the thought processes that arose as I grappled with these philosophical questions. It’s important to note that this essay is not an exact reflection of my personal beliefs, but rather an exercise in argumentation. Despite this, I believe the arguments presented in this essay hold value and are worth exploring. My hope is that this essay provides you with insight and provokes thought, and that you find value in engaging with the ideas presented here.