DEV Community: aiw3n

I built a Ruby hosting platform and I'm looking for 10 early adopters (free for 3 months)

aiw3n — Fri, 09 Oct 2026 12:16:32 +0000

Hi everyone,

I'm a Rubyist and I've been building Enkihost, a hosting platform focused on Ruby and Rails apps. The idea is simple: something between "Heroku is too expensive" and "managing my own VPS is too much work".

Where it stands today: deploys take around 11 seconds, and you get a dashboard with logs, domains, a terminal, config, add-ons and backups.

Where it doesn't stand yet: it has no users. That's why I'm here.

I'm looking for 10 people willing to host a real app (side projects are perfect) for free for 3 months. In exchange I'd love honest feedback: what's confusing, what's missing, what breaks.

If you're interested, comment or DM me. Happy to answer any questions about how it works under the hood.

enkihost.com

The Challenges of Vibe Coding: Staying Focused Amidst Memory Chaos

aiw3n — Sun, 06 Apr 2025 13:49:32 +0000

As developers, we’ve all been there—coding away, only to find ourselves suddenly caught up in a stream of unrelated ideas or thoughts. It’s like we’re coding in the "vibe," but at the same time, we have to juggle multiple mental threads to avoid losing track of the task at hand.

One of the most unique aspects of vibe coding is the constant mental balancing act. We need to keep an active memory of all the concepts, pieces of code, or tasks we’ve touched during our coding journey. This is particularly challenging when there are multiple threads of conversation or tasks involved, such as while working on a collaborative project or engaging in discussions during pair programming or team meetings.
The Memory Challenge

When coding in this "vibe" mode, it’s like our brains are hosting a chat with ourselves. Every idea or concept we interact with needs to be stored somewhere to ensure we don’t stray from our goal. You have to maintain the "memory" of where you left off with each part of the task, especially if it’s a multi-step process or involves jumping between different files or languages. This can get messy and overwhelming.

Imagine, for example, you’re working on a specific function, but midway through, you’re distracted by a potential optimization or a bug elsewhere in the codebase. You must quickly switch gears, remember where you left off, and then shift back into the groove of the original task. The mental strain of continuously refocusing on the task at hand, without getting lost in side thoughts, can be exhausting.
How to Keep the Flow

So, how do you navigate vibe coding without losing track of the task? A few strategies that might help:

Break Tasks Down: Having clear, manageable tasks and goals makes it easier to stay on track. Instead of focusing on the entire project at once, break down tasks into smaller, more digestible pieces.

Use Tools to Your Advantage: Take advantage of your code editor’s features like comments, bookmarks, and tasks lists. These simple features can help keep track of what’s next and avoid forgetting what you were doing when you got distracted.

Timeboxing: Set short intervals of focus time (like the Pomodoro technique) where you concentrate solely on the current task, and during breaks, clear your mind of unrelated thoughts.

Collaborative Tools: In team environments, collaborative platforms like Slack, Jira, or Trello can serve as external memory banks for keeping track of where each task or discussion stands, reducing the mental load.

The Payoff

Despite the inherent challenges, vibe coding can be incredibly productive if approached with the right mindset and tools. The key is recognizing when you’re getting sidetracked and reining yourself back in, while still embracing the creative process.

It’s a delicate balance, but when you manage it, you can code with purpose, productivity, and, of course, good vibes.

Why Declare Components as Standalone in Modern Angular

aiw3n — Sat, 23 Nov 2024 17:30:55 +0000

Modern Angular versions introduced standalone components, a feature that simplifies project structure, enhances modularity, and reduces boilerplate. This approach makes Angular development more intuitive and aligns well with other modern frameworks like React or Vue. This post will explain why you should use standalone components and show how to implement them with an example.

What Are Standalone Components?

In traditional Angular, components are declared within NgModules. To use a component, directive, or pipe, you had to include it in a module and import that module in other parts of the app. While powerful, this approach has some drawbacks:

Overhead: Managing modules can be tedious, especially in large projects.
Complexity: Circular dependencies and unnecessary module imports can arise.
Tightly Coupled: Components are bound to specific modules, reducing flexibility.

Standalone components eliminate the need for NgModules. These components, along with standalone directives and pipes, declare their dependencies directly, resulting in simpler and more modular applications.

Why Use Standalone Components?

Simplified Modular Design

Each component is self-contained, with all dependencies declared directly in the component.
Reduced Boilerplate

There’s no need to create and maintain NgModules, leading to less repetitive code.
Improved Tree-Shaking

Angular can optimize the app more effectively by removing unused components.
Faster Development

Components can be created and used without worrying about module configuration.
Future-Proof

Standalone components are a core part of Angular's future, ensuring your applications are up-to-date with the latest standards.

Example: A Standalone Component with FormsModule

Let’s build a standalone PostFormComponent that allows users to create blog posts using Angular’s FormsModule.

1. Create the Component

Run the following command to generate the standalone component:

ng generate component post-form --standalone

2. Implement the Component

Here’s the code for post-form.component.ts:

import { Component } from '@angular/core';
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-post-form',
  standalone: true,
  imports: [FormsModule],
  template: `
    <form (ngSubmit)="submitForm()" #postForm="ngForm">
      <div>
        <label for="title">Title:</label>
        <input id="title" name="title" [(ngModel)]="post.title" required />
      </div>
      <div>
        <label for="content">Content:</label>
        <textarea id="content" name="content" [(ngModel)]="post.content" required></textarea>
      </div>
      <button type="submit" [disabled]="postForm.invalid">Submit</button>
    </form>
    <div *ngIf="submitted">
      <h3>Post Preview</h3>
      <p><strong>{{ post.title }}</strong></p>
      <p>{{ post.content }}</p>
    </div>
  `
})
export class PostFormComponent {
  post = {
    title: '',
    content: ''
  };
  submitted = false;

  submitForm() {
    this.submitted = true;
  }
}

3. Use the Component

You can now bootstrap the standalone component directly in main.ts:

import { bootstrapApplication } from '@angular/platform-browser';
import { PostFormComponent } from './post-form.component';

bootstrapApplication(PostFormComponent)
  .catch(err => console.error(err));

This approach eliminates the need for an AppModule. You directly bootstrap the PostFormComponent, making the application structure cleaner and more modular.