DEV Community: Kenta Takeuchi

Writing Code That Fits in Your Brain: Heuristics and Techniques to Avoid Complexity and Ensure Sustainability

Kenta Takeuchi — Sun, 15 Mar 2026 11:22:51 +0000

Writing Code That Fits in Your Brain: Heuristics and Techniques to Avoid Complexity and Ensure Sustainability is a book I recently read.

From the title, I expected it to include cognitive science discussions reminiscent of Programmer's Brain, but that wasn't the case.

This book discusses practical practices for writing code that fits within your brain's memory.

Overall, there were many parts I resonated with based on my own experiences. The author seems to have a background not from a computer science department but has built a career as a software engineer, which gives a sense of experience cultivated in the field.

Regarding the content, it felt a bit fragmented.

The discussion on fractal architecture seemed a bit brief, so I would love to read a book by the author focused solely on fractal architecture.

The Art of Writing a CFP

Kenta Takeuchi — Sun, 15 Mar 2026 11:22:49 +0000

Overview

Submitting a CFP (Call for Papers) for conferences and speaking events is a common practice. Here, I will write a poem about how I craft and submit my CFPs.

Past Achievements

I have submitted CFPs seven times in the past, with a 100% acceptance rate (though I declined one due to various reasons).

The events I have spoken at include PHP and Go conferences, with more appearances at PHP conferences.

cf. https://speakerdeck.com/bmf_san

To be honest, there were many shortcomings in my early presentations and CFPs, but recently I've gained a lot more confidence, so I thought I'd leave my thoughts here.

My Way of Writing a CFP

Before Writing a CFP...

I always organize what I do before writing a CFP.

Consider the Purpose of Speaking

What do I want to gain from speaking? Having this clear helps motivate me.

I focus on whether it seems valuable both for myself and the audience. While it's not wrong to think only about personal benefits and consider the CFP's acceptance as a validation of its value to the audience, considering various perspectives broadens the range of presentation themes and increases what I can gain.

Decide on the Event to Speak At

If it's an event I've attended before, I can easily imagine the atmosphere and themes. If not, it's better to research past events or actually attend them.

Knowing the themes, level of presentations, audience characteristics, and sponsor companies helps build confidence when speaking, making it an important preparation step.

Thanks to past experiences, I don't get nervous speaking in front of people; rather, I enjoy it. However, this prior research helps maintain my mental state.

Thoroughly Check the Event Schedule

It's obvious, but if the schedule doesn't match even if the CFP is accepted, it would be sad. It's best to adjust the schedule in advance.

How to Write a CFP

By the time I submit a CFP, I usually have a rough idea of the presentation.

When I start writing a CFP, I have a somewhat organized outline of the presentation theme and can almost start writing the slides.

It depends on the person, but for me, the "idea" comes first, and once I see "this idea can be presented," I consider speaking. (There might be cases where you create an idea from keywords and prepare for the presentation, similar to presentation-driven development.)

I'll explain the steps I take to submit a CFP.

Prepare the Idea

Nothing starts without an idea.

Sometimes I use things I've done privately based on interests as ideas, or I start by thinking of ideas related to specific technologies, but it's mostly the former.

Write a Blog

Writing a blog to submit a CFP might seem odd, but this process is crucial for me.

Writing a blog ≈ CFP written, slides almost done.

By writing a blog, I can expand the idea, making CFP writing and slide creation smoother.

It's important to write a blog with a proper structure, not just as a memo.

Write the CFP

My method is to write a blog before writing the CFP.

Instead of writing the CFP immediately, I organize various things.

Recently, I've been using Miro to organize.

I organize it like the image below.

Here's the format I prepare to write a CFP.

Session Title
Event Information
CFP
Acceptance Criteria
What to Talk About / What Not to Talk About
What I Want to Convey
Keywords
Outline
Slide Draft
Research

By completing this format in no particular order, the CFP is finished.

The original idea for this format was taught by a senior engineer at a company I used to work for, but I've added my own touches.

I'll explain each part of the format using the preparation content submitted for Go Conference 2021 as an example.

Session Title

Write the session title.

If the idea is ready and the blog is written, the session title can be mostly decided, but if not, I set a tentative title first.

When thinking about the title, I only consider whether it conveys the presentation's image concisely in one breath, similar to naming functions or variables when coding.

Event Information

Check and write down information about the event.

Write the event title, date, and details of the speaking slot for which you're submitting the CFP.

CFP

Write the text of the CFP to be submitted.

Sometimes I write it after organizing other parts, or I write a rough draft first.

I feel that CFPs have a certain character limit, but even if not, I try to write concisely.

As long as it includes the necessary information for the selectors, it should be fine to write it briefly.

