DEV Community: Salajan Silviu

How I Built a Git Log Diff Workflow Plugin for Neovim

Salajan Silviu — Mon, 19 Jan 2026 10:03:44 +0000

When I switched fully to Neovim a while back, one of the things I missed most from JetBrains IDEs (like RubyMine) was Git integration, especially the Git log view I’d use every day to quickly inspect recent commits and diffs. In RubyMine I’d often ask: “What changed in the last three commits?” and get an instant interactive history view.

Neovim, however, doesn’t have this kind of UI built in, and while there are many Git plugins out there (from inline signs like gitsigns.nvim to full interfaces like Neogit), none gave me exactly the workflow I wanted: a compact “pick commits, then diff them” experience.

So I built a plugin for that: gitlogdiff.nvim: a tiny Neovim plugin for listing recent Git commits and quickly seeing their diffs.

What gitlogdiff.nvim Does

At its core, gitlogdiff.nvim gives you:

A simple commit list, sourced from git log, showing your recent history
Easy navigation with j/k and selecting commits with
Pressing opens a diff view (via diffview.nvim) comparing commits

This workflow feels much closer to the Git log explorer I used in JetBrains, right inside Neovim, without leaving your editor.

Try It & Feedback

The plugin is on GitHub - here. Drop issues, ideas, or pull requests! It’s meant to stay lightweight but extendable, and someday might support alternative diff viewers beyond Diffview too.

Happy viming! 🧑‍💻

ActiveRegistration: Simple User Sign-Up in Rails 8

Salajan Silviu — Mon, 07 Apr 2025 11:02:51 +0000

My girlfriend had an exciting app idea (more on that in future posts), I saw it as the perfect opportunity to explore Rails 8 and its latest features. One highlight of Rails 8 is the native authentication generator, designed to simplify user authentication without relying on external gems like Devise. However, I quickly realized that while this generator efficiently manages user sessions and password handling, it doesn't offer a built-in user registration (sign-up) feature.

To bridge this gap, I developed active_registration, a Rails engine that seamlessly adds user registration with email confirmation to Rails 8+ applications utilizing the native authentication generator. This gem is designed as a drop-in solution, enabling developers to incorporate robust user registration functionality without starting from scratch.

By creating it, my goal was to provide a straightforward and customizable way to enhance Rails 8's native authentication capabilities, allowing developers to implement comprehensive user registration with email confirmation effortlessly.

GitHub
RubyGems

Switching Fully to Neovim

Salajan Silviu — Wed, 05 Feb 2025 13:05:15 +0000

A while back, I shared my initial experiments with a minimalist Neovim environment after switching from RubyMine (my previous post). Today, I’m excited to announce that I’ve made the full leap to Neovim. While my new configuration isn’t 100% polished yet, it’s exactly what I need for now—and I’m committed to refining it over time.

The Transition: Why Neovim?

After years of relying on a heavyweight IDE like RubyMine, I found myself craving a leaner, more customizable experience. Neovim offered:

Efficiency: A fast, lightweight editor that allows me to tailor every aspect of my workflow.

Flexibility: The ability to integrate plugins and customizations.

Minimalism: A focus on doing one thing well without the overhead of unnecessary features.

The switch wasn’t just a change of editor; it was a leap forward, reclaiming control over my coding environment.

As I continue to refine my config, I want to document my changes and share them with the community.

My Neovim Configuration

Since making the switch, I’ve built a setup that aligns with my needs. My current configuration includes a carefully selected set of plugins and settings that enhance my workflow without adding unnecessary bloat.

Plugins I Use

catppuccin.lua - Aesthetic color scheme
completions.lua - Autocompletion support
copilot.lua & copilotchat.lua - GitHub Copilot integration
diffview.lua - Git diffs in a side-by-side view
harpoon.lua - Quick file navigation
lsp-config.lua - Language Server Protocol configurations
oil.lua - File explorer enhancements
telescope.lua - Fuzzy finder for files, symbols, and more
treesitter.lua - Better syntax highlighting and parsing
undootree.lua - Advanced undo history navigation
fugitive.lua - Git integration
zenmode.lua - Distraction-free writing mode

This vim options are also a very important part of my plugin.

My configuration was inspired by several great sources, including lazyvim starter, ThePrimeagen’s dotfiles, kickstart.nvim, and Typecraft’s Rails config. These provided a strong foundation that I’ve adapted to fit my workflow.

Additionally, I integrate several CLI tools into my work flow, such as lazygit for streamlined Git operations, yazi as a terminal file manager, tmux for session management, and lazydocker for handling Docker containers efficiently.

What I Love

Speed and Responsiveness: The editor is blazingly fast, even when handling larger projects.

Customization: The ability to fine-tune every aspect of the editor means I can constantly adapt it to my evolving workflow, and I love to do that.

Community Plugins: I’m continually discovering plugins that help fill in gaps and extend Neovim’s capabilities.

Final Thoughts

Switching fully to Neovim has been both a liberating and challenging experience. My new configuration is a work in progress, perfectly tailored for today’s needs, with plenty of room for growth. I hope that by sharing my journey, others might be inspired to take control of their coding environments, too.

I’m excited about what the future holds for this setup—and I invite you to follow along as I refine and improve my Neovim experience.

Vim: Minimalist Environment

Salajan Silviu — Fri, 15 Nov 2024 09:50:14 +0000

Hey Devs! 👋

I wanted to share my ongoing journey into using vim, a transition inspired by a few key motivations: embracing a minimalist coding environment, reducing mouse use to prevent wrist pain (here's an article about mouse-related wrist pain), and ultimately boosting my speed in navigating files.

Where I Started

I began my coding journey with Sublime Text and later explored RubyMine, Atom, and VSCode. These editors served me well, but I always found myself seeking something more streamlined. Today, I primarily use RubyMine with the IdeaVim plugin and Fuzzier for work. My simple config can be found here. For my personal projects, I’ve opted for neovim with the LazyVim starter and a few tweaks. In the next few articles, I'll dive deeper into my journey of setting up neovim from scratch. I'll be sharing my step-by-step process, configurations, and tips that have helped me make neovim my go-to for side projects. Stay tuned if you're curious about building a minimalist, powerful editing environment!

Why the Shift?

My role involves frequent code reviews, branch comparisons, and commit diffs, and I absolutely love RubyMine’s diff tool (which is great across JetBrains products). For a potential vim alternative, I’ve come across diffview.nvim I haven't tried it yet, but it looks promising! At home, I use LazyGit, which is great but occasionally leaves me wishing for more robust features.

Keyboarding for Comfort

Another key part of my shift is reducing strain from my current small mechanical keyboard and gaming mouse. Ergonomic options are on my radar for the future. Less mouse usage + ergonomic setup = happier wrists!

Vim Joys

What keeps me coming back to Vim? Quick text replacements using search (/text) and n to jump, followed by cgn to edit is such a delight! Navigating with f and ,, ; to jump around characters is another favorite. I also love the efficiency of ciw (change inner word) and caw (change a whole word, including whitespace) for rapid edits. Moving instantly to the top of a file with gg or to the end with G saves so much scrolling time, and the zz command centers the screen on the current line, keeping my focus exactly where I need it. Vim truly turns text editing into a fluid experience!

I'm still learning, experimenting, and making adjustments along the way.
I'd love to hear your experiences with vim or any recommendations you might have!

SDLC for Developers: Efficient Workflows and Best Practices

Salajan Silviu — Wed, 09 Oct 2024 09:13:09 +0000

When working on development tasks or tickets, it's essential to follow a well-defined workflow to ensure consistency, code quality, and proper functionality. Below is an outline of my SDLC workflow, highlighting critical steps that should be followed during the development of new features or fixing bugs.

1. Requirement Analysis and Internalization

The first and most crucial step in the process is understanding the requirements thoroughly. This involves:

Analyzing the task or ticket: Carefully review the requirements provided.
Testing the current functionality: Get a clear understanding of how the system works in its current state.
Identifying the required changes or extensions: Grasp the modifications needed to meet the new requirements.

If anything is unclear, it's important to ask questions early on (e.g., through meetings, comments on tickets, or emails). Properly documenting the questions and answers will help clarify expectations and reduce miscommunication, ensuring alignment between stakeholders and developers.

2. Implementation

2.a Code Implementation

Once the requirements are fully understood, proceed to implement the changes. Keep in mind:

Follow best practices regarding naming conventions for variables and functions.
Adhere to the coding standards already established within the team to maintain consistency.
Refactor any legacy code if necessary, especially if it can be improved during implementation.

2.b Implement Model Tests (if necessary)

If the task requires it, write tests for the model layer. These ensure that core business logic remains stable and behaves as expected with the new changes.

2.c Manual/Exploratory Testing with Common Values

After implementing the changes, conduct manual and exploratory testing using typical values. This ensures that your code works correctly under normal conditions.

2.d Self-Code Review

Before submitting your code for review, perform your own thorough check. This includes:

Reviewing the business logic and ensuring that the model and design meet the requirements.
Conducting a formal code review, making sure that the coding style, formatting, and other structural elements follow best practices.

Steps 2.a, 2.b, 2.c, and 2.d should be repeated iteratively until the desired result is achieved and all issues have been resolved.

3. Testing Edge Cases and Interdependencies

3.a Testing with Edge Cases and Non-Standard Values

Once you're satisfied with the initial implementation, move on to more rigorous testing, focusing on:

Boundary values, non-standard data, and edge cases.
Potentially unexpected or rare situations that the application might face.

If any issues arise, you may need to revisit steps 2.a to 2.d.

3.b Testing Connected Features

After verifying the functionality in isolation, test other related features that could be impacted by the changes. It's important to ensure that no unintended side effects have been introduced. If necessary, return to the previous steps to address any new issues discovered during this phase.

4. Running Tests and Implementing Feature Tests

4.a Running Tests and Specs

Execute a relevant subset of automated tests and specs that could be affected by the changes. If the changes break existing tests, you’ll need to go back to step 2.a and modify the implementation accordingly. In some cases, this might involve adapting or adding to the existing specifications to better cover the new functionality.

4.b Implementing New Feature Tests

Finally, implement new feature tests to ensure comprehensive coverage of the new functionality. Ideally, these tests should extend existing ones by adding additional assertions without introducing too much redundant code (i.e., avoid excessive copy-pasting). If it's not possible to extend existing tests, create dedicated feature tests for the new functionality.

5. Continuous Integration and Continuous Deployment (CI/CD)

CI/CD is essential in modern software development. By integrating code frequently and deploying it automatically, you:

Reduce integration problems: Regular code merges ensure that conflicts are identified and resolved early.
Catch bugs early: Automated tests run during the integration process, identifying potential issues before they reach production.
Speed up release cycles: CI/CD pipelines streamline the deployment process, making it easy to deploy small, incremental updates quickly.

Incorporating CI/CD into the workflow ensures continuous improvement and allows for fast iteration.

6. Version Control and Branching Strategy

Effective use of version control systems (e.g., Git) is critical to managing code changes, especially when working in teams:

Feature branches: Work on individual features in separate branches to avoid impacting the main codebase until the feature is complete.
Pull requests: Ensure code is reviewed by peers before it is merged into the main branch.
Hotfix branches: In case of critical bugs in production, use dedicated hotfix branches to apply urgent patches without disrupting ongoing development.
Rebasing and merging: Use appropriate strategies (e.g., rebasing for cleaner history or merging for preserving context) to manage branches.

Following a well-defined branching strategy can streamline collaboration and reduce complexity in the codebase.

7. Documentation

Proper documentation is a critical part of SDLC, and it should not be overlooked:

Technical documentation: Provide clear and detailed information on how your code works. This includes architectural diagrams, API documentation, and usage examples.
User-facing documentation: If needed, offer user guides, installation manuals, or help sections for end users.
Inline documentation: Use comments within the codebase to explain complex logic or important decisions.

Well-maintained documentation not only helps current team members but also future developers who may work on the project.

8. Security Considerations

Security should be embedded into every phase of the SDLC, from requirement gathering to deployment:

Security requirements: Identify security needs during the analysis phase, including data encryption, authentication, and authorization mechanisms.
Code security: Implement secure coding practices to avoid common vulnerabilities (e.g., SQL injection, cross-site scripting, CSRF, insecure deserialization, broken authentication and session management, security misconfiguration, dependency scanning for secure libraries, input validation, least privilege principle, error handling and logging).

Use static analysis tools to detect vulnerabilities in the code.
Security testing: Perform regular security audits, penetration testing, and vulnerability scanning to ensure the system is protected from potential attacks.

Incorporating security into SDLC is crucial to safeguard data and build trustworthy software.

9. Performance Optimization

Ensuring your application performs efficiently is another vital aspect of SDLC:

Profiling and monitoring: Identify bottlenecks through profiling tools and real-time performance monitoring.
Optimization strategies: Optimize the code, database queries, and infrastructure to enhance response time and scalability.
Load testing: Simulate high traffic to ensure the application can handle peak loads without crashing or slowing down.

Performance tuning helps maintain a positive user experience, especially as the system scales.

10. User Acceptance Testing (UAT)

User Acceptance Testing is a critical phase where the end users verify that the product meets their requirements:

Feedback from end users: Involve actual users or stakeholders in testing to ensure that the product meets business goals and is user-friendly.
Iterative feedback loops: Incorporate feedback from UAT into further development cycles to continuously improve the product.
Sign-off: Once UAT is successful, stakeholders provide sign-off, indicating that the feature is ready for production.

UAT ensures that the software aligns with the user's expectations before final deployment.

11. Deployment and Release Management

Deployment is a critical part of SDLC, as it marks the point where the software becomes available for use:

Deployment plan: Establish a structured deployment plan with clear steps and fallback options (rollback strategy) in case issues arise.
Staging environments: Test the software in a staging environment that closely resembles production to ensure everything works as expected.
Release scheduling: Plan releases around business needs, and avoid peak times to reduce risks.

Effective deployment management minimizes downtime and ensures a smooth transition from development to production.

12. Post-Release Maintenance and Support

Once the software is in production, it enters the maintenance phase. This involves:

Monitoring: Use application monitoring tools to track performance and error logs in real-time.
Bug fixing: Quickly address any issues that arise after deployment.
Feature updates and patches: Continuously improve the software by adding new features or applying security patches.

By rigorously following these steps, you will not only ensure high-quality code but also minimize errors and regressions, resulting in a more stable and maintainable product.

The Evolution of Ruby Version Management

Salajan Silviu — Tue, 03 Sep 2024 08:43:59 +0000

Managing Ruby versions has been a cornerstone of any developer's toolkit since the early days of Ruby's popularity. Over the years, several Ruby version managers have emerged, each with its unique strengths and weaknesses. This article explores this evolution, focusing on why Mise has become my preferred choice.

The Beginnings with RVM

For many Ruby developers, myself included, RVM (Ruby Version Manager) was the first introduction to managing multiple Ruby versions on the same machine. RVM's comprehensive feature set and ease of use made it incredibly popular. It allowed developers to switch between Ruby versions seamlessly, isolate project environments with gemsets, and manage dependencies effortlessly.

As a hardline lover of RVM, I appreciated its all-in-one nature. It was reliable, well-documented, and had a large community behind it. However, RVM’s all-encompassing approach also meant that it was relatively heavy and could sometimes interfere with system-level settings, leading to potential conflicts and a steeper learning curve for newcomers.

Exploring Alternatives: rbenv

Over time, I became curious about rbenv, which offered a more lightweight approach to Ruby version management. Unlike RVM, rbenv doesn’t overwrite shell commands or try to manage everything about your Ruby environment. Instead, it uses shims to provide different Ruby versions per project.

While rbenv’s simplicity was appealing, I often found it lacking some of the conveniences RVM provided out of the box, such as gemsets. This led to additional setup for managing gems across different projects, which slightly diminished the initial attraction of rbenv's minimalist philosophy.

The Versatility of asdf

The introduction of asdf changed the game by offering a version manager not just for Ruby but for multiple languages and tools, including Node.js, Python, Elixir, and more. For developers working in polyglot environments, asdf was a revelation. It consolidated all version management under a single tool, reducing the overhead of learning and maintaining different managers for different languages.

Asdf’s plugin-based architecture was powerful, allowing the community to contribute and expand its capabilities. However, asdf’s flexibility also introduced complexity. The plugin system, while expansive, could sometimes lead to inconsistencies or issues when plugins were not maintained to the same standard.

Why I Switched to Mise (RTX)

Now, I find myself using Mise, a tool that has impressed me with its balance of flexibility and simplicity. Like asdf, Mise supports multiple languages and tools, making it a versatile choice for developers who work across different environments. However, Mise goes a step further by streamlining the user experience, providing better performance, and integrating more tightly with the system.

Mise is built on the shoulders of asdf, taking the best parts of it and refining the experience. It offers easier configuration, faster command execution, and a more polished interface. Additionally, it has a growing community and active development, which means it's continuously improving.

One of the standout features of Mise is its approach to plugins and language support. While asdf’s plugin system is powerful, Mise offers better consistency and reliability by maintaining a core set of well-supported plugins. This reduces the risk of running into issues and provides a smoother, more predictable experience.

The Future with Mise

After years of using RVM, rbenv, and asdf, I’ve settled on Mise as my version manager of choice. It combines the best elements of its predecessors—RVM’s comprehensiveness, rbenv’s simplicity, and asdf’s versatility—while improving on their weaknesses. Mise offers a modern, efficient solution that’s well-suited for the demands of today’s developers, particularly those working in multi-language environments.

While each of these tools has its place and merits, I believe Mise represents the future of version management, especially for those who value performance, ease of use, and a unified toolset for multiple languages. If you haven’t tried it yet, I highly recommend giving Mise a spin—you might find yourself making the switch just as I did.

Mastering Ruby on Rails: Thoughts and Ideas

Salajan Silviu — Tue, 27 Aug 2024 08:36:15 +0000

Mastering Ruby on Rails: Thoughts and Ideas

Ruby on Rails, with its convention-over-configuration philosophy, has become a go-to framework for developers building modern web applications. But to truly master Rails, one must dive deep into both the Ruby language and the Rails ecosystem. In this article, I’ll share some of my thoughts and ideas. Whether you’re preparing for a job interview or looking to deepen your understanding of the framework, mastering the fundamentals is crucial.

1. Ruby Language Fundamentals

Object-Oriented Programming (OOP) Principles

At the heart of Ruby lies its object-oriented nature. Mastering OOP principles is essential for any Ruby developer:

Encapsulation: Protect your data and methods by encapsulating them within objects. This keeps your code organized and maintainable.
Inheritance: Leverage Ruby’s inheritance to create hierarchical class structures, allowing for code reuse and logical categorization.
Polymorphism: Understand how to implement polymorphism in Ruby, enabling objects to be treated as instances of their parent class.
Abstraction: Simplify complex systems by focusing on high-level interactions while hiding implementation details.

Mixins

Mixins in Ruby allow you to share behavior between classes without using inheritance. By using extend, include, and included do, you can inject methods and functionality into classes, offering a flexible way to build reusable code.

Metaprogramming

Ruby’s metaprogramming capabilities enable you to write code that writes code:

method_missing: Dynamically handle calls to methods that don’t exist, allowing for flexible and dynamic behavior.
define_method: Programmatically define methods on classes or modules, enhancing the adaptability of your code.

Ruby Constructs

Understanding Ruby’s unique constructs is vital:

Proc vs Lambda: Learn the differences between these two, particularly how they handle return statements and arguments.
Duck Typing and Monkey Patching: Embrace Ruby’s dynamic typing by understanding how objects are treated based on their behavior rather than class. Use monkey patching wisely to extend or modify existing classes.
Everything is an object: In Ruby, even classes and methods are objects. Understanding this concept is key to mastering Ruby.

Memory Management & Optimization

Memoization: Optimize performance by storing the results of expensive operations and reusing them when needed.

Multithreading & Concurrency

Ruby provides basic tools for managing concurrency:

General Concepts: Grasp the basics of multithreading, concurrency, and the challenges they introduce.
How it works in Ruby, JRuby: Learn how Ruby handles threads and how JRuby enhances concurrency support.

2. Design Patterns & Principles

SOLID Principles

The SOLID principles are the foundation of good software design. Applying these principles ensures that your code is modular, flexible, and easy to maintain.

GoF (Gang of Four) Patterns

Familiarize yourself with the most common design patterns:

Factory, Singleton, Facade, Strategy: Learn when and how to apply these patterns to solve recurring design problems.

Rails-Specific Patterns

Rails introduces several design patterns tailored to the framework’s needs:

Service Object: Encapsulate business logic within service objects, promoting code reuse and separation of concerns.
Form Object: Simplify complex forms by handling their logic within a dedicated object.
Presenter and Decorator: Separate presentation logic from models, ensuring a clean MVC structure.
Builder and Observer: These patterns help in managing object creation and handling event-driven behavior respectively.

3. Database & ORM

Database Design & Optimization

An optimized database design is critical for performance:

Normalization/Denormalization: Balance between normalized data structures for consistency and denormalized structures for performance.
Locks and Transactions: Ensure data integrity and consistency through appropriate use of locks and transactions.

SQL Optimizations

Indexes, SQL Joins, Arel.sql: Optimize query performance by understanding how to effectively use indexes and joins, and how to leverage Arel for complex queries.

ActiveRecord Performance

ActiveRecord is the ORM layer in Rails, and optimizing it is crucial:

N + 1 Queries: Identify and eliminate N + 1 query problems to improve performance.
eager_load, preload: Use eager loading techniques to optimize database queries and reduce load times.

Database Systems

MySQL Performance: Understand how to tune MySQL for optimal performance in Rails applications.
NoSQL (Redis): Learn the basics of working with Redis for caching and data storage.

4. Rails Framework

Core Concepts

Ruby on Rails Callbacks: Master the use of callbacks to hook into the lifecycle of your ActiveRecord models.
Scopes and Filtering: Utilize scopes for reusable query logic and integrate Ransack for advanced filtering capabilities.

Rails Engines & Gem Development

Create and Extend a Gem: Gain experience in building and extending Rails engines and gems to add modular functionality to your applications.

Routing

Router Configuration: Learn how to configure the Rails router effectively to handle complex routing scenarios.

Performance

Ruby and Rails Performance Tuning: Focus on optimizing both Ruby code and Rails applications for maximum efficiency and speed.

5. Web Development & APIs

Security

Security is paramount in web development:

CORS, JWT, OAuth: Implement secure communication and authentication mechanisms in your Rails applications.
Authorization & Authentication: Build secure authentication systems and manage user permissions effectively.

HTTP Basics

Headers, Payloads, Requests: Understand the structure of HTTP requests and responses, and how to interact with them in Rails.

Front-End Integration

Enhance your Rails application with modern front-end technologies:

Tailwind CSS, SASS, Bootstrap: Style your applications using these powerful CSS frameworks.
JavaScript/TypeScript, Stimulus, Hotwire, Turbo, React: Integrate JavaScript and modern front-end libraries into your Rails applications.

REST & Microservices

Grape Gem: Build RESTful APIs using the Grape gem, and explore the world of microservices in Ruby.

6. DevOps & Infrastructure

Containerization & Orchestration

Docker, Kubernetes: Learn how to containerize your applications with Docker and orchestrate them using Kubernetes.

Infrastructure as Code

Ansible, Terraform: Manage your infrastructure using code with these powerful tools.

Cloud Services

AWS, Heroku, Hetzner: Deploy your Rails applications to the cloud using these popular platforms.
Dokku: Explore Dokku as a lightweight alternative to more complex PaaS solutions.

CI/CD & Monitoring

Kamal, AppSignal, Logger: Implement continuous integration and deployment pipelines, and monitor your applications effectively.

Background Jobs

Sidekiq: Offload time-consuming tasks to background jobs using Sidekiq.

Payment Integration

Stripe: Integrate payment processing into your Rails application with Stripe.

7. Other Tools & Utilities

REPL (Read-Eval-Print Loop)

The REPL is an essential tool for testing and experimenting with Ruby code on the fly.

File Attachments

Paperclip: Manage file uploads in your Rails applications using Paperclip.

Web Servers

Puma, Nginx: Understand how to configure and optimize web servers to serve your Rails applications.

Conclusion

Mastering Ruby on Rails requires a deep understanding of both the Ruby language and the Rails framework. By focusing on these key areas, you’ll be well-prepared for any challenge that comes your way, whether it’s a job interview or a complex project. Continue learning, experimenting, and building, and you’ll become a proficient developer in no time.

Ubuntu Development Sprinter

Salajan Silviu — Mon, 08 Jul 2024 07:52:38 +0000

I made this tool, inspired by Omakub.

Ubuntu Development Sprinter is a collection of centralized bash scripts designed to automate the setup of a development environment on Ubuntu and different flavours. This tool is tailored for Ruby on Rails developers but is versatile enough to be useful for any developer needing a robust and efficient setup.

You can find it here.