DEV Community: İbrahim SEZER

The Day the Internet Died: What kind of world would digital silence bring about?

İbrahim SEZER — Fri, 30 Jan 2026 15:25:58 +0000

If the world were to wake up to a morning without the internet, the first sensation would be a deafening digital silence—like blood draining from the veins of the modern age—followed immediately by global panic. As the instant data flow of stock markets is cut off, financial systems would lock up in seconds; the fear of empty shelves would loom as logistics networks collapse, and everyone from ships in the middle of the ocean to couriers in city traffic would lose their way and drift into chaos as GPS signals became useless. While the noise of social media is replaced by the rumor mill born of uncertainty, people would pour into the streets in the void created by screens that no longer light up with notifications, driven by the desperation of being unable to access their funds or hear from distant loved ones. Yet, amidst the dust and smoke of this technological apocalypse, humanity might remember the long-forgotten reflex of "knocking on a neighbor's door," entering a process of reacquaintance that is slower and harder, but inherently much more physical and mandatory, forcing us to look into each other's eyes instead of the cold light of a screen.

This digital silence would bring with it a shattering identity crisis within the individual's inner world; as "like" counts and filtered lives suddenly lose their meaning, people would face the nakedness of being unable to hide behind their digital avatars. Our attention, constantly fragmented by a stream of notifications, would give way to a jarring necessity for focus; minds going into dopamine withdrawal would be forced to rediscover that boredom is actually the seed of creativity and genuine conversation. As no one lives to eat or travel just "so others can see," but rather to experience it for themselves, social status would vanish from virtual vitrines, transforming back into a human condition based on trust, verbal communication, and eye contact—slower, perhaps, but far more authentic.

Over to You
Now, I turn the question to you. If we pulled the plug tomorrow, what is the very first thing you would do? Would you panic, or would you feel a strange sense of relief? And perhaps the scariest question for us developers: How would we survive without access to documentation or Stack Overflow?

Share your "offline survival scenarios" in the comments below!

How I Built a High-Performance CS2 Leaderboard Using Antigravity & GitHub Actions 🚀

İbrahim SEZER — Sat, 24 Jan 2026 14:08:57 +0000

As developers, we often over-engineer. We reach for React, a Node.js backend, and a PostgreSQL database before we even define the problem. For my latest project—a Counter-Strike 2 Leaderboard—I decided to go the opposite way: Lean, Mean, and Blazing Fast.

I wanted to build a platform that tracks player stats, rankings, and match history without paying a dime for hosting or managing a heavy backend.

🚀 Live Demo: ibrahimsezer.github.io/cs2-leaderboard

💻 Source Code: github.com/ibrahimsezer/cs2-leaderboard

🧐 The Challenge: Dynamic Data on a Static Budget
Leaderboards are inherently dynamic. Ratings change after every match. Usually, this requires a database. However, I wanted to leverage GitHub Pages for hosting.

The solution? Treating my repository as a database using JSON and automating the "write" process with GitHub Actions.

🛠️ The Tech Stack

Frontend: (React + Tailwind CSS + Vite).
Backend : Python for data parse.
Steam WEB API
- steam documents : Check it out
IDE : Antigravity
Data Storage: Structured data.json files.
Automation: GitHub Actions for scheduled data fetching.
Styling: Custom CSS with a "Steam/Valve" inspired aesthetic.

🎨 UI/UX: Designed for Gamers
I wanted the leaderboard to feel like an extension of the CS2 game menu. This meant high-contrast typography, dark themes, and subtle gradients.

Responsive Design
Gamers check stats on their phones during match breaks. I used a mobile-first approach to ensure the tables scale beautifully on any device.

⚙️ How It Works: The "Static-Dynamic" Loop
The magic happens in three steps:

The Data Fetcher Instead of the client (the browser) calling heavy APIs, a GitHub Action runs on a schedule (Cron job). It fetches the latest player data and updates the leaderboard.json file in the repo.

for workflow update-stats.yml

name: Update Stats & Deploy to Pages

on:
  schedule:
    #- cron: '0 */12 * * *'
    - cron: '0 */6 * * *' 
    #- cron: '0 0 * * *' # Her gece çalışır
  workflow_dispatch:      # Manuel tetikleme
  push:
    branches: ["main"]    # Kod değişikliği yaparsan da tetiklensin

permissions:
  contents: write
  pages: write      # GitHub Pages'e yazma izni
  id-token: write

concurrency:
  group: "pages"
  cancel-in-progress: false

jobs:
  # 1. GÖREV: Verileri Güncelle ve Build Al
  build-and-update:
    runs-on: ubuntu-latest
    steps:
      - name: Depoyu Çek
        uses: actions/checkout@v4

      # --- PYTHON KISMI (Veri Çekme) ---
      - name: Python Kurulumu
        uses: actions/setup-python@v4
        with:
          python-version: '3.10'

      - name: Python Paketlerini Yükle
        run: pip install requests python-dotenv

      - name: İstatistik Scriptini Çalıştır
        env:
          API_KEY: ${{ secrets.STEAM_API_KEY }}
        run: python scripts/data-parse.py

      # --- REACT KISMI (Build) ---
      - name: Node.js Kurulumu
        uses: actions/setup-node@v4
        with:
          node-version: 18

      - name: NPM Paketlerini Yükle
        run: npm ci

      - name: React Projesini Derle (Build)
        run: npm run build

      # --- COMMIT KISMI (Verileri Repoya Kaydet) ---
      # Bu adım data.json'ı repoda da güncel tutar, böylece geçmişi görürsün.
      - name: Güncel Veriyi Commit ve Push Et
        run: |
          git config --global user.name 'github-actions[bot]'
          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
          git add src/data.json scripts/baseline.json src/hall_of_fame.json
          # Değişiklik yoksa hata vermeden devam et, varsa pushla
          git diff --quiet && git diff --staged --quiet || (git commit -m "Auto-update stats [skip ci]" && git push)

      # --- ARTIFACT OLUŞTURMA ---
      # Build edilen 'dist' klasörünü bir sonraki adıma aktarır
      - name: Upload Pages Artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: './dist'

  # 2. GÖREV: Yayına Al (Deploy)
  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    needs: build-and-update
    steps:
      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v4

Live Filtering I implemented a real-time search feature. As you type, the table filters instantly without any server-side delay. It also has a versus mode where you can compare users with each other.

Detailed Player Cards Clicking on a player reveals a deeper dive into their stats—Win rates, ADR (Average Damage per Round), and recent match history.

🚀 Performance Benchmarks

Since we use the Steam web API, you need to close the game for the game data to synchronize. You can then retrieve the data using the data-parse.py file. The site goes live on GitHub Actions in about 1-2 minutes, and the data retrieval process takes approximately 5 to 10 seconds.

💡 What I Learned
This project actually came about after a conversation among friends. That's why I wanted to move forward quickly. I created a React project using Antigravity AI and the Steam Web API. With Vite, I was able to build the foundation of the project very quickly, and the rest was just development.

Key Takeaway: Focus on the data structure first. If your JSON is clean, your frontend logic becomes trivial.

💬 Let's Discuss!
How do you handle data updates for static sites? Do you prefer GitHub Actions, or do you think a serverless function (like Vercel/Netlify) is the better route?

If you liked it, don't forget to leave a star ! ⭐

Check out the repo and let me know your thoughts in the comments! 👇

Solving XOR without Backpropagation: A Genetic Algorithm Approach 🧬

İbrahim SEZER — Tue, 06 Jan 2026 18:08:00 +0000

We usually hear about Backpropagation and Gradient Descent when talking about training Neural Networks. They are the industry standards, the "calculus" way of learning.

But what if we took a step back and looked at how nature learns? 🌿

In this post, we are going to solve the classic XOR problem (a problem that a single neuron cannot solve) using a Genetic Algorithm (GA). We won't calculate a single gradient. Instead, we will simulate "survival of the fittest."

Let's breed some brains! 🧠

What is the XOR Problem?

Before we dive into the code, let's remember our target. The XOR (Exclusive OR) gate is a non-linear problem.

A simple linear line cannot separate these outputs. We need a Neural Network.

The Evolutionary Recipe

In a Genetic Algorithm, we treat our Neural Networks as "individuals" in a population.

Fitness: How well does the network solve XOR?
Selection: The best networks get to reproduce.
Crossover: We mix the weights of two parents.
Mutation: We add random noise to keep genetic diversity.

Let's look at the Python implementation.

(Note: This code assumes you have a basic NeuralNetwork class setup with a .forward() method and weight matrices W1, W2, etc.)

1. Determining "Fitness"

In nature, fitness might mean "speed" or "strength." In our code, fitness is the inverse of error. We want the Mean Squared Error (MSE) to be as low as possible.

import numpy as np
from basic_neural_network import NeuralNetwork

def calculate_fitness(nn):
    """
    Measures the XOR performance of the network.
    The lower the error, the higher the Fitness (Score).
    """
    X_xor = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
    y_target = np.array([[0], [1], [1], [0]])

    predictions = nn.forward(X_xor)
    mse = np.mean((y_target - predictions) ** 2)  # Mean Squared Error

    # We add 1e-9 to avoid dividing by zero if we hit a perfect score
    return 1 / (mse + 1e-9)

Mutation: The Spark of InnovationIf we only bred the best existing networks, we would eventually get stuck. We need random "oopsies" to discover new, better weights. This is Mutation.We iterate through the weights ($W1, W2...$) and occasionally nudge them with random values.

def mutate(nn, mutation_rate=0.1, strength=0.5):
    """
    Adds random noise to the network's weights.
    """
    parameters = [nn.W1, nn.b1, nn.W2, nn.b2, nn.W3, nn.b3]

    for param in parameters:
        if np.random.rand() < mutation_rate:
            # Add random Gaussian noise
            noise = np.random.randn(*param.shape) * strength
            param += noise

Crossover: Breeding This is where the magic happens. We take two parent networks and create a child. In this simple implementation, the child's brain is literally the average of its parents.

def crossover(parent1, parent2):
    """
    Produces a child by taking the average of two parents' weights.
    """
    child = NeuralNetwork()
    # Averaging weights acts as a simple way to combine traits
    child.W1 = (parent1.W1 + parent2.W1) / 2
    child.b1 = (parent1.b1 + parent2.b1) / 2
    child.W2 = (parent1.W2 + parent2.W2) / 2
    child.b2 = (parent1.b2 + parent2.b2) / 2
    child.W3 = (parent1.W3 + parent2.W3) / 2
    child.b3 = (parent1.b3 + parent2.b3) / 2
    return child

The Main Loop: Evolution in Action
Now we run the simulation. We are using Elitism here—meaning the top 5 performers move to the next generation automatically. This guarantees our AI never gets "dumber" across generations.

Here is the strategy:

Sort population by score.
Keep the top 5 (Elites).
Fill the rest of the population by breeding the top 20%.
Mutate the children.
Repeat!

# --- MAIN LOOP ---

# 1. Initial Population
population_size = 50
population = [NeuralNetwork() for _ in range(population_size)]
generation_count = 1000

print("Evolution starting...")

for gen in range(generation_count):
    # 2. Calculate scores for everyone and sort (Highest score first)
    population = sorted(population, key=lambda x: calculate_fitness(x), reverse=True)

    best_individual = population[0]
    best_error = 1 / calculate_fitness(best_individual)

    if gen % 100 == 0:
        print(f"Gen {gen}: Lowest Error (MSE): {best_error:.5f}")
        # Early exit if error is low enough
        if best_error < 0.001:
            print("Solution found!")
            break

    # 3. Create New Generation (Elitism + Crossover)
    new_population = []

    # Carry over the top 5 individuals directly (Elitism)
    new_population.extend(population[:5])

    # Fill the remaining 45 by breeding from the top performers
    while len(new_population) < population_size:
        # Select 2 parents randomly from the top 10 (top 20%)
        parent1 = population[np.random.randint(0, 10)]
        parent2 = population[np.random.randint(0, 10)]

        child = crossover(parent1, parent2)

        # High mutation rate helps explore the search space faster
        mutate(child, mutation_rate=0.3, strength=0.2)
        new_population.append(child)

    population = new_population

The Result?
After running this, the "Best Individual" should have weights perfectly tuned to solve XOR without ever calculating a derivative!

# --- FINAL TEST ---
print("\n--- Training Complete ---")
X_test = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
result = population[0].forward(X_test)

print("XOR Inputs:")
print(X_test)
print("Trained Network Predictions:")
print(np.round(result, 3))

Why use this over Backpropagation?
To be honest, for XOR, Backpropagation is faster. However, Genetic Algorithms shine in scenarios where:

The reward is sparse: (e.g., You only know if you won the game at the very end).

The problem is not differentiable: You can't calculate gradients on discrete logic or complex physical simulations.

Conclusion
We just simulated natural selection to teach a computer logic. If that isn't cool, I don't know what is!

Have you experimented with Evolutionary code? Let me know in the comments below! 👇

Happy coding! 🚀

Photo by Warren Umoh on Unsplash

Optimizing Factory Efficiency with Genetic Algorithms & Tabu Search

İbrahim SEZER — Thu, 01 Jan 2026 12:19:22 +0000

Optimization is not just a buzzword; in the manufacturing world, it is the thin line between profit and loss. While writing nested loops can solve small problems, what happens when you have 50 machines, 1000 orders, strict deadlines, and mandatory maintenance windows?

Welcome to the world of NP-Hard problems, where Genetic Algorithms (GA) and Tabu Search become your best friends.

The Scenario: "The Chaos Floor" ⚠️
Imagine a smart factory producing automotive parts.

Resources: CNC Machines, Welding Robots, Assembly Lines.

Tasks: 500 different orders with varying durations.

Constraints:

❌ Hard Constraint: A machine cannot process two parts at once.
❌ Hard Constraint: Machine #3 must undergo maintenance every Tuesday between 14:00-16:00.
⚠️ Soft Constraint: Minimize energy consumption (don't turn machines on/off frequently).
⚠️ Soft Constraint: Finish high-priority orders first.

Brute-forcing this? If you check every combination, the universe might end before your code finishes running. This is where Heuristics come in.

1. The Scoreboard: The Fitness Function 📊

Before we solve the problem, we need to know what "good" looks like. In AI, this is the Fitness Function (or Cost Function). It converts a complex schedule into a single number.

For our factory, the mathematical model might look like this:

TotalTime (Makespan): How long to finish all orders?
EnergyCost: Cost of electricity based on machine idle time.
Penalty: 10,000 points added for every Maintenance Violation!

Goal: Minimize the Fitness Score. (0 is perfection, but rarely achievable).

Schedule ID	Completion Time	Maintenance Breach?	Fitness Score	Status
Schedule A	8 Hours	Yes (1)	10,5	❌ INVALID
Schedule B	12 Hours	No	800	✅ VALID (Slow)
Schedule C	8.5 Hours	No	250	🏆 OPTIMAL

2. Evolution in Action: Genetic Algorithms (GA) 🧬

GA treats production schedules like DNA strands. It relies on the principle of "Survival of the Fittest".

How it works on the Factory Floor:

Population: Create 50 random schedules. Most will be terrible (machines crashing, maintenance skipped).
Selection: Pick the best 10 schedules based on the Fitness Function.
Crossover: Combine Schedule A and Schedule B.

Take morning shift from A + Afternoon shift from B.

Mutation: Introduce chaos.

Randomly move Order #55 from Machine 1 to Machine 2.

Step ID	Current Stage (İşlem)	Condition / Action (Koşul/Eylem)	Next Step (Sonraki Adım)	Description (Açıklama)
A	Random Schedules	Initial Creation	--> B (Calculate Fitness)	The process starts by generating random solutions.
B	Calculate Fitness	If Bad Solution	--> C (Discard)	The algorithm evaluates the schedule. Poor results are rejected.
B	Calculate Fitness	If Good Solution	--> D (Parents)	Successful schedules are selected to be "Parents".
C	Discard	Stop	End of Path	Bad solutions are removed from the pool.
D	Parents	Selection	--> E (Crossover)	Selected parents prepare to combine their features.
E	Crossover	Mixing	--> F (Mutation)	Parents' attributes are mixed to create a new solution.
F	Mutation	Alteration	--> G (New Generation)	Small random changes are made to maintain diversity.
G	New Generation	Loop Back (🔄)	--> B (Calculate Fitness)	The new generation is sent back to be evaluated again.

Why Mutation Matters: Without mutation, your factory schedule might get stuck in a "Local Optima"—a solution that looks good but isn't the best. Mutation forces the algorithm to try weird combinations, potentially finding a hidden shortcut in production.

3. The Memory Master: Tabu Search 🧠

While GA creates new solutions by breeding, Tabu Search improves a single solution by exploring its neighbors.

Imagine you are climbing a mountain in the fog (searching for the peak efficiency).

1- You take a step.

2- If it's higher (better), you keep going.

3- The Twist: To prevent walking in circles, you keep a "Tabu List" (Forbidden List).

"I just moved Machine 4's task to 2 PM. I cannot move it back for the next 10 iterations."

Feature	Genetic Algorithm (GA)	Tabu Search (TS)
Strategy	Population-based (Evolution)	Single-solution (Local Search)
Strength	Explores the whole search space widely.	Fine-tunes and polishes a solution.
Mechanism	Crossover & Mutation	Tabu List (Memory)
Factory Use Case	Generating the initial weekly plan.	Handling a sudden machine breakdown & re-optimizing.

Real-World Impact 🚀

Applying these algorithms to factory floors results in tangible ROI:

Predictive Maintenance: Instead of fixed schedules, algorithms schedule maintenance when the impact on production is lowest (low downtime cost).
Energy Efficiency: Grouping high-energy tasks together to reduce peak load penalties.
Agility: When a rushed order comes in, GA can re-calculate the schedule in minutes, not days.

Sample Python Logic (Conceptual)

def calculate_factory_cost(schedule):
    cost = 0

    # 1. Check Maintenance (Hard Constraint)
    if check_maintenance_conflict(schedule):
        cost += 10000 # Massive Penalty!

    # 2. Check Efficiency (Soft Constraint)
    cost += calculate_idle_time(schedule) * 10 

    return cost

Conclusion

Whether it's arranging university timetables or managing a gigafactory, the logic remains the same: Define the constraints, penalize the errors, and let evolution find the path.

Next time you see a factory running smoothly, remember: it's not just mechanics; it's mathematics.

📊 Visualize Your Coding Journey: Check Your GitHub Stats

İbrahim SEZER — Sat, 27 Dec 2025 12:09:59 +0000

Have you ever wondered what your coding timeline really looks like beyond the standard green contribution squares on GitHub?

We all love seeing those green squares light up, but sometimes they don't tell the whole story. They don't tell you which languages dominate your repos, how your tech stack has evolved over the years, or which specific repositories earn the most stars.

I recently stumbled upon a tool that turns your GitHub profile into a beautiful visual report, and I had to share it.

🚀 Meet "Profile Summary for GitHub"

It is an open-source tool that analyzes your public repositories and generates a comprehensive dashboard of your coding habits.

Instead of just counting commits, it breaks down your profile into actionable insights.

🔗 Check it out here: profile-summary-for-github.com

✨ Key Features

Here is why I think this tool stands out:

Language Breakdown: It doesn't just show your top language; it visualizes the ratio of every language you use across all repositories.
Repository Insights: You can see which repos have the most stars and forks in a clean bar chart.
Timeline Analysis: It shows a "Commits per Repository" chart over time, which is great for seeing which projects you were obsessed with during specific years.
No Sign-up Required: You just enter your GitHub username, and it generates the report instantly.

🧐 How to Use It

Go to profile-summary-for-github.com.
Enter your GitHub username.
Analyze your charts!

You can also view your profile directly via this URL pattern:

https://profile-summary-for-github.com/user/YOUR_USERNAME

💡 Why It Matters

As developers, we often forget how much we've learned or how our interests have shifted. Seeing a visual representation of your move from, say, Java to Python, or seeing that side project you worked on for three months straight in 2021, is incredibly validating.

It is also a great link to include in your portfolio or resume to give recruiters a quick snapshot of your technical focus.

👇 Let's Connect!

Give it a try and let me know in the comments: What is your #1 most used language according to the tool?

I built my Portfolio as a Computer Engineer. Roast my design! 🚀

İbrahim SEZER — Sat, 27 Dec 2025 12:00:29 +0000

A look into my personal portfolio hosted on GitHub Pages, showcasing my work in AI, Flutter, and Web Development.

Hi everyone! 👋

I'm Ibrahim Sezer, a Computer Engineering graduate and entrepreneur passionate about Generative AI, Mobile Development (Flutter), and Web Technologies.

After working on various projects ranging from chess visualization tools to file transfer interfaces, I decided to develop my portfolio to showcase my journey. I wanted something fast, clean, and easy to maintain without dealing with complex server setups.

Here is the result: https://ibrahimsezer.github.io/

🛠️ The Tech Stack (Simplicity is Key)

I decided to go with a "Static First" approach.

Hosting: GitHub Pages (Free, reliable, and integrated with my workflow).
Frontend: HTML5, CSS3, and Vanilla JavaScript.
Version Control: Git (obviously).

Why this stack?
As an engineer, I love over-engineering things, but for a portfolio, content is king. Hosting it on GitHub Pages allows for automatic deployment. Every time I push a change to the main branch, the site updates instantly. No DevOps headaches!

📂 What's Inside?

My portfolio is designed to be a gateway to my technical world. It includes:

About Me: My background in Computer Engineering and my entrepreneurial goals.
Project Showcase:
- AI & RAG Projects: Such as my "Chat with Docs" LLM implementation.
- Flutter Apps: Like "Seezme", a voice/chat messaging app.
- Web Tools: Including my open-source Chess Vision trainer.
Social Links: Direct access to my GitHub, LinkedIn, and Medium articles.

🤝 I Need Your Feedback!

I am constantly looking to improve the UX and the content strategy.

Does the design feel professional enough for an entrepreneur?
Is the navigation intuitive?
Should I add a blog section directly to the site or keep linking to Medium?

Feel free to check out the code and star ⭐ the repo if you like it:

https://www.github.com/ibrahimsezer/ibrahimsezer.github.io

Thanks for stopping by! 🚀

High-Throughput IoT Log Aggregator

İbrahim SEZER — Thu, 25 Dec 2025 19:47:17 +0000

Imagine an industrial monitoring system receiving telemetry packets from thousands of sensors every second. The system must:

Ingest a batch of raw data packets.
Filter inactive sensors.
Aggregate temperature readings by Device ID.
Generate a textual summary log for the dashboard.

The Challenge: Since this runs continuously, any inefficiency (like unnecessary memory allocation) will cause "Garbage Collection" pauses, causing data loss. We must use memory-efficient patterns.

We used Go language for this performance test

System Flow Diagram

    A[Raw Data Ingestion] -->|Slice Pre-allocation| B(Batch Processing)
    B -->|Value Semantics| C{Filter Inactive}
    C -->|Map Pre-allocation| D[Aggregation]
    D -->|strings.Builder| E[Log Generation]
    E --> F[Final Report]

Code Segment	Optimization Technique	Why it matters in this scenario?
`type SensorPacket struct`	Struct Alignment	Millions of packets are kept in RAM. Saving 8 bytes per packet saves ~8MB of RAM per million records.
`make([]SensorPacket, 0, n)`	Slice Pre-allocation	The simulation loads 100,000 items. Without this, Go would resize the array ~18 times, copying memory each time.
`make(map[int32]float64, 100)`	Map Size Hint	We aggregate by device. Allocating buckets upfront prevents expensive "rehashing" when the map fills up.
`var sb strings.Builder`	String Builder	Generating the report log involves many string additions. Builder prevents creating hundreds of temporary trash strings.
`func processBatch(...)`	Value vs Pointer	`config` is passed by Value (fast stack access). The `Report` is returned by Pointer (avoids copying the big map).

Optimized (Current Code):

[ Timestamp (8) ] [ Value (8) ] [ DeviceID (4) | Active (1) | Pad (3) ]
Total: 24 Bytes / Block

Unoptimized (If mixed):

[ Active (1) | Pad (7) ] [ Timestamp (8) ] [ DeviceID (4) | Pad (4) ] [ Value (8) ]
Total: 32 Bytes / Block (33% Wasted Memory!)

Example Results

--- Processing Complete in 6.5627ms --- --- BATCH REPORT --- Batch ID: 1766689634 Device 79: Avg Temp 44.52 Device 46: Avg Temp 46.42 Device 57: Avg Temp 45.37 Device 11: Avg Temp 44.54 Device 15: Avg Temp 46.43 ... (truncated)

📊 Benchmark Results

The following benchmarks compare the performance of "naive" implementations versus "optimized" patterns using Go's best practices. The tests were run on an Intel Core i5-10300H CPU @ 2.50GHz.

Operation Type	Implementation	Time (ns/op)	Memory (B/op)	Allocations (op)	Performance Gain
Slice Append	Inefficient	66,035 ns	357,626 B	19	-
	Efficient (Pre-alloc)	15,873 ns	81,920 B	1	~4.1x Faster
String Build	Inefficient (+)	8,727 ns	21,080 B	99	-
	Efficient (Builder)	244.7 ns	416 B	1	~35.6x Faster
Map Insert	Inefficient	571,279 ns	591,485 B	79	-
	Efficient (Size hint)	206,910 ns	295,554 B	33	~2.7x Faster
Struct Pass	By Value (Copy)	0.26 ns	0 B	0	-
	By Pointer (Ref)	0.25 ns	0 B	0	Similar

Note on Structs: In micro-benchmarks with tight loops, the Go compiler heavily optimizes (inlines) function calls, making the difference between Value and Pointer negligible. However, in real-world applications with complex call stacks, passing large structs by Pointer significantly reduces CPU usage by avoiding memory copy operations.

💡 Key Takeaways
String Concatenation: Never use + in loops. The strings.Builder approach is over 35 times faster and uses 98% less memory because it avoids creating intermediate garbage strings.

Memory Pre-allocation: Telling Go how much memory you need upfront (for Slices and Maps) eliminates the overhead of resizing and copying data (Rehashing/Reallocation).

Slice: Reduced allocations from 19 to 1.

Map: Reduced allocations from 79 to 33.

Allocations matter: Every allocation (allocs/op) forces the Garbage Collector to work harder. Keeping this number low makes the entire application more stable and responsive.

Contact 📧

If anyone is interested, I can also share the code blocks I used for the performance test. You can contact me via my GitHub profile.

I launched a Prayer Times web app. What would make you use this daily? 🚀(Built with React & Tailwind)

İbrahim SEZER — Wed, 24 Dec 2025 11:16:12 +0000

Hi community!

I just deployed my latest project: https://ezannamaz.netlify.app/

My goal was to create a distraction-free interface for checking prayer times. It works smoothly, but I feel like it needs that "extra" touch to make it a daily driver for users.

I need your creativity: Aside from the standard features (times, location), what is a unique feature you haven't seen in other apps?

Maybe an integration with Google Calendar?

A minimal "focus mode" for reading?

Or something completely different?

I’m ready to code the most upvoted suggestion this weekend! Let me know your thoughts. 👇

Prayer Times - Main Page

Islamic Insights & Articles

I built a free, open-source tool to improve my Chess Vision and Coordinate memory. Looking for feature ideas!

İbrahim SEZER — Fri, 19 Dec 2025 18:17:26 +0000

Hi everyone,
I've been trying to improve my calculation skills, but I realized I was struggling with visualizing the board (knowing instantly if 'e4' is white or black) and finding coordinates quickly without looking at the numbers.
So, I decided to build a simple web app to train these specific skills.

It’s called Chess Warmup.

It currently has 4 modes:

Color Memory: Guess if a square is White or Black.
Coordinate Finder: Click the correct square as fast as possible.
Piece Movement: Coordinate work with the appropriate moves of chess pieces.
Ghost Mode: The hardest one! Coordinates are hidden, forcing you to use your instinct.

It also tracks your stats and shows a heatmap of your weak squares after each session. It's completely free, no ads, and no sign-up required.

I would love to hear your feedback: What other training modes or features would help you as a beginner?

Here is the link to try it: Live Site And here is the source code on GitHub if you want to contribute: Github Repo

Flutter MediaPlayer

İbrahim SEZER — Wed, 26 Feb 2025 15:52:27 +0000

Hello everyone, I would like to share an open source project about Flutter MediaPlayer.

My goal in this application is to create an open source and free MediaPlayer application. I'm trying to design an application for Android. I am waiting for everyone who wants to support open source starting projects.

Thanks for your help. 💫

git clone https://github.com/ibrahimsezer/mediaplayer.git

You can click on my profile to connect with me. 👇

https://ibrahimsezer.github.io/