I write the CFP with the following outline.

What will be discussed
Who is the target audience, and who would benefit from listening
What information can be gained from the presentation
Outline of the presentation content
Supplementary material links

Acceptance Criteria

Check and write down the event's acceptance criteria.

Most conferences have acceptance criteria.

This is a regulation, so read and confirm it carefully.

Not only the acceptance criteria but also the code of conduct should be read thoroughly.

What to Talk About / What Not to Talk About

Write what to talk about and what not to talk about.

It's especially important to write what not to talk about. Prioritizing the main theme and avoiding talking too much about unrelated topics prevents the content from becoming scattered and hard to convey, so it's important to clarify unnecessary topics.

What I Want to Convey

Write what you want to convey.

You can write as many as you want, but focusing on one per theme makes the content more cohesive.

Keywords

Pick up and write keywords related to the presentation content.

This is more about organizing and finding key points rather than expanding ideas.

Writing them out helps identify important keywords, making it easier to summarize what you want to convey and assert.

Conversely, it also reveals keywords that may not need to be addressed, so I write them out as an exercise.

Outline

Write the outline of the presentation content.

I sometimes write this, sometimes not. If the blog is finished, I might not write it; if not, I write it to prepare the blog.

If the blog is finished, I organize the outline based on the blog content.

Slide Draft

Write a rough image of the slides using sticky notes.

This is about imagining how to translate the outline into slides, but recently I've been using slide creation software to create outlines as sticky notes and make slides, so it might not be necessary. However, doing it helps you be aware of the presentation flow, notice any inconsistencies, and identify areas that need more depth, so it's worth doing.

Research

Write down anything you want to research thoroughly or delve into later.

Summarize and memo research items like preparing sample implementations or conducting technical verifications.

Also, write down checks for logical or factual confirmations of what you want to assert.

CFP Examples

Here are examples of CFPs I have actually submitted.

Go Conference 2021/Introduction to Building an HTTP Router with net/http

I will talk about how to build an HTTP router using Go's standard package net/http. Starting with reading the code to launch a simple server using net/http, I will explain how to build an HTTP router and the algorithms involved. Although there may not be many opportunities to build one from scratch due to the existence of excellent routers as OSS, I believe building one can deepen your understanding of net/http and tree structures. This LT targets Go beginners.

Here are the main materials for this LT.

## Github
- [github.com - bmf-san/goblin](https://github.com/bmf-san/goblin)

## Blog
- [Golang's HTTP Server Code Reading](https://bmf-tech.com/posts/Golang%E3%81%AEHTTP%E3%82%B5%E3%83%BC%E3%83%90%E3%83%BC%E3%81%AE%E3%82%B3%E3%83%BC%E3%83%89%E3%83%AA%E3%83%BC%E3%83%87%E3%82%A3%E3%83%B3%E3%82%B0)
- [Introduction to Building URL Routing from Scratch Episode 1](https://bmf-tech.com/posts/URL%E3%83%AB%E3%83%BC%E3%83%86%E3%82%A3%E3%83%B3%E3%82%B0%E8%87%AA%E4%BD%9C%E5%85%A5%E9%96%80%E3%80%80%E3%82%A8%E3%83%94%E3%82%BD%E3%83%BC%E3%83%89%EF%BC%91)
- [Introduction to Building URL Routing from Scratch Episode 2](https://bmf-tech.com/posts/URL%E3%83%AB%E3%83%BC%E3%83%86%E3%82%A3%E3%83%B3%E3%82%B0%E8%87%AA%E4%BD%9C%E5%85%A5%E9%96%80%E3%80%80%E3%82%A8%E3%83%94%E3%82%BD%E3%83%BC%E3%83%89%EF%BC%92)
- [Introduction to URL router from scratch with Golang](https://dev.to/bmf_san/introduction-to-url-router-from-scratch-with-golang-3p8j)


## Slides
- [Built a URL Router with Golang](https://speakerdeck.com/bmf_san/golangteurlrutawotukututa)

Go Conference 2023/The Ultimate HTTP Router Dance

This was accepted, but I had to decline due to unavoidable circumstances. I really wanted to participate, and I feel regret and apologize to the organizers. This idea is still an unpublished work, so I plan to try again next time.

Go provides a standard feature (multiplexer) for routing, but in actual development, you often use some HTTP Router package.

I have been building my own HTTP Router, and I wanted to compare its performance with existing packages.

So, I implemented a benchmarker and worked on comparing performance differences.

I will talk about the results of picking up and comparing several packages and the learnings from it.

This LT will consider the following outline.

Motivation
Premises (premises for performance comparison)
Measurement methods and targets
Measurement results
Learnings

I want to provide my answers to questions like "Which HTTP Router performed the best? (according to me)", "What is the performance difference with the standard multiplexer?", and "Can performance alone be a criterion for selecting an HTTP Router?"

// The following is not the main body of the CFP but a supplementary text submitted
This presentation is based on a past presentation, "The Ultimate HTTP Router Martial Arts Tournament."

cf. https://speakerdeck.com/bmf_san/tian-xia-httprouterwu-dou-hui

I plan to organize and brush up on parts that were not fully organized in the initial content of that presentation and make it the theme of this presentation.

I changed it to a dance because martial arts tournaments sound violent, and martial arts tournament 2 sounds mysterious.

Other related information
https://dev.to/bmf_san/implemented-a-bench-marker-to-compare-gos-http-router-146p
An article summarizing the comparison of HTTP Routers
https://github.com/bmf-san/goblin
My self-made HTTP Router

As a hidden theme, I hope to convey the fun of implementing an HTTP Router to the audience.

Conclusion

The key point or tip for me when writing a CFP is "to have a blog written."

If you can output in writing, about 60-70% of the presentation preparation is done.

When I usually finish a CFP, I write it in this flow, but as I repeat the process, the method becomes rougher, but I make sure not to skip the task of writing a blog.

Once the CFP is accepted, it's just a matter of riding the flow to create and refine the slides, so you can proceed smoothly.

Although it's somewhat formal, I think that by not neglecting preparation, the work becomes smoother, and the acceptance rate increases (personal opinion).

Speaking of which, I once served as a selector for an event as an organizer, and I think it's important to put yourself in the selector's shoes.

Thoughts

I always think there's room to study these business skills, but due to laziness, I haven't been able to...

Since impressions can be influenced by how you convey things, I believe the return on honing these skills is significant, but recently I have a feeling that ChatGPT might become a good teacher.

Aside

I intended to limit the discussion to CFPs, but I'll add an aside.

Things to Keep in Mind When Creating Slides

I've organized a few things I keep in mind when creating slides for speaking events.

First, finish roughly, move your hands first, and refine details gradually. Like agile.
- If you try to complete each slide, you might fall into the waterfall trap.
- You often end up reworking, losing sight of the overall picture, and the flow of the slides becomes inconsistent.
Don't put too much text.
- I think presentation materials are like that.
- Even if you write a lot of text, the audience can't read it all, and they come to listen to the talk.
Practice
- Measure time, practice in the same environment as the actual presentation (match the device, presentation method, etc.).
- Properly operate slide transitions, check if speaker notes are visible if you split the screen, etc.
- If you fumble during the actual presentation, you'll waste time...
- It's also good to roughly check how many seconds you can spend per slide.
Keep the volume modest.
- For a 15-minute presentation, it's just right to narrow down the slide count and content to something that can be covered in about 12-13 minutes.
- Even if you're not nervous, if there are various things you want to talk about, the talk tends to extend (which can also be due to lack of practice).
Don't write too much in speaker notes.
- Don't make notes that can be read aloud as they are.
- Unless you're an announcer, it tends to become monotone.
Think about the words to use at transitions in the talk.
- In the flow of the talk, there are scenes where the topic changes, and I often struggle with how to smoothly move to the next topic, so I choose words in advance.
- If you can't find good words, there might be room for improvement in the flow of the talk, so refactor it.
Keep the self-introduction slide simple.
- Unless there's a case where you should write it properly depending on the purpose of the presentation or event, keep it brief.
- There's a strategic way of writing it as a conversation starter for after-parties, but it's a low priority that can be considered after all slides are finished.
Don't include easy jokes or gags.
- In official talks, don't include unnecessary "gags." There's no need to take risks that don't match the cost.
- Also avoid quirky metaphors...
Get a review
- As an individual activity, I often complete it on my own, but if it's part of work, it's good to get feedback from others through a review.

Things to Consider When Writing Architecture Documents

Kenta Takeuchi — Sun, 15 Mar 2026 11:22:17 +0000

Overview

In system design, architecture documents play a crucial role. Especially during the design phase, they function as materials to explain the validity of the design to stakeholders and to form consensus. This document should not be a mere list of design information but a strategic document that guides the reader's understanding and agreement.

Clarify the Purpose

The first thing to be aware of when creating a document is its purpose. It must be clear who this document is for and what it aims to convey. The main audience is the project's stakeholders. It is required to address their concerns and be understandable.

Characteristics the Document Should Have

Accuracy

The content must be accurate concerning the target architecture and stakeholders' concerns. It should also clearly state that the proposed architecture meets the stakeholders' needs.

Sufficiency

Instead of merely listing components, it is necessary to show the reasoning behind adopting such a configuration. If there were alternatives, logically explaining their comparison and reasons for rejection increases the persuasiveness of the design.

Conciseness

It is important to focus on critical design decisions rather than writing everything in detail. The level of detail should be adjusted based on the following perspectives:

Stakeholders' technical ability and experience
The novelty of the content
Complexity of the problem to be solved
Available communication time and resources

Clarity

It is important to adjust the use of technical terms and expressions according to the reader's knowledge and understanding level. Using diagrams and tables to convey information visually is also effective.

Relevance

The document must reflect the latest design status. As the design evolves, the document must be updated regularly to remain meaningful.

Precision

The necessary details should be described to the extent that implementation can begin. However, writing too much detail can impair readability, so it is necessary to balance using diagrams, separate documents, and a mix of concrete and abstract information.

Example Structure

Below is an example structure of an architecture document, including points the author keeps in mind when writing.

Introduction

Purpose of the document
Intended audience
Summary of system goals
Summary of scope
Summary of solutions

Requirements Definition

Functional requirements
Non-functional requirements
Special notes (regulations, assumptions, constraints, etc.)

Architecture Diagram

Diagrams showing system components and their relationships, including external systems (C4 model is effective)
Special notes (trust boundaries, availability perspectives, etc.)

Data Model

Diagrams of major data structures handled (ER diagrams, schema diagrams, etc.)
Special notes (handling of personal information, legal constraints, etc.)

Use Cases

Describe major usage scenarios and show the business context behind design decisions

Technical Details

Technology stack, frameworks, libraries used
Explanation of reasons for technology selection and design considerations

Risks and Issues

Risks anticipated at this point
Technical and business challenges and their response strategies

Outlook

Future directions for system expansion and improvement
Prospects for availability, scalability, and maintainability

Unresolved Issues

Points requiring further consideration and pending issues

Conclusion

Who the stakeholders are becomes a variable that influences the content of the document.

If the document is only for developers, it is relatively easy for developers to write. However, when targeting stakeholders without a technical background, such as project managers or sales, more careful consideration is needed.

It is easy to create documents or diagrams that try to explain multiple things at once, but to help the reader understand, it is important to organize information and focus the content.

I often start by being aware of conciseness first and then adjust to capture other perspectives. Including too much detail from the start can increase cognitive load even for myself, so I often build the document by first grasping the overall picture and then adding necessary information.

References

Principles of Building System Architecture: Three Thoughts IT Architects Should Have - Chapter 13

Writing to Remote Files with Ansible

Kenta Takeuchi — Sun, 15 Mar 2026 11:22:15 +0000

Overview

A task to write to remote files using Ansible. Frequently used.

Playbook

---
- hosts: vps
  become: yes
  user: root
  tasks:
  - name: Add text
    blockinfile:
     dest: /path/to/file
     insertafter: '^# Add Here'
     content: |
        # New Line
         Here is a new line.

Thoughts

It's easy to write.

References

lineinfile - Ensure a particular line is in a file, or replace an existing line using a back-referenced regular expression.

Why and When to Write an Architecture Strategy

Kenta Takeuchi — Sun, 15 Mar 2026 11:21:43 +0000

In many cases, strategies and tactics are not clearly defined. This may be due to a lack of recognition of their usefulness and necessity.

Some might say, "If I have time to write a strategy, I'd rather be working," or "Even if I write it, no one will read it." However, proceeding without a strategy can lead to various problems.

This article organizes what happens without a strategy and when you should write one.

What Happens Without a Strategy

Proceeding without a strategy can lead to the following issues.

Ad Hoc Technology Selection

Different technologies are adopted by each team and phase. For example, Service A uses Redis, Service B uses Memcached, and Service C has a custom implementation.

As a result, skills are dispersed, and maintenance costs increase. Without a unified policy, selections are made based on ad hoc decisions.

Misguided Prioritization

Multiple improvement proposals such as "DB partitioning," "cache introduction," and "asynchronization" are discussed in parallel. However, without criteria for judgment, decisions are swayed by the loudest voices or recent incidents.

As a result, everything becomes half-baked, or the order of implementation becomes inefficient.

Means Becoming the End

"Microservices" become the goal, and the reason for doing it becomes unclear. Each team interprets it differently, with expectations like "wanting independent deployment" or "wanting to increase scalability" varying.

As a result, the granularity of division becomes inconsistent, and the expected effects are not achieved.

Postponing Debt Management

"Prioritizing feature development now" becomes the norm. Without criteria for when and which debts to repay, debts continue to accumulate.

As a result, debts exceed a critical point, leading to a rushed response. Planned repayment becomes impossible, causing a decline in development speed.

When to Write a Strategy

For medium to long-term projects of about 1 to 3 years, a strategy should be written. Even for projects of about six months, having a simple one is beneficial.

The reason is that without a policy, the architecture may waver when evolving over such a span. The aforementioned problems are more likely to occur.

Moreover, if there is a policy, it can be flexibly updated according to the situation. Changing the policy itself is not a problem. However, without a policy, it becomes unclear "what was changed." It is important to have a policy and update it as needed.

Making the Strategy Work

Writing a strategy is meaningless if it doesn't function. Here are some points to prevent it from becoming a mere formality.

Use as a Basis for Decision-Making

Refer to the strategy in actual decision-making. By making it a habit to ask, "Does this align with the policy?", the strategy functions as a criterion for judgment.

Review Regularly

Situations change. The strategy should not be fixed but reviewed and updated regularly. Reflect quarterly or when there are significant changes.

Share with Stakeholders

The strategy is not just for the person who wrote it. Sharing it with stakeholders and having a common understanding helps prevent the team's decisions from wavering.

Conclusion

Proceeding without a strategy leads to issues such as ad hoc technology selection, misguided prioritization, means becoming the end, and postponing debt management.

For medium to long-term projects of about 1 to 3 years, a strategy should be written. Even for projects of about six months, having a simple one is beneficial.

To make the strategy work, it is important to use it as a basis for decision-making, review it regularly, and share it with stakeholders.

Polymorphism Explained: How Object-Oriented Code Stays Flexible

Kenta Takeuchi — Sun, 15 Mar 2026 11:21:41 +0000

Overview

Summarizing polymorphism

What is Polymorphism

Poly (multiple) Morphism (forms)
Providing a shared interface for multiple different types
Instances behave differently depending on the class when receiving arguments

Types of Polymorphism

Ad-hoc polymorphism
- Functions have different implementations for arguments of different types
- Achieved through overloading and function overloading
Parametric polymorphism
- Code is written without specifying types and can be used transparently for each type
- Applicable to various types by passing the type as an argument
- Achieved through generics or templates
Subtyping
- Handling multiple types with a common supertype under a single name

References

The N+1 Problem Explained: How to Detect and Fix It in Go/Rails

Kenta Takeuchi — Sun, 15 Mar 2026 11:21:10 +0000

Overview

A summary of the N+1 problem and how to address it.

What is the N+1 Problem

The issue where 1 SQL query is issued for retrieving all records plus N SQL queries for each record.
It is easier to understand if interpreted as 1+N rather than N+1.

Example

Case of retrieving data for list display
- Issue 1 SELECT query to retrieve all data for the list (returns N records)
- Issue N SELECT queries to retrieve related data for N records

Solutions

Join
- SELECT "users".* FROM "users" INNER JOIN "posts" ON "posts"."user_id" = "users"."id" WHERE "posts"."id" = 1
- Eager Loading
- SELECT "users".* FROM "users"
- SELECT "posts".* FROM "posts" WHERE "posts"."id" IN (1, 2, 3, 4, 5)

References

Linux Load Average Explained: How to Read and Diagnose Performance Issues

Kenta Takeuchi — Sun, 15 Mar 2026 11:21:08 +0000

When checking system load, you often see the metric "Load Average" displayed by the top or uptime commands.

Load Average is a value that represents the number of processes waiting to be executed, and it is an important indicator of system congestion.

The Nature of Load Average

Load Average is the average number of processes that were in a "runnable or running" state over a certain period. In Linux and UNIX-based OS, the averages for 1 minute, 5 minutes, and 15 minutes are displayed.

load average: 0.78, 1.32, 1.48

From left to right, these represent the 1-minute, 5-minute, and 15-minute averages.

This number indicates the number of processes that were simultaneously running or waiting to run relative to the CPU cores, indirectly representing CPU congestion.

It is important to note that Load Average is not "CPU usage." While CPU usage is expressed as a percentage (%), Load Average is the "average number of processes," which is fundamentally different in nature.

Relationship with CPU Core Count

The most important aspect of evaluating Load Average is its relative relationship to the number of CPU cores.

For example, if a machine with 4 cores has a Load Average of 4.0, it means all cores are fully utilized. If it exceeds this, processes may be waiting for CPU availability, indicating potential "congestion."

Conversely, if a machine with 8 cores has a Load Average of 1.5, the average wait per core is only 0.1875, indicating ample capacity.

Cases Where High Load Average is Not a Problem

A high Load Average does not necessarily indicate an issue. For instance, it is natural for it to temporarily increase in the following cases:

Batch processing or scheduled jobs are running
Many processes are waiting for IO or are in sleep mode, leaving the CPU with spare capacity
Parallel processing tasks temporarily occupy the CPU

In such cases, if a high Load Average does not affect user experience, it should not be a concern.

When to Really Pay Attention

If you observe the following symptoms, a high Load Average may be causing real issues:

Application response delays or timeouts
CPU usage is also spiking in Cloud Monitoring or similar tools
IO Wait (disk IO waiting) persists for a long time
The number of concurrent connections or threads is rapidly increasing

In such situations, you need to use tools like top, vmstat, or iostat to check details and identify which resource is the bottleneck.

Using Load Average and Other Metrics

Load Average is a metric to see "how congested processes are." To understand the system's state, you also need to look at other metrics like the following:

Metric	Description	Representative Commands
Load Average	Average number of waiting processes	`uptime`, `top`
CPU Usage	Percentage of CPU time used	`top`, `mpstat`
IO Wait	Percentage of IO wait time	`iostat`, `vmstat`
Memory Usage	State of actual memory usage	`free`, `htop`
Process Count	Number of currently running processes	`ps`, `htop`

Correct Interpretation and Engagement

Load Average is not something to be swayed by just looking at the "numbers." You should understand the appropriate value for that server and observe trends. Consider whether it exceeds the number of cores, if there are abnormal spikes, and if there is any real impact. By keeping these three points in mind, you can avoid overreacting.

Moreover, the trend of Load Average is a good indicator of how "busy" the system is. By combining it with CPU usage and memory usage, you can perform a more realistic analysis.

Conclusion

Load Average provides valuable information for understanding system congestion as an indicator of process traffic. By being aware of its relative relationship with CPU core count, you can correctly evaluate the meaning of the values.

By observing it in combination with other metrics like CPU usage, IO Wait, and memory usage, it becomes a clue to decipher actual bottlenecks and processing wait situations.

Instead of just focusing on "high Load Average," consider "how it affects user experience and the overall system."

What is a Database Index? How It Works and When You Need It

Kenta Takeuchi — Sun, 15 Mar 2026 11:20:36 +0000

What is an Index?

A mechanism to quickly retrieve records stored in a table.

Consider a query with an O(n) problem like the following:

SELECT * FROM users WHERE first_name = ‘Tom’

To improve the performance of this query, you can add an index as follows:

ALTER TABLE users ADD INDEX (first_name)

Advantages and Disadvantages

Advantages

Improved speed of data reading and retrieval

Disadvantages

Increased storage size
Decreased write speed

When creating or updating data, indexes are also added or updated simultaneously, leading to the above disadvantages.

Index Patterns

Standard (Applied to a single column)

ALTER TABLE users ADD INDEX (first_name)

Partial Index

An effective pattern when you want to improve performance while suppressing storage increase.

Example of applying an index to only the first 4 bytes:
ALTER TABLE users ADD INDEX (first_name(4))

Multi-column Index (Also called composite or compound index)

ALTER TABLE users ADD INDEX (last_name, first_name)

In MySQL, only one index per table can be used for a single query execution, but if a multi-index is applied, a valid index will be selected during query execution.

It is generally good to specify a column with high cardinality at the beginning of a multi-column index.

Unique Index

Values will not appear duplicated except for NULL.
During record creation or update, it checks all values to ensure the same value does not already exist.
In MySQL, specifying a unique key also specifies a unique index.

ALTER TABLE users ADD UNIQUE (first_name)

Measuring Index Effectiveness

Check the execution plan of a query with the EXPLAIN clause.

EXPLAIN SELECT * FROM users WHERE first_name = ‘Tom’

Check the following items:

possible_keys
- Possible indexes
key
- Index actually selected
extra
- If the following displays appear, query optimization is recommended:
- using filesort
- Insufficient memory for sorting, writing out to physical files for sorting
- using temporary
- Temporary tables are created for query execution

Index Criteria

List of criteria that might suggest considering an index. These are just guidelines for estimation, so it's better to measure with EXPLAIN.

When the table has a large amount of data and the target records for search are few
When there are columns used in WHERE, JOIN, ORDER BY, etc.
When searching for non-NULL data from data containing many NULLs (Index may be effective as it does not include NULLs)
When data is not frequently added, updated, or deleted (considering the load of index updates)

Clustered Index and Secondary Index

Clustered Index

Indexes that fall under the following are clustered indexes.

Columns defined by the primary key
Columns with NOT NULL unique keys
If no columns fall under the above, InnoDB creates a hidden clustered index called GEN_CLUST_INDEX

Secondary Index

Indexes other than clustered indexes are called secondary indexes.
Secondary indexes include the value of the primary key.
Although it is assumed to be measured with EXPLAIN, since the primary key value is included, it might be good to remember that a covering index can be achieved with just a secondary index without including the primary key in a composite index.
cf. InnoDB Secondary Index Utilization Techniques!

Covering Index

An index that contains all the columns necessary for the query result.

Since it can be covered with just the index without reading the data file, the search is accelerated.

Cautions When Applying Indexes

Arithmetic Operations and SQL Functions on Index Columns

SELECT * FROM users WHERE amount * 2 > 10;

If an index is applied to amount, avoid operators to utilize the index. The amount itself is held in the index, not the result of the operation. The same applies to SQL functions.

SELECT * FROM users WHERE amount > 10/2;

IS_NULL

SELECT * FROM users WHERE amount IS NULL;

IS NULL or IS NOT NULL generally do not effectively utilize indexes (depends on DBMS specifications).

Negation or OR

SELECT * FROM users WHERE amount <> 10;

Negation cannot utilize indexes. The same applies to OR.

LIKE

SELECT * FROM users WHERE name = 'a%';

When using LIKE, only forward matches utilize indexes due to the nature of B-Tree.

Implicit Type Conversion

SELECT * FROM users WHERE age = '10'

If age is a numeric type, implicit conversion from string to number will prevent index utilization.

References

What is GraphQL

Kenta Takeuchi — Sun, 15 Mar 2026 11:20:34 +0000

What is GraphQL

Developed by Facebook
A query language for APIs
- User-friendly because the data format of API requests and responses are similar
REST is an architecture (design), while GraphQL is a language (DSL)

Comparison of REST API and GraphQL

REST API Format

Send requests to endpoints using HTTP verbs

curl https://api.bmf-tech.com/v1/configs

[
    {
        "id": 1,
        "name": "title",
        "alias_name": "Title",
        "value": "bmf-tech",
        "created_at": "2017-09-25 23:08:23",
        "value": "bmf-tech",
        "deleted_at": null
    }
]

GraphQL API Format

Send queries to a single endpoint

curl https://api.bmf-tech.com/api

configs {
  id,
  name,
  alias_name
  value,
  created_at,
  updated_at,
  deleted_at
}

[
    {
        "id": 1,
        "name": "title",
        "alias_name": "Title",
        "value": "bmf-tech",
        "created_at": "2017-09-25 23:08:23",
        "value": "bmf-tech",
        "deleted_at": null
    }
]

	REST API	GraphQL
Endpoints	Multiple	Single
HTTP Verbs	Dependent	Independent
Type System	None	Available
Versioning Required	Yes	No
Documentation Required	Yes	No
Resource Limitation	Mainly call count	Handled according to resource amount

Flexibly specify the desired data for a single endpoint
- REST has fixed response data for each endpoint.
- GraphQL allows specifying the desired data for a single endpoint to get the response data.
Resource limitation requires ingenuity
- Handled according to resource amount
- Need to consider methods for load calculation, such as based on the number of objects
Almost no need for documentation
- API definition serves as documentation
- The query structure and response data structure are almost the same

Points of Concern

Dependency on libraries
- Requires libraries for parsing queries
Not necessarily better performance than REST API
- Reduces the number of requests
- Increases the amount of data per request
- Need to control data volume in both REST API and GraphQL (e.g., pagination, field specification)
Monitoring
- REST API can be monitored per endpoint
- GraphQL is a single endpoint, making it difficult to monitor response performance per query. Some measures are needed.
- Wait for ecosystem maturity or implement in-house
Caching
- Cannot use HTTP cache
- Should investigate various other aspects

Impressions

In applications with many components and complex UIs, where the number of requests increases and the client side struggles, there may be benefits to introducing it.
Considered using it with Rubel, but decided against it as it feels premature. Currently unnecessary.

References

What is Duck Typing? How Dynamic Type Checking Works in Python, Ruby, and Go

Kenta Takeuchi — Sun, 15 Mar 2026 11:20:02 +0000

Overview

A summary of duck typing

What is Duck Typing

In dynamically typed object-oriented programming languages, what an object can do is determined by the object itself.
An object that has all the methods of an interface can be considered to implement the interface, even if it does not explicitly implement it.
If it walks like a duck and quacks like a duck, it must be a duck.

References

Wikipedia - ダック・タイピング

What is Docker? A Beginner's Complete Guide to Containers

Kenta Takeuchi — Sun, 15 Mar 2026 11:20:01 +0000

What is Docker

A platform developed by Docker Inc. for creating, distributing, and running container-based virtual environments
Uses Linux container technology
- Containers utilize the host machine's kernel to isolate processes and users
- Lightweight and fast
Middleware and various environment settings can be managed as code (=Infrastructure as Code)
- Regardless of local or production environments
- Anyone can create the same environment
- Easy redistribution and reuse of environments
The essence of Docker
- Linux Container (LXC)
- A container management tool to simplify customization of containers in LXC (such as creating configuration files and installing files via shell scripts)
Docker for Mac
- Uses the virtualization tool HyperKit, which is included by default on Mac, to launch a virtual machine and run Linux to enable Docker

What is a Container (Linux Container)

A set of processes isolated from the rest of the system
- Runs from a separate image that provides all the files necessary to support the processes
Shares the OS and kernel, isolating application processes from the rest of the system (runs on a single OS)

Differences Between Other Virtual Environments and Containers

General PC

Configuration

  [Host OS]
  [Hard Disk]

Host OS Type (sometimes defined as hypervisor type using host OS in a broad sense)

Configuration

  [Guest OS]
  [Virtualization Software]
  [Host OS]
  [Hard Disk]

Advantages
- Easy to achieve virtualization
- High freedom in OS selection
Disadvantages
- High consumption of disk and memory

Hypervisor Type (using hard disk pattern)

Configuration

  [Guest OS]
  [Hypervisor]
  [Hard Disk]

Advantages
- Can control hardware directly without needing host OS processing, resulting in faster processing speed
Disadvantages
- Not easy to achieve virtual environments (may not be able to use the host OS as is, or may require a dedicated physical server)

Container Type

[Container Management Software]
[Host OS]
[Hard Disk]

Advantages
- Easy to achieve virtual environments
- Low consumption of disk and memory
Disadvantages
- Can only use OS that utilizes the Linux kernel

Overview of Docker Images and Containers

                Docker repository(Ex. Docker Hub)

                         ↓ (pull)

Dockerfile   →     Docker Image    →    Docker Container
                 (build)                           (run)   
                                      ↓ (commit)

                             Docker Image    →    Docker Container
                                                       (run)

※ Differences between Host OS Type and Hypervisor Type
Think IT - What are the differences between Host Type and Hypervisor Type? Overview of VMware vSphere Hypervisor is a useful reference.

Host OS Type
- Install virtualization software on the OS
- Access to hardware is via the host OS, causing overhead and not fully utilizing performance.
Hypervisor Type
- Install directly on the server without needing a host OS.
- Can directly control hardware, making it easier to achieve performance.

Basic Commands

docker build
- Create an image from a Dockerfile
docker run
- Launch a container from an image
docker commit
- Create an image from a container

Additional Information

What is a Kernel
- Software responsible for the basic functions of the OS
- It's generally difficult to use the OS with just the kernel, so it's commonly used in combination with other software
- Kernel + Software = Distribution
- CentOS or Ubuntu → Linux kernel + software distribution

DEV Community: Kenta Takeuchi

Writing Code That Fits in Your Brain: Heuristics and Techniques to Avoid Complexity and Ensure Sustainability

The Art of Writing a CFP

Overview

Past Achievements

My Way of Writing a CFP

Before Writing a CFP...

Consider the Purpose of Speaking

Decide on the Event to Speak At

Thoroughly Check the Event Schedule

How to Write a CFP

Prepare the Idea

Write a Blog

Write the CFP

Session Title

Event Information

CFP

Acceptance Criteria

What to Talk About / What Not to Talk About

What I Want to Convey

Keywords

Outline

Slide Draft

Research

CFP Examples

Go Conference 2021/Introduction to Building an HTTP Router with net/http

Go Conference 2023/The Ultimate HTTP Router Dance

Conclusion

Thoughts

Aside

Things to Keep in Mind When Creating Slides

Things to Consider When Writing Architecture Documents

Overview

Clarify the Purpose

Characteristics the Document Should Have

Accuracy

Sufficiency

Conciseness

Clarity

Relevance

Precision

Example Structure

Introduction

Requirements Definition

Architecture Diagram

Data Model

Use Cases

Technical Details

Risks and Issues

Outlook

Unresolved Issues

Related Documents

Conclusion

References

Writing to Remote Files with Ansible

Overview

Playbook

Thoughts

References

Why and When to Write an Architecture Strategy

What Happens Without a Strategy

Ad Hoc Technology Selection

Misguided Prioritization

Means Becoming the End

Postponing Debt Management

When to Write a Strategy

Making the Strategy Work

Conclusion

Polymorphism Explained: How Object-Oriented Code Stays Flexible

Overview

What is Polymorphism

Types of Polymorphism

References

The N+1 Problem Explained: How to Detect and Fix It in Go/Rails

Overview

What is the N+1 Problem

Example

Solutions

References

Linux Load Average Explained: How to Read and Diagnose Performance Issues