DEV Community: Israel Olaleye

SSH Keys in 2024: Why Ed25519 Replaced RSA as the Default

Israel Olaleye — Thu, 26 Mar 2026 18:20:35 +0000

If you've ever set up GitHub, configured a server, or worked with remote machines, you've encountered SSH keys. Take a look in your ~/.ssh/ directory and you'll likely find files named id_rsa or id_ed25519. These represent two generations of cryptography—and understanding the difference matters for both security and performance.

What These Files Actually Are

SSH keys come in pairs: a private key (kept secret on your machine) and a public key (shared with servers). The names id_rsa and id_ed25519 refer to the cryptographic algorithms used to generate them:

	`id_rsa`	`id_ed25519`
Algorithm	RSA (1977)	Ed25519 (2011)
Mathematical foundation	Integer factorization	Elliptic curve cryptography
Key size	2048–4096+ bits	Fixed 256 bits
Standard since	Early SSH days	OpenSSH 6.5+ (2014)

The Technical Shift

RSA relies on the difficulty of factoring large prime numbers which is a problem that has served cryptography for decades but requires increasingly large keys to maintain security. Modern 2048-bit RSA keys offer roughly 112 bits of security.

Ed25519 uses elliptic curve cryptography (specifically Curve25519 designed by Daniel Bernstein). Despite its compact 256-bit size, it provides approximately 128 bits of security with significantly better performance characteristics.

Real-World Performance Differences

The contrast becomes noticeable in practice:
Key generation: Ed25519 is nearly instantaneous; RSA with 4096 bits takes perceptibly longer.

Authentication speed: Ed25519 signatures are smaller (64 bytes vs 256 bytes for RSA 2048) and faster to verify—relevant when connecting to busy servers or working from low-power devices.

Storage efficiency: Public keys shrink from ~500 bytes to 32 bytes. On systems managing thousands of keys, this adds up.

When to Use Which

Choose Ed25519 for:

New projects and fresh setups
Modern servers running OpenSSH 6.5 or later
Resource-constrained environments (embedded systems, mobile devices)
Any situation where you control both endpoints

Keep RSA for:

Legacy infrastructure (old network equipment, aging enterprise systems)
Environments with strict compliance requirements mandating specific algorithms
Interfacing with systems that haven't updated their SSH implementations since ~2014

Most major platforms—GitHub, GitLab, AWS, Azure—have supported Ed25519 for years. The remaining compatibility concerns typically involve specialized hardware: load balancers, industrial controllers, or vintage corporate infrastructure.

Practical Migration
Generating a modern key takes one command:

ssh-keygen -t ed25519 -C "your_email@example.com"

This creates ~/.ssh/id_ed25519 and ~/.ssh/id_ed25519.pub. Add the public key to your services, update your SSH config if needed, and gradually retire RSA dependencies.

If you maintain both, SSH will try keys in order—Ed25519 typically first—falling back to RSA only when necessary.

Looking Forward
Cryptography evolves. Ed25519 represents a deliberate design: rigidity (no variable parameters to misconfigure), speed, and resistance to side-channel attacks. It won't resist quantum computing—no mainstream public-key algorithm does yet—but it represents current best practice.

RSA isn't broken. 4096-bit keys remain secure for now. But Ed25519 achieves equivalent or better security with elegance and efficiency. For new work in 2024, it's the clear default.

Check your current keys with ls -la ~/.ssh/ and consider whether your setup reflects modern standards or inherited legacy.

How to Add a Link or Hyperlink in README.md File

Israel Olaleye — Wed, 23 Jul 2025 14:32:17 +0000

As a software engineer, one of the first things I learned after pushing my code to GitHub was the importance of a well-structured README.md file. Whether you're open-sourcing a library, sharing a project with your team, or just documenting something for future-you, your README is often the first impression people get of your work.

One of the most common elements you'll need to include in a README is a hyperlink—maybe to your live site, an external documentation page, or even another file in your repository. It sounds simple, but if you're new to Markdown, you might not know the exact syntax.

Let me walk you through it.

Basic Markdown Link Syntax

In Markdown, you add a hyperlink using this syntax:

[Link Text](https://example.com)

Link Text is the clickable text that will be shown.
https://example.com is the URL the user will be taken to when they click the link.

Example:

Check out my portfolio [here](https://yourwebsite.com).

When rendered, that line becomes

Check out my portfolio here.

Linking to Another File in Your Repo
Sometimes you’ll want to link to another file inside your own project repository—maybe a contribution guide, license, or even another markdown file.

Here’s how:

[CONTRIBUTING.md](CONTRIBUTING.md)

This assumes CONTRIBUTING.md is in the same directory as your README.md.

If it's in a subfolder:

[View API Docs](docs/API.md)

Opening in a New Tab? Not with Vanilla Markdown
If you're coming from HTML, you might be tempted to write this:

<a href="https://example.com" target="_blank">Click me</a>

But most Markdown processors — including GitHub's — don’t support target="_blank". Markdown links open in the same tab by default. If you really need the target="_blank" behavior, you’ll have to fall back to raw HTML:

<a href="https://example.com" target="_blank">Click me</a>

This works in GitHub-flavored Markdown, which supports inline HTML.

Bonus: Reference-Style Links

If you're trying to keep things clean and readable—especially for long documents—reference-style links are a great option:

Read the [official docs][docs-link].

...

This separates the content from the links, which is nice for large documentation files.

My Final Thoughts

I can’t count how many times I’ve had to Google “how to add a link in Markdown” when writing README files in my early days. But once you get the hang of it, it becomes second nature. The simplicity of Markdown is actually what makes it so powerful.

Whether you're linking to your deployed site, another file in your repo, or an external tutorial, now you know exactly how to do it—clean, professional, and properly formatted.

Let your README.md file speak for your project. It's more than just a document—it's your first impression to the world.

JavaScript Data Structures and Algorithm.

Israel Olaleye — Mon, 21 Feb 2022 20:55:35 +0000

High-level data structures are methods of storing and organizing data so that it can be easily modified, navigated, and accessed. Data structures define how data is collected, the functions we can use to access it, and relationships between data.

Data structures are used in almost every area of computer science and programming, from operating systems to simple vanilla code to artificial intelligence.

Data structures enable us to:
• Manage and utilize large datasets
• Search for particular data from a database
• Design algorithms that are tailored towards particular programs
• Handle multiple requests from users at once
• Simplify and speed up data processing

Data structures are essential for efficient problem solving in the real world. Finally, how we organize data has a huge impact on performance and usability. In fact, most top companies require a strong understanding of data structures.

JavaScript has primitive and non-primitive data structures. Primitive data structures and data types are native to programming languages. These include Boolean values, nulls, numbers, strings, and more. Non-primitive data structures are defined by the programmer, not the programming language. These include linear and static data structures, as well as dynamic data structures such as queues and linked lists.

Array
The most basic array of all data structures stores data in memory for later use. Each array has a fixed number of cells that are determined at creation time, and each cell has a corresponding numeric index used to select the data. Whenever you use an array, you only need the index you want, and you can access any data in it.
Queues
Queues are conceptually similar to stacks; both are sequential structures, but queues process items in the order they were entered, not the order they were last entered.
Therefore, queues can be configured as a FIFO (First In, First Out) are viewed from stacks. These are useful as buffers for requests, storing each request in the order it was received until it can be processed.
Linked List
Linked lists are a data structure that, unlike the previous three, does not use physical placement of data in memory. This means that linked lists use a referencing system instead of indices or positions: elements are stored in nodes containing a pointer to the next node, which is repeated until all nodes are linked.

This system enables items to be loaded and unloaded efficiently without reorganization.

JavaScript 101: Ultimate JavaScript Guide.

Israel Olaleye — Mon, 14 Feb 2022 06:42:53 +0000

*JavaScript Overview *
Let's take a look at what's special about JavaScript, what you can do with JavaScript, and what other technologies work well with JavaScript.

What is JavaScript?
JavaScript was originally created to "bring web pages to life". Programs in this language are called scripts. These can be written directly in the HTML of the web page and will be executed automatically when the page loads. The script is provided and executed as plain text. No special preparation or compilation is required to run it. In this respect, JavaScript is very different from another language called Java.

Today, JavaScript can be executed not only in the browser, but also on the server, or actually on any device with a special program called the JavaScript Engine. The browser has a built-in engine sometimes called a "javascript virtual machine".

Different engines have different "code names". For example:

V8 - in Chrome, Opera and Edge.
SpiderMonkey - in Firefox.

... There are other code names like "Chakra" for IE, "JavaScriptCore", "Nitro", "SquirrelFish" for Safari, etc. It's a good idea to remember the terms above because they are used in developer articles on the Internet. We'll use it too. For example, if "Feature X is supported by V8", it probably works in Chrome, Opera, and Edge.

Code editors
A code editor is the place where programmers spend most of their time.
There are two main types of code editors: IDEs and lightweight editors. Many people use one tool of each type.

IDE
The term IDE (Integrated Development Environment) refers to a powerful editor with many features that would normally run on a "complete project". As the name implies, it is not just an editor, but a "complete development environment".

The IDE loads the project (which can be many files), allows navigation between files, provides auto-completion based on the entire project (not just the open file), and integrates With a version management system (such as git), a test environment, and other "project level" elements. If you haven't selected an IDE yet, consider the following options:

• Visual Studio Code ( across platforms, for free). 
• WebStorm (cross-platform, paid).

Light Weight Editor

A "lightweight editor" isn't as powerful as an IDE, but it's fast, elegant, and simple. Mainly used to open and edit files instantly. The main difference between "lightweight editor" and "IDE" is that the IDE works at the project level, so it has much more data at the start and analysis. Is to load. Project structure etc. as needed. If you only need one file, the lightweight editor is much faster. In fact, lightweight editors may contain a number of plugins such as directory-level syntax analyzers and autocompleters. There is no strict boundary between the lightweight editor and the IDE. The following options are noteworthy: Atom (cross-platform, free). Sublime Text (cross-platform, shareware). Notepad ++ (Windows, free). Vim and Emacs are also cool if you know how to use them.

The modern mode, "use strict"
• Variables
• Data types
• Interaction: alert, prompt, confirm
• Type Conversions
• Basic operators, maths
• Comparisons
• Conditional branching: if, '?'
• Logical operators
• Nullish coalescing operator '??'
• Loops: while and for
• The "switch" statement
• Functions
• Function expressions
• Arrow functions, the basics
• JavaScript specials
• Objects
• Object references and copying
• Garbage collection
• Object methods, "this"
• Constructor, operator "new"
• Optional chaining '?.'
• Symbol type
• Object to primitive conversion

Just to mention a few to start with.