Forem: Ben Borla

MCP Server for MySQL

Ben Borla — Mon, 31 Mar 2025 09:21:31 +0000

In today's data-driven world, the ability to interact with databases through natural language has become increasingly valuable. Enter MCP Server for MySQL - a powerful tool that bridges the gap between Large Language Models (LLMs) like Claude and your MySQL databases.

This innovative tool enables LLMs to:

Inspect database schemas
Execute SQL queries directly
Analyze data without manual copying
Perform database operations through natural language commands

Whether you're a developer looking to streamline your database interactions, a data analyst seeking more intuitive ways to query data, or a database administrator wanting to leverage AI for database management, MCP Server for MySQL offers a seamless solution.

What is MCP?

MCP (Model Context Protocol) is a framework that extends the capabilities of LLMs, allowing them to interact with external tools and systems. In this case, MCP Server for MySQL acts as a connector between LLMs and MySQL databases.

Key Features

SQL Query Execution: Send SQL queries directly to your MySQL database from your conversations with Claude
Schema Inspection: Allow Claude to understand your database structure without manual explanations
Data Analysis: Have Claude analyze your database data and return insights
Security Features:
- SQL injection prevention through prepared statements
- Configurable write permissions (INSERT, UPDATE, DELETE)
- Query whitelisting and rate limiting capabilities
- Configurable connection encryption

Performance Features

Optimized connection pooling
Query result caching
Large result set streaming
Query execution plan analysis
Configurable query timeouts

Use Cases

Database Exploration: Ask Claude to explain complex database structures
Query Generation: Request specific data without writing SQL yourself
Data Analysis: Have Claude analyze patterns or insights from your database
Database Maintenance: When configured, allow Claude to help update or clean your data

Installation

Getting started with MCP Server for MySQL is straightforward, with multiple installation methods available depending on your environment and preferences.

Prerequisites

Node.js v18 or higher
MySQL 5.7 or higher (MySQL 8.0+ recommended)
MySQL user with appropriate permissions

Installation Options

Using Claude Desktop

For Claude Desktop App, add the following to your claude_desktop_config.json file:

{
  "mcpServers": {
    "mcp_server_mysql": {
      "command": "npx",
      "args": [
        "-y",
        "@benborla29/mcp-server-mysql"
      ],
      "env": {
        "MYSQL_HOST": "127.0.0.1",
        "MYSQL_PORT": "3306",
        "MYSQL_USER": "your_username",
        "MYSQL_PASS": "your_password",
        "MYSQL_DB": "your_database",
        "ALLOW_INSERT_OPERATION": "false",
        "ALLOW_UPDATE_OPERATION": "false",
        "ALLOW_DELETE_OPERATION": "false",
        "PATH": "/path/to/node/bin:/usr/bin:/bin",
        "NODE_PATH": "/path/to/node/lib/node_modules"
      }
    }
  }
}

For Cursor IDE (Version: 0.47+)

Add this to your mcp.json

{
  "mcpServers": {
    "MySQL": {
      "command": "npx",
      "args": [
        "mcprunner",
        "MYSQL_HOST=127.0.0.1",
        "MYSQL_PORT=3306",
        "MYSQL_USER=root",
        "MYSQL_PASS=root",
        "MYSQL_DB=demostore",
        "ALLOW_INSERT_OPERATION=true",
        "ALLOW_UPDATE_OPERATION=true",
        "ALLOW_DELETE_OPERATION=false",
        "--",
        "npx",
        "-y",
        "@benborla29/mcp-server-mysql"
      ]
    }
  }
}

If you have a lower version you may use this

npx mcprunner MYSQL_HOST=127.0.0.1 MYSQL_PORT=3306 MYSQL_USER=root MYSQL_PASS=root MYSQL_DB=demostore ALLOW_INSERT_OPERATION=true ALLOW_UPDATE_OPERATION=true ALLOW_DELETE_OPERATION=false -- npx -y @benborla29/mcp-server-mysql

Remember to replace the values in the env strings.

How You Can Help

MCP Server for MySQL is an open-source project that welcomes community contributions! If you're interested in helping improve this tool, here are some ways to get involved:

Contributing to the Project

Visit the GitHub repository at https://github.com/benborla/mcp-server-mysql/ to:

Report bugs or issues you encounter
Suggest new features or improvements
Submit pull requests for bug fixes or new functionality
Help improve documentation

Development Setup

If you want to contribute code:

Fork the repository
Clone your fork: git clone https://github.com/your-username/mcp-server-mysql.git
Install dependencies: npm install or pnpm install
Build the project: npm run build or pnpm run build
Run tests: npm test or pnpm test

Project Roadmap

The team is actively working on enhancing this MCP server with features like:

Enhanced query capabilities with prepared statements
Advanced security features
Performance optimizations
Comprehensive monitoring
Expanded schema information

Your contributions to any of these areas would be greatly appreciated!

By connecting LLMs like Claude directly to your MySQL databases, MCP Server for MySQL opens up new possibilities for database interaction and management. Whether you're using it for personal projects, development workflows, or enterprise applications, this tool provides a powerful bridge between natural language AI and your structured data.

Give it a try today, and join the community to help shape the future of AI-powered database interactions!

MCP Server for MySQL

Ben Borla — Mon, 09 Dec 2024 19:04:38 +0000

Hi! I'd like to share the tool that I just worked. If you are using Anthropic's Claude AI and MySQL, this might be helpful to you.

You may visit this Github link:
https://github.com/benborla/mcp-server-mysql

Let me know what you think of it. Thanks!

Hi, I'd like to share an MCP Server tool I have been working. If you use Claude API and MySQL on your development, this might be helpful. Please visit this Github link. https://github.com/benborla/mcp-server-mysql Let me know what you think of it. Tnx!

Ben Borla — Mon, 09 Dec 2024 19:00:26 +0000

🔥🔥🔥 I Turned My Terminal into a Time Machine

Ben Borla — Fri, 18 Oct 2024 03:20:24 +0000

Hey there! Remember those days when journaling meant scribbling "Dear Diary" in a notebook hidden under your mattress? Well, dust off your keyboards because we're about to take a leap into the simplicity of journaling.

The Journaling Journey: More Than Just Teen Angst

Let's face it, we've all had those moments when life feels like a washing machine on spin cycle. You know, when your to-do list is longer than a CVS receipt, and your brain feels like a browser with 100 tabs open. That's where journaling comes in, like a superhero swooping down to save your sanity.

But here's the kicker – journaling isn't just about venting your frustrations or documenting your crush on that cute barista (though that's totally valid). It's a powerful tool for mindfulness, organization, and habit-sticking. It's like having a personal trainer for your brain, minus the intimidating muscles and protein shake obsession.

Enter the Journal Bash Script: Your New BFF (Best Function for Fulfillment)

Now, I know what you're thinking. "Bash script? Isn't that something only hackers in hoodies use?" Well, prepare to have your mind blown like a dandelion in a hurricane.

Imagine having a journaling tool that's as easy to use as typing a single word into your terminal. No need to fumble with apps, remember passwords, or navigate through clunky interfaces. Just you, your thoughts, and the comforting glow of your command line.

Our journal bash script is like the Swiss Army knife of journaling tools. It's got more features than a Hollywood celebrity has Instagram followers:

Daily Entries: Because consistency is key, like remembering to water your plants (RIP, Steve the Succulent).
Customizable Location: Store your journals wherever you want. Under your digital bed, perhaps?
Configurable Editor: Use your favorite text editor. Vim, Emacs, or even Notepad if you're feeling nostalgic (but seriously, why would you do that to yourself?).
Time Travel: Okay, not really. But you can create entries for past or future dates. Perfect for when you forget to journal or want to leave a message for your future self ("Dear Future Me, I hope you finally learned how to fold fitted sheets").
List All Entries: Because sometimes you need to remind yourself of how far you've come (or how many days in a row you complained about your neighbor's yodeling practice).

Why This Tool Will Change Your Life (No Exaggeration... Okay, Maybe a Little)

Mindfulness: It's like meditation, but you get to use words instead of sitting in silence wondering if you left the stove on.
Organization: Keep your thoughts as tidy as Marie Kondo's sock drawer.
Habit Formation: Because the only thing standing between you and your goals is consistency (and maybe that last slice of pizza).
Accessibility: It's always there, just a terminal away. No excuses!
Privacy: Your thoughts stay local. No cloud storage, no data breaches, no awkward explanations about why you wrote a sonnet to your cat.

How to Get Started (It's Easier Than Assembling IKEA Furniture)

Head over to the project's GitHub repository: https://github.com/benborla/journal-cli
Clone the repo or download the script (don't worry, it won't bite).
Make it executable (chmod +x, for the cool kids).
Move it somewhere in your PATH (so you can summon it like a genie, but without the limited wishes).
Start journaling! Type journal and watch the magic happen.

The Bottom Line

Look, I'm not saying this journal bash script will solve all your problems. It won't do your laundry or explain why pineapple on pizza is controversial. But it will give you a simple, powerful tool to reflect, organize your thoughts, and build better habits.

Remember, in the grand debugging of life, self-reflection is the best breakpoint.

P.S. If all else fails, you can always use the script to document your attempts at becoming a professional bubble tea taster. Hey, everyone needs a dream!

P.P.S. Don't forget to star the GitHub repo. It's like giving a digital high-five to the developers, and who doesn't love high-fives?

Let me know in the comments if you have tried it and what you think about it.

Have a great day everyone!

Moon Phases | CSS Art: Space

Ben Borla — Tue, 10 Sep 2024 08:52:32 +0000

CSS Art: Interactive Space Scene

This is a submission for Frontend Challenge v24.09.04, CSS Art: Space.

Inspiration

For this challenge, I wanted to capture the dynamic and interactive nature of our night sky. The ever-changing phases of the moon, the twinkling stars, and the occasional thrill of a shooting star have always fascinated humanity. By creating an animated and interactive representation of these celestial phenomena, I aimed to bring a small piece of the universe to our screens, reminding us of the constant motion and beauty in space.

Demo

Link: https://moon-phase.fly.dev/

Here's a live demo of the interactive space scene. The centerpiece is the moon with its ever-changing phases, represented by an animation that cycles through different stages. Surrounding the moon, you'll see a sky full of twinkling stars, each blinking at its own rhythm. For an extra interactive element, try hovering your mouse over the stars - you'll trigger a comet animation, simulating a shooting star effect.

Journey

This project has been an exhilarating journey into the world of CSS animations and interactive web design. When I first approached the challenge, I was both excited and slightly overwhelmed by the idea of creating a dynamic space scene purely with HTML and CSS. However, as I delved deeper into the project, I discovered the incredible power and flexibility of these technologies.

One of the most significant learnings was mastering CSS animations. Creating the moon phase effect was particularly challenging and rewarding. I learned how to use keyframe animations to smoothly transition the moon through its different phases, which opened up a whole new world of possibilities for future projects.

The twinkling star effect taught me a lot about using random values in CSS animations. By applying different animation delays to each star, I was able to create a more natural, organic feel to the night sky. This technique of introducing controlled randomness is something I'm excited to explore further in future designs.

I'm particularly proud of the interactive comet effect. Implementing this feature pushed me to combine CSS animations with pseudo-elements and hover states. It was a breakthrough moment when I finally got the comet to streak across the sky upon hovering over a star. This intersection of animation and user interaction has sparked many ideas for future interactive web elements.

The process of refining the colors and timing of animations was also enlightening. I spent considerable time tweaking the shades of blue for the space background and adjusting the animation speeds to find the perfect balance between an active scene and a calming night sky. This exercise greatly improved my understanding of color theory and the impact of timing in animations.

Moving forward, I'm excited to explore more complex CSS animations and interactions. I'd love to add features like parallax scrolling for different layers of stars or even incorporate subtle audio effects to complement the visual experience.

License

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

This challenge has not only improved my technical skills but also reminded me of the joy of creating immersive, interactive experiences on the web. It's empowering to know that with CSS and a bit of creativity, we can bring a piece of the universe to life on a webpage. I'm grateful for this experience and the renewed appreciation it's given me for both the wonders of space and the limitless possibilities of web design.

This journey has taught me that the frontier of web development, much like space itself, is boundless. I'm excited to continue exploring and pushing the limits of what's possible with CSS and HTML.

Clean Architecture Demystified: A Practical Guide for Software Developers

Ben Borla — Mon, 02 Sep 2024 04:00:15 +0000

As developers, we've all encountered codebases that feel like navigating a maze blindfolded. Clean Architecture, proposed by Robert C. Martin (Uncle Bob), offers a way out of this chaos. Let's break it down in practical terms using NextJS, TypeScript, DrizzleORM, and PostgreSQL.

Why Code Structure Matters

Imagine you're working on an e-commerce app built with NextJS. Here's how it might look with poor structure vs. Clean Architecture:

Poor Structure:

// pages/api/products/[id].ts
import { NextApiRequest, NextApiResponse } from 'next';
import { drizzle } from 'drizzle-orm/node-postgres';
import { eq } from 'drizzle-orm';
import { Pool } from 'pg';
import { products } from '@/schema';

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});

const db = drizzle(pool);

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  const { id } = req.query;

  const [product] = await db.select().from(products).where(eq(products.id, id as string));

  if (product) {
    res.status(200).json(product);
  } else {
    res.status(404).json({ message: 'Product not found' });
  }
}

In this case, changing from PostgreSQL to another database would require rewriting every API route that interacts with the database.

Clean Architecture:

// entities/Product.ts
export interface Product {
  id: string;
  name: string;
  price: number;
}

// use-cases/GetProduct.ts
export interface ProductRepository {
  getProduct(id: string): Promise<Product | null>;
}

export class GetProduct {
  constructor(private repository: ProductRepository) {}

  async execute(id: string): Promise<Product | null> {
    return this.repository.getProduct(id);
  }
}

// infrastructure/DrizzleProductRepository.ts
import { drizzle } from 'drizzle-orm/node-postgres';
import { eq } from 'drizzle-orm';
import { Pool } from 'pg';
import { products } from '@/schema';
import { Product, ProductRepository } from '@/use-cases/GetProduct';

export class DrizzleProductRepository implements ProductRepository {
  private db;

  constructor() {
    const pool = new Pool({
      connectionString: process.env.DATABASE_URL,
    });
    this.db = drizzle(pool);
  }

  async getProduct(id: string): Promise<Product | null> {
    const [product] = await this.db.select().from(products).where(eq(products.id, id));

    if (product) {
      return {
        id: product.id,
        name: product.name,
        price: product.price,
      };
    }
    return null;
  }
}

// pages/api/products/[id].ts
import { NextApiRequest, NextApiResponse } from 'next';
import { GetProduct } from '@/use-cases/GetProduct';
import { DrizzleProductRepository } from '@/infrastructure/DrizzleProductRepository';

const getProduct = new GetProduct(new DrizzleProductRepository());

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  const { id } = req.query;
  const product = await getProduct.execute(id as string);

  if (product) {
    res.status(200).json(product);
  } else {
    res.status(404).json({ message: 'Product not found' });
  }
}

With this structure, swapping databases only requires creating a new repository implementation. The use case and API route don't need to change at all. That's the power of Clean Architecture - it isolates the impact of changes to specific parts of your system.

Clean Architecture: The Layer Cake

Picture your NextJS app as a layer cake:

Entities (Core): These are your business objects. In our e-commerce app, think Product, Order, and Customer.
Use Cases (Application Business Rules): These orchestrate data flow between entities and the outer layers. Example: GetProduct, PlaceOrder.
Interface Adapters: They convert data between use cases and external agencies. In NextJS, this includes your API routes and controllers.
Frameworks and Drivers (Outermost layer): This is where NextJS, DrizzleORM, PostgreSQL, and UI components live.

Key Principles in Action

1. The Dependency Rule

Inner layers should not know about outer layers. This means your Product entity shouldn't know about your database or NextJS.

// Good: Entity doesn't know about storage or framework
export interface Product {
  id: string;
  name: string;
  price: number;
}

// Bad: Entity depends on a database
import { InferModel } from 'drizzle-orm';
import { products } from '@/schema';

type Product = InferModel<typeof products>;

export interface Product {
  save(): Promise<void>;  // This violates Clean Architecture
}

2. Use Cases Define Application Behavior

Use cases encapsulate and implement all of the use cases of the system.

export interface ProductRepository {
  getProduct(id: string): Promise<Product | null>;
  updateProduct(id: string, data: Partial<Product>): Promise<void>;
}

export class UpdateProduct {
  constructor(private repository: ProductRepository) {}

  async execute(id: string, data: Partial<Product>): Promise<void> {
    const product = await this.repository.getProduct(id);
    if (!product) {
      throw new Error('Product not found');
    }
    await this.repository.updateProduct(id, data);
  }
}

3. Interface Adapters

In NextJS, your API routes act as interface adapters. They convert incoming HTTP requests into calls to your use cases and convert the results back into HTTP responses.

// pages/api/products/[id].ts
import { NextApiRequest, NextApiResponse } from 'next';
import { UpdateProduct } from '@/use-cases/UpdateProduct';
import { DrizzleProductRepository } from '@/infrastructure/DrizzleProductRepository';

const updateProduct = new UpdateProduct(new DrizzleProductRepository());

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  if (req.method === 'PUT') {
    const { id } = req.query;
    const data = req.body;

    try {
      await updateProduct.execute(id as string, data);
      res.status(200).json({ message: 'Product updated successfully' });
    } catch (error) {
      res.status(404).json({ message: error.message });
    }
  } else {
    res.setHeader('Allow', ['PUT']);
    res.status(405).end(`Method ${req.method} Not Allowed`);
  }
}

4. Frameworks and Drivers

This layer is where all the details go. Your NextJS configuration, DrizzleORM setup, database connection, and React components live here.

// infrastructure/DrizzleProductRepository.ts
import { drizzle } from 'drizzle-orm/node-postgres';
import { eq } from 'drizzle-orm';
import { Pool } from 'pg';
import { products } from '@/schema';
import { Product, ProductRepository } from '@/use-cases/UpdateProduct';

export class DrizzleProductRepository implements ProductRepository {
  private db;

  constructor() {
    const pool = new Pool({
      connectionString: process.env.DATABASE_URL,
    });
    this.db = drizzle(pool);
  }

  async getProduct(id: string): Promise<Product | null> {
    const [product] = await this.db.select().from(products).where(eq(products.id, id));
    return product ? { id: product.id, name: product.name, price: product.price } : null;
  }

  async updateProduct(id: string, data: Partial<Product>): Promise<void> {
    await this.db.update(products).set(data).where(eq(products.id, id));
  }
}

// components/ProductForm.tsx
import React, { useState } from 'react';
import { useRouter } from 'next/router';

export function ProductForm({ product }) {
  const [name, setName] = useState(product.name);
  const [price, setPrice] = useState(product.price);
  const router = useRouter();

  const handleSubmit = async (e) => {
    e.preventDefault();
    const res = await fetch(`/api/products/${product.id}`, {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ name, price }),
    });
    if (res.ok) {
      router.push(`/products/${product.id}`);
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      {/* form fields */}
    </form>
  );
}

Real-World Benefits

Testability: You can test business rules without UI, database, or any external element.
Independence: You can easily swap out your database or even migrate from NextJS to another framework with minimal changes to your core business logic.
Maintainability: New developers can easily understand and navigate the system.

Is It Always Necessary?

For a simple CRUD app, Clean Architecture might be overkill. But it's a game-changer for complex applications where business rules are crucial. It's the difference between dreading and embracing changes to your codebase.

Conclusion

Clean Architecture isn't just theoretical—it's a practical approach to building maintainable, flexible software with NextJS, even when using modern ORMs like DrizzleORM. By separating concerns and adhering to the dependency rule, you create a codebase that's resilient to change and a joy to work with.

Next time you start a NextJS project, consider how Clean Architecture principles could make your future self (and your team) thank you. Your code will be cleaner, your architecture is more robust, and your development process smoother.

As you implement Clean Architecture in your NextJS projects, remember that the examples provided in this guide are starting points. The beauty of Clean Architecture lies in its flexibility within its core principles. Feel free to iterate and refine these patterns to best suit your project's needs while maintaining the separation of concerns and dependency rules that make Clean Architecture so powerful.

Bonus: Clean Architecture Project Structure for NextJS with DrizzleORM

Here's a sample project structure that follows Clean Architecture principles:

nextjs-app/
├── src/
│   ├── entities/
│   │   └── Product.ts
│   ├── use-cases/
│   │   ├── GetProduct.ts
│   │   └── UpdateProduct.ts
│   ├── interfaces/
│   │   └── repositories/
│   │       └── ProductRepository.ts
│   ├── infrastructure/
│   │   ├── DrizzleProductRepository.ts
│   │   └── schema.ts
│   ├── pages/
│   │   ├── api/
│   │   │   └── products/
│   │   │       └── [id].ts
│   │   ├── products/
│   │   │   ├── [id].tsx
│   │   │   └── edit/[id].tsx
│   │   └── index.tsx
│   └── components/
│       └── ProductForm.tsx
├── public/
├── tests/
│   ├── unit/
│   ├── integration/
│   └── e2e/
├── package.json
├── tsconfig.json
└── next.config.js

Note: This project structure is a suggested template based on Clean Architecture principles. You may adjust it to fit your specific project needs, development practices, and team preferences. The key is to maintain a clear separation between the layers of your application, ensuring that dependencies point inwards towards the core business logic.

Happy coding, and happy Monday!

Reference:
https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html

Debugging Your Productivity: A Guide to Mindfulness and Efficiency

Ben Borla — Fri, 30 Aug 2024 06:39:52 +0000

Taming the Chaos: A Real-World Guide to Mindfulness and Productivity

Look, we've all been there. You sit down to tackle that big project, and suddenly your phone chirps. Before you know it, you're down a rabbit hole of cat videos and obscure Wikipedia articles. Two hours later, you're wondering where the day went. Sound familiar?

In this wild, wired world of ours, staying focused is like trying to herd cats – while the cats are on caffeine. But fear not! I've stumbled through the productivity maze and come out the other side with some hard-earned wisdom to share.

The Modern Brain: Overwhelmed and Underprepared

Let's face it: our noggins weren't built for this. We're bombarding our poor brains with a firehose of information every day. How much? Try 34GB – that's like reading "War and Peace" seven times over. Every. Single. Day.

No wonder we're all walking around like zombies half the time. This info deluge is doing a number on us:

Our attention spans are shrinking faster than my patience in rush hour traffic
Stress levels are through the roof (and the roof is already pretty high)
Making decisions feels like defusing a bomb blindfolded
Creative juices? More like a creative drought

But hey, recognizing the problem is half the battle, right? So let's dive into the murky waters of our overloaded minds and see if we can't find some treasure.

Procrastination vs. Burnout: The Productivity Frenemies

Here's a fun game: try to guess which productivity killer you're dealing with today! Is it our old pal procrastination, or its evil twin, burnout? Spoiler alert: they're both the worst.

Procrastination: The "I'll Do It Tomorrow" Trap

Ah, procrastination. It's not just being lazy (though sometimes a nap does sound pretty good). It's more like your brain's way of playing hooky from adulting.

You might be in Procrastination Nation if:

You've got more excuses than a politician caught with their hand in the cookie jar
The guilt of not working is almost as bad as actually working
You've become a champion at "productive procrastination" (hello, spotless kitchen!)
Deadlines whoosh by like you're standing still

Why do we do this to ourselves? Well, it could be:

Fear of messing up (hello, perfectionism, my old friend)
Feeling lost in the sauce (what even are goals?)
Time management skills that would make a sloth look efficient
Emotions? In this economy? No thanks!

Burnout: When Your Get-Up-And-Go Has Got-Up-And-Gone

Now burnout, that's a whole other kettle of fish. It's like your brain has gone on strike, and it's not accepting any negotiations.

You might be burning out if:

The mere thought of your to-do list makes you want to hibernate
Even the fun stuff feels like a chore (Netflix and chill? More like Netflix and stare blankly at the wall)
You're about as cheerful as a wet cat
Your body's sending out SOS signals (hello, insomnia, my least favorite bedfellow)

What's cooking this burnout stew? Often it's:

Work stress that never lets up (like a bad houseguest)
Feeling like a puppet on strings (where's the control?)
Job expectations clearer than mud
Work-life balance? More like work-work imbalance

Knowing which beast you're battling is key to picking the right weapons. So, let's gear up!

Outsmarting Your Own Brain: Jedi Mind Tricks for Productivity

Time to pull a fast one on that grey matter of yours. Your brain might think it's the boss, but we're about to stage a coup.

Try this on for size: when your mind whispers "Maybe later," you shout back "How about now?" When it starts spinning yarns about why you can't possibly work right now, call it bluff.

Here's a real-life example: that report you've been dreading? Set a timer for 5 measly minutes and dive in. Chances are, once you're in, you're in. It's like tricking yourself into cleaning the house by saying you'll "just do one thing."

Future You: Your New Best Friend

Imagine your future self as a real person. Would you dump all your work on them? Force them to pull an all-nighter? Probably not, unless you're a real jerk to yourself (in which case, we need to have a different talk).

Before you make a decision, ask yourself: "Is Future Me going to high-five me for this, or curse my name?" It's amazing how this little mental trick can light a fire under your butt.

Some ways to be Future You's hero:

Tidy up your workspace before calling it a day (Future You will feel like they've got their life together)
Prep some healthy snacks (Future You won't be hangry)
Lay out your gym clothes (Future You will have one less excuse)

Mornings: Setting the Stage for Awesome

I get it, mornings can be rough. But hear me out: how you kick off your day can make or break your productivity.

Instead of face-planting into your phone first thing, try this:

Keep a notebook by your bed (old school, I know, but trust me)
When you wake up, take a few deep breaths (no, hitting snooze doesn't count as breathing)
Spend 5-10 minutes brain-dumping everything on your mind
For the important stuff, use this magic formula: "I will [what] at [when] in [where]" (Implementation Intention from Atomic Habits)

For example:

"I will tackle those soul-crushing spreadsheets at 10 AM in my home office (with plenty of coffee)."
"I will attempt to touch my toes without pulling a muscle at 6 PM in the living room."

It's like giving your day a roadmap before you even brush your teeth.

The Power of Pause: Because Sometimes Doing Nothing Is Everything

In our mad dash to tick off to-do lists, we sometimes forget to ask if we're even running in the right direction. Enter the power of pause.

Here's a little experiment for you:

Set an alarm for every couple of hours
When it goes off, stop whatever you're doing (yes, even if you're in the middle of beating your high score on Candy Crush)
Take 20 deep breaths (count them, it's oddly satisfying)
Ask yourself: "Is what I'm doing right now important, or am I just spinning my wheels?"
If you're off track, no biggie. Just course-correct and carry on.

This little check-in can save you from spending hours on tasks that seemed crucial but were actually about as useful as a chocolate teapot.

Putting It All Together: Your "Get Your Act Together" Action Plan

Rome wasn't built in a day, and your productivity empire won't be either. But here's a weekly plan to get you started:

Monday: Kick off with your new morning routine (you've got this!)
Tuesday: Outsmart your brain – tackle that one thing you've been avoiding
Wednesday: Channel your inner time traveler and do something nice for Future You
Thursday: Practice your pausing skills
Friday: Look back on your week and give yourself a gold star (or identify where it all went pear-shaped)

Remember, we're aiming for progress, not perfection. If you mess up, no worries. There's always tomorrow (but don't use that as an excuse to procrastinate, you hear?).

The Grand Finale: Small Steps, Big Wins

Living in our crazy, distracted world is like trying to meditate in the middle of a rock concert. It's tough, but it's not impossible.

By being more mindful, constantly tweaking your approach, and treating your future self like your best friend, you're setting yourself up for success. Every small win adds up. The you of tomorrow, next month, next year? They'll be doing a happy dance thanks to the efforts you make today.

Remember, being productive isn't about turning yourself into a work robot. It's about doing the stuff that actually matters and finding time for the good things in life (like binge-watching your favorite show without guilt).

Your journey to mastering your mind in this bonkers world starts now. So, what's your first move going to be? Whatever it is, Future You is already breaking out the pom-poms.

References:

Atomic Habits by James Clear
The Power Of Now by Eckhart Tolle
Discipline Equals Freedom by Jocko Willink

Rust Microservice Starter Kit powered by Neon

Ben Borla — Wed, 28 Aug 2024 17:01:14 +0000

This is a submission for the Neon Open Source Starter Kit Challenge: Ultimate Starter Kit

My Kit

🦀 Rust Microservice Starter Kit - a powerful, type-safe, and memory-safe foundation for building high-performance APIs! This starter kit combines the robustness of Rust with the Axum web framework and the serverless PostgreSQL capabilities of Neon.

🌟 Key Features:

Rust's strong type system and ownership model for safety and concurrency
Axum's modular web framework for building scalable APIs
Neon's serverless PostgreSQL with autoscaling and bottomless storage
SeaORM for intuitive database interactions
Comprehensive documentation and examples

Link to Kit

🔗 Repository: https://github.com/benborla/rust-microservice-starter-kit

Demo: https://rust-microservice-starter-kit.fly.dev/

The repository includes detailed setup instructions, covering prerequisites, installation, project structure, testing, and deployment.

My Journey

Learning Rust was initially challenging, with concepts like borrowing, ownership, and lifetimes seeming confusing. However, with dedication and persistence, I gradually unraveled the language's intricacies.

Creating this starter kit allowed me to apply my Rust knowledge to a real-world project. I encountered obstacles but learned valuable lessons in perseverance and growth. The Rust community provided invaluable support throughout the journey.

Integrating Neon's serverless PostgreSQL was a game-changer, enabling me to focus on writing code without worrying about database management. SeaORM made database interactions seamless and intuitive.

Structuring the project in a maintainable and scalable manner was crucial. By separating concerns and leveraging Rust's module system, I created a clean and organized codebase.

🎉 I'm excited to share this starter kit with the community and empower developers to build robust microservices using Rust and Neon. Whether you're a seasoned Rust developer or just starting, this kit provides a solid foundation to kickstart your journey.

Happy coding, and may your Rust journey be filled with growth and success! 🚀✨

Efficient editor navigation for BEGINNERS in VIM - Part 1

Ben Borla — Thu, 07 Nov 2019 02:25:42 +0000

In this post, I'm going to teach you how to efficiently navigate in Vim editor instead of you spamming keys j, k, l, h (or the arrow keys) just to go to a certain character or line.

This post is for aspiring Vim ninjas that want to make Vim as their primary editor when coding, or even writing anything.

I recommend not to read the whole post but instead follow the guide that I will leave on each paragraph, so you would have time to learn and build that muscle memory as we go learn each command in Vim.

I suggest to archive or save this so you can go back to this post anytime. The goal is to learn it step-by-step, and not learning all at once.

Vim is great and powerful (if you have mastered all the keystrokes, shortcuts, mnemonics, etc), but it does take time to get used to it, especially building that muscle memory. It takes guts to fully grasp Vim and hone your skills with it.

Without further ado, let's start!

But first, let's go back to basics. To navigate to each character:

j to go down, k to go up, h to get left, and l to go right. For beginners, this may seem awkward because we used to do it on arrow keys or WASD keys, in VIM, it's different.

When Bill Joy created the vi text editor he used the ADM-3A terminal, which had the arrows on hjkl keys. Naturally he reused the same keys and the rest is history.
https://catonmat.net/why-vim-uses-hjkl-as-arrow-keys

And for me, this is fine, so I can rest my fingers where I can reach the most common shortcut keys in Vim.

Now you know the basic navigation, let's take another level, will take it slowly, as we tackle each command that we will be using.

Legend
TTL - Time to Learn 😅

To start, copy this gist and save it somewhere you can easily find.

Once done, open your terminal and run this command vim path-to-lorem.txt, this will bring up the lorem.txt that you just saved. We will be using this sample text file to practice.

In order to navigate easily, we have to enable the Line Number, most IDE has this built-in on their application, but in Vim, you have to enable this feature.

In your VIM make sure you are in Normal mode, type :set number and hit enter, as you can see this will show the line number(s) in your editor, most of Vim users I know use Relative Number as this is much easier to navigate line by line.

You can see more about relative number by typing :h relativenumber

Show the line number relative to the line with the cursor in front of each line.

Commands

Navigate through each word
w jump to the start of the word this includes punctuation.

W jump to the start of the word, does not include punctuations.

b jump to the end of the word this includes punctuation.

B jump to the end of the word, does not include punctuations.

** Jump to the start or the end of the line **
0 jump to the start of the line

$ jump to the end of the line.

*** TTL: 5 to 10 minutes ***

End of Part 1

VIM | Getting rid of ESC key to switch to Normal mode

Ben Borla — Tue, 05 Nov 2019 03:38:45 +0000

It's important that you place your hands in a correct position to reach different keyboard keys, but it has been a pain for me ever since to reach the ESC key just to switch to normal mode.

Some say you have to remap the CAPSLOCK key with ESC, but that doesn't work for me since I need the CAPSLOCK key sometimes if I need to write capitalized phrases or sentences.

Obviously, remap is the only solution. With this, I can place my hands in one place, and not stressing my fingers to reach certain keys.

You can put this in your .vimrc

" Press nn to return to normal mode when in insert mode
inoremap ii <ESC>
inoremap <ESC> <NOP>

" Press ii to return to normal mode when in visual mode
vnoremap ii <ESC>
vnoremap <ESC> <NOP>

" Press ii when in Command mode, to go back to normal mode
cnoremap ii <ESC>

The code above will allow you to use ESC functionality when pressing ii on these modes:

Insert mode
Visual mode
Command mode

This doesn't mean that you can't use the ESC, it's still usable but if you prefer switching to normal mode, then ii is the key to press.

It will take some time to train your hands and build that muscle memory, but once you have, I can assure you that it's worth it.

BONUS

Saving your changes, instead of :w or :w!, you can either map this with your leader key:

noremap <Leader>s :update<CR>

OR!!!

" Press ww to do a w!
inoremap ww <ESC>:w!<CR>
" nnoremap ww <ESC>:w!<CR>
vnoremap ww <ESC>:w!<CR>
" Press nww to do a save on normal mode
nnoremap nww <ESC>:w!<CR>

This will allow you to save your changes without going to the command mode.

For Insert mode, press ww to save your changes.
When in Normal mode, press nww to save your changes.
Lastly on Visual mode, ww to save your changes.

I hope the remapped keys will help you to be more efficient when editing files on Vim.

Thank you for your time!