DEV Community: Hastycode Andreh

🔐 Fixing SSH Conflicts: Using a Separate SSH Key for GitHub

Hastycode Andreh — Sat, 31 May 2025 09:00:00 +0000

When working on multiple environments, you might run into this error when pushing to GitHub:

identity_sign: private key /home/hastycode-andreh/.ssh/id_ed25519 contents do not match public
git@github.com: Permission denied (publickey).
fatal: Could not read from remote repository.

This usually happens when:

You already have an SSH key (id_ed25519) used for something else (like a server), and
You're trying to use GitHub with that same key, but GitHub doesn't recognize it.

💡 Solution: Create a dedicated SSH key for GitHub, and tell your system to use it only for GitHub connections.

✅ Step 1: Generate a New SSH Key for GitHub

Let’s create a new key and name it something distinct, like id_ed25519_github.

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

You’ll see:

Enter file in which to save the key (/home/your-name/.ssh/id_ed25519):

Respond with:

/home/hastycode-andreh/.ssh/id_ed25519_github

This generates two files:

~/.ssh/id_ed25519_github (private key)
~/.ssh/id_ed25519_github.pub (public key)

✅ Step 2: Add the Key to Your SSH Agent

Start the SSH agent if it's not already running:

eval "$(ssh-agent -s)"

Then add your new GitHub key:

ssh-add ~/.ssh/id_ed25519_github

✅ Step 3: Add Your Public Key to GitHub

Copy your public key:

cat ~/.ssh/id_ed25519_github.pub

Go to GitHub SSH keys page
Click "New SSH Key", give it a name like “Andreh Laptop GitHub Key”, and paste the key.

✅ Step 4: Create a Custom SSH Config for GitHub

Now, tell your system to use the GitHub key only when talking to GitHub.

Edit or create your SSH config file:

nano ~/.ssh/config

Add this:

# GitHub account
Host github.com
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_github
  IdentitiesOnly yes

💡 This ensures your original server SSH key is untouched.

✅ Step 5: Test the SSH Connection

Let’s verify everything is working:

ssh -T git@github.com

Expected output:

Hi your-username! You've successfully authenticated, but GitHub does not provide shell access.

Perfect! 🎉 You're now pushing to GitHub securely using a separate SSH key.

✅ Optional: Clean Up Your SSH Agent (If Needed)

If your old key is causing conflicts, you can remove it:

ssh-add -d ~/.ssh/id_ed25519

This ensures your system prioritizes the GitHub key when needed.

🧠 Bonus: Multiple GitHub Accounts?

If you're juggling both personal and work GitHub accounts, you can add an alias in your SSH config:

# Personal GitHub
Host github.com-personal
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_personal
  IdentitiesOnly yes

# Work GitHub
Host github.com-work
  HostName github.com
  User git
  IdentityFile ~/.ssh/id_ed25519_work
  IdentitiesOnly yes

Then in Git remotes, use the alias:

git remote set-url origin git@github.com-personal:username/repo.git

🚀 Wrapping Up

This setup gives you a clean and flexible way to manage multiple SSH keys on the same machine — no more conflicts between GitHub and your server environments.

OperationalError - no such table (Django 101)

Hastycode Andreh — Sat, 31 May 2025 08:58:16 +0000

When you encounter the error message:

OperationalError at /task_list - no such table: myapp_task

in Django, it typically means that the application is trying to query a database table that hasn't been created yet. In this case, Django is attempting to access the myapp_task table, but it doesn't exist in the database. This situation usually happens when database migrations have not been properly made or applied after defining your models.

To fix this, the first step is to ensure that your app is correctly registered in your project’s settings. Open the settings.py file and check the INSTALLED_APPS list. Make sure that the name of your app — in this case, likely 'myapp' — is included there. If it’s missing, Django won’t recognize your models when you try to make migrations.

Once you have confirmed that the app is properly listed, the next step is to generate the migrations. Migrations are Django’s way of tracking changes you make to your models and applying those changes to your database schema. To create the necessary migration files, you should run the command:

python manage.py makemigrations

After running this, Django will scan your models for any changes and prepare migration files, typically under an app’s migrations/ directory. If successful, you’ll see a message indicating that a new migration file has been created for your app.

Following that, you need to apply these migrations to your database by running:

python manage.py migrate

This command actually executes the SQL statements necessary to create the tables in your database, including the missing myapp_task table. After completing the migrations, your database will be properly updated to match your models, and the error should disappear when you revisit your /task_list URL.

If you run makemigrations and Django tells you "No changes detected," it could mean that your models.py file is missing the Task model, or that it was not properly defined. In that case, you would need to double-check your model definitions to ensure that everything is correctly set up.

In summary, always ensure your app is listed in INSTALLED_APPS, then run makemigrations to create the migration files and migrate to apply them. This process will synchronize your models with your database and resolve errors related to missing tables.

OperationalError - no such table (Django 101)

Hastycode Andreh — Mon, 28 Apr 2025 08:08:23 +0000

When you encounter the error message:

OperationalError at /task_list - no such table: myapp_task

python manage.py makemigrations

Following that, you need to apply these migrations to your database by running:

python manage.py migrate

Resolving Missing `_sqlite3` Module in Python on Ubuntu

Hastycode Andreh — Sun, 19 Jan 2025 03:45:37 +0000

If you encounter the error ModuleNotFoundError: No module named '_sqlite3' while running Python scripts, it means the SQLite module required by the sqlite3 library is not installed. This is common when Python is built from source without the required SQLite development libraries. Here's how to resolve the issue:

1. Install SQLite Development Libraries

Ensure your system has the necessary SQLite development libraries by running the following commands in your terminal:

sudo apt update  
sudo apt install libsqlite3-dev

This installs the libsqlite3-dev package, which provides the header files and libraries needed for Python's SQLite support.

2. Rebuild Python with `pyenv`

If you are using pyenv to manage Python versions, you need to reinstall the affected version to include SQLite support. Use this command:

pyenv install --force 3.8.13

This forces pyenv to rebuild Python version 3.8.13, ensuring SQLite support is enabled.

3. Verify Python Installation

After rebuilding Python, you can confirm that SQLite support is working correctly. Run the following command:

python -c "import sqlite3; print('SQLite is working')"

If you see SQLite is working in the output, the issue has been resolved.

Additional Tip

You can check your installed Python versions using:

pyenv versions

Rebuild any version of Python where SQLite support might be missing.

By following these steps, you'll ensure that your Python environment is fully equipped to handle SQLite operations.

Troubleshooting 'pip install pipenv'

Hastycode Andreh — Sat, 18 Jan 2025 07:08:37 +0000

If pip install pipenv is not running in your terminal on Ubuntu, here are steps to troubleshoot and resolve the issue:

1. Verify Python and pip Installation

Check if Python is installed:
```
 python3 --version
```
Check if pip is installed:
```
 pip3 --version
```

If pip is not installed, install it:

 sudo apt update
 sudo apt install -y python3-pip

2. Run pip with the Correct Python Version

On Ubuntu, the command pip may point to Python 2. Use pip3 for Python 3:
```
 pip3 install pipenv
```

3. Ensure `pip` is Up-to-Date

Update pip to the latest version:
```
 python3 -m pip install --upgrade pip
```

4. Install pipenv

After updating pip, install pipenv:
```
 python3 -m pip install pipenv
```

5. Fix Permissions Issues

If you encounter permissions errors, use the --user flag to install pipenv locally:
```
 python3 -m pip install --user pipenv
```

Ensure the local binary path is in your PATH environment variable:

 echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
 source ~/.bashrc

6. Use a Virtual Environment (Optional)

If you want to avoid system-level installation issues, create a virtual environment:
```
 python3 -m venv myenv
 source myenv/bin/activate
 pip install pipenv
```

7. Debugging Common Issues

Command Not Found: Ensure python3 and pip3 are correctly installed and in your PATH.
Conflicting Dependencies: If you encounter dependency issues, try using --force-reinstall:
```
 python3 -m pip install --force-reinstall pipenv
```

8. Verify Installation

Check if pipenv is installed:
```
 pipenv --version
```

If the issue persists, share the exact error message, and I’ll provide further assistance.

Using Homebrew to Install Pyenv on Ubuntu

Hastycode Andreh — Sat, 18 Jan 2025 07:07:07 +0000

Did you know Homebrew isn’t just for macOS? You can use it on Linux too! Often called Linuxbrew, it allows Ubuntu users to leverage Homebrew’s powerful package management features. Here’s how to install pyenv using Homebrew on Ubuntu:

1. Install Homebrew on Ubuntu

Start by installing Homebrew with this command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Follow the prompts during installation. When asked, add Homebrew to your system's PATH by appending this line to your shell configuration file (~/.bashrc or ~/.zshrc):

eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"

Reload your shell to apply the changes:

source ~/.bashrc

Verify the installation:

brew --version

2. Install pyenv Using Homebrew

With Homebrew set up, installing pyenv is a breeze:

brew install pyenv

3. Configure pyenv

Finally, set up pyenv by adding this to your shell configuration file:

export PYENV_ROOT="$HOME/.pyenv"  
export PATH="$PYENV_ROOT/bin:$PATH"  
eval "$(pyenv init --path)"

Reload your shell once more:

source ~/.bashrc

4. Verify pyenv Installation

To confirm everything is working, check the pyenv version:

pyenv --version

Why Use Homebrew on Ubuntu?

Unified Management: Manage all your packages consistently across systems.
Ease of Use: Homebrew simplifies installations and updates.

With this setup, you're ready to install Python versions using pyenv and start managing your development environment with ease.

Give it a try and enjoy the flexibility of Linuxbrew on Ubuntu!

Resolving HTTP 302 Errors

Hastycode Andreh — Wed, 25 Dec 2024 17:25:54 +0000

An HTTP 302 status code indicates redirection, often caused by:

Authentication requirements.
Backend misconfigurations.

Quick Fixes

Check Backend Logic: Ensure no unintended redirection occurs.
Add Authentication Headers:

   const response = await axios.get(
     `http://localhost:8080/api/product/${id}`,
     { headers: { Authorization: `Bearer ${token}` } }
   );

Debug with Tools: Use Postman to inspect backend responses.

Backend Adjustment

Return the correct status code in the controller:

@GetMapping("/product/{id}")
public ResponseEntity<Product> getProductById(@PathVariable int id) {
    Product product = service.getProductById(id);
    return product != null
        ? new ResponseEntity<>(product, HttpStatus.OK)
        : new ResponseEntity<>(HttpStatus.NOT_FOUND);
}

By addressing these issues, you can eliminate unexpected redirections and ensure proper API responses.

Mastering Surrounds in Vim: Add, Remove, and Modify Like a Pro

Hastycode Andreh — Mon, 18 Nov 2024 09:11:09 +0000

If you're working in Vim and frequently need to add, delete, or modify surrounding characters like parentheses, quotes, or tags, the vim-surround plugin is a must-have. Here's a quick guide to get you started.

What is vim-surround?
vim-surround, developed by Tim Pope, is a plugin that simplifies working with surrounding characters in Vim. Whether you're wrapping a word in quotes, removing parentheses, or changing tags, vim-surround makes it effortless.

Adding Surroundings To add surrounding characters to text:

Install vim-surround using a plugin manager like vim-plug:
vim
Copy code
Plug 'tpope/vim-surround'
Use the command ys (yank surround) in normal mode:
ys wraps the specified motion with the given character.
Examples:
ysiw) → Wraps the inner word with parentheses: (word)
ysiw" → Wraps the inner word with double quotes: "word"

Deleting Surroundings To remove surrounding characters:

Place the cursor inside the surrounding.
Use the ds command followed by the surrounding character:
ds" → Removes surrounding double quotes: "word" → word
ds) → Removes surrounding parentheses: (word) → word

Changing Surroundings To change one type of surrounding to another:

Place the cursor inside the current surrounding.
Use the cs command followed by the current and desired surrounding characters:
cs"' → Changes double quotes to single quotes: "word" → 'word'
cs)( → Changes parentheses to curly braces: (word) → {word}
For Vim Without Plugins
If you don't have vim-surround installed, you can still manually add or remove surroundings:

Add: Use i (insert) or a (append) to type the surrounding characters manually.
Remove: Use x to delete characters or visual mode (v) to select and remove.
Why Use vim-surround?
This plugin saves time and keystrokes, especially for repetitive editing tasks. It's simple, powerful, and enhances productivity in Vim.

Try it out and watch your Vim workflow transform!

Resolving the "Unable to Resolve Name [org.hibernate.dialect.MySQLDialect]" Error in Spring Boot

Hastycode Andreh — Wed, 28 Aug 2024 04:45:02 +0000

If you've encountered the error message "Unable to resolve name [org.hibernate.dialect.MySQLDialect;] as strategy [org.hibernate.dialect.Dialect]" while working with Spring Boot and Hibernate, you're not alone. This error usually points to a misconfiguration related to the Hibernate dialect setting. In this post, we'll walk through how to resolve this issue step-by-step.

Understanding the Error
Hibernate uses the concept of "dialects" to communicate with different databases. A dialect tells Hibernate how to convert the specific SQL of your database into its own format. The error indicates that Hibernate is unable to find or recognize the specified dialect. This can be due to a typo, an incorrect class name, or even a syntax error like an extra semicolon.

Step 1: Verify the Dialect Configuration
The first step is to ensure that the Hibernate dialect is correctly specified in your configuration file (application.properties or application.yml).

Here’s how you should define the dialect for different versions of MySQL:

For General MySQL Use:

properties
Copy code
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
For MySQL 5.x:

properties
Copy code
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
For MySQL 8.x:

properties
Copy code
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
Key point: Make sure there are no extra characters or typos, such as an accidental semicolon ; at the end of the dialect name.

Step 2: Ensure Proper Dependencies
The correct Hibernate and MySQL dependencies must be included in your project. If these dependencies are outdated or missing, it can cause Hibernate to fail in resolving the dialect.

Here’s how you can specify these dependencies in Maven and Gradle:

For Maven Users:

xml
Copy code

mysql
mysql-connector-java
8.0.x 

org.hibernate
hibernate-core
5.x.x 

For Gradle Users:

gradle
Copy code
implementation 'mysql:mysql-connector-java:8.0.x' // Replace with your MySQL version
implementation 'org.hibernate:hibernate-core:5.x.x' // Replace with your Hibernate version
Step 3: Clear Caches and Rebuild Your Project
Development environments like IntelliJ IDEA or Eclipse may cache old configurations, causing issues even after you've fixed your code.

Invalidate Caches/Restart in IntelliJ IDEA: Navigate to File > Invalidate Caches / Restart to clear the cache and restart your IDE.

Clean and Rebuild the Project: Use the following commands to clean and rebuild your project:

Maven: mvn clean install
Gradle: ./gradlew clean build
Step 4: Update the Hibernate Dialect
If you're using a specific version of MySQL, it's essential to use the corresponding dialect to avoid compatibility issues.

For MySQL 8.x:
properties
Copy code
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
Using an outdated or incorrect dialect can lead to unexpected errors, so always ensure you're using the correct one for your database version.

Conclusion
The "Unable to resolve name [org.hibernate.dialect.MySQLDialect;] as strategy [org.hibernate.dialect.Dialect]" error is primarily a configuration issue. By carefully verifying your dialect settings, ensuring you have the correct dependencies, and cleaning your project cache, you can resolve this issue and get your Spring Boot application running smoothly.

Have you encountered this error before? Share your experiences or any additional tips in the comments below!

Understanding Pattern and Matcher Classes in Java

Hastycode Andreh — Wed, 21 Aug 2024 10:12:22 +0000

When working with regular expressions in Java, the Pattern and Matcher classes are essential tools. Both are part of the java.util.regex package and provide robust mechanisms to search, match, and manipulate strings based on regular expression patterns. In this blog post, we'll explore each class in detail and provide examples to illustrate their usage.

The Pattern Class The Pattern class represents a compiled version of a regular expression. In simpler terms, it's a blueprint for the regex operations you want to perform. Here’s a quick overview of its role:

Compilation: Before you can perform any regex operations, you need to compile your regular expression into a Pattern. This step transforms your regex string into an optimized format that Java can use efficiently.
Usage: Once compiled, you can use the Pattern to create Matcher objects, which can then be used to perform various operations, such as searching or matching.

Example:

import java.util.regex.Pattern;

public class PatternExample {
    public static void main(String[] args) {
        String regex = "[a-zA-Z]+";
        Pattern pattern = Pattern.compile(regex);

        // Now, the pattern is ready to be used for matching operations.
    }
}

In this example, [a-zA-Z]+ is a regex that matches one or more letters, both uppercase and lowercase. This pattern is compiled into a Pattern object, which can be used to create a Matcher for further operations.

The Matcher Class The Matcher class is where the action happens. After you have a Pattern, you can use it to create a Matcher object that applies the regex to a specific string. The Matcher class provides several methods to interact with the string:

Matching: You can check if the entire string matches the pattern using the matches() method.
Finding Substrings: The find() method allows you to search for substrings within the string that match the pattern.
Replacing: The replaceAll() method enables you to replace all occurrences of the pattern within the string with a new substring.

Example:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class MatcherExample {
    public static void main(String[] args) {
        String regex = "\\d+";
        String input = "My number is 1234 and my friend's number is 5678.";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            System.out.println("Found a number: " + matcher.group());
        }
    }
}

In this example, the regex \\d+ matches one or more digits. The Matcher object is created by applying the compiled pattern to the input string. The find() method is then used to locate all substrings within the input that match the pattern.

Conclusion
The Pattern and Matcher classes are powerful tools for working with regular expressions in Java. By compiling regex into a Pattern and using a Matcher to apply that pattern to strings, you can perform complex string manipulations and searches with ease. Whether you're validating input, searching for patterns, or transforming strings, these classes provide the functionality you need to work efficiently with regular expressions in Java.

DEV Community: Hastycode Andreh

🔐 Fixing SSH Conflicts: Using a Separate SSH Key for GitHub

✅ Step 1: Generate a New SSH Key for GitHub

✅ Step 2: Add the Key to Your SSH Agent

✅ Step 3: Add Your Public Key to GitHub

✅ Step 4: Create a Custom SSH Config for GitHub

✅ Step 5: Test the SSH Connection

✅ Optional: Clean Up Your SSH Agent (If Needed)

🧠 Bonus: Multiple GitHub Accounts?

🚀 Wrapping Up

OperationalError - no such table (Django 101)

OperationalError - no such table (Django 101)

Resolving Missing `_sqlite3` Module in Python on Ubuntu

1. Install SQLite Development Libraries

2. Rebuild Python with pyenv

3. Verify Python Installation

Additional Tip

Troubleshooting 'pip install pipenv'

1. Verify Python and pip Installation

2. Run pip with the Correct Python Version

3. Ensure pip is Up-to-Date

4. Install pipenv

5. Fix Permissions Issues

6. Use a Virtual Environment (Optional)

7. Debugging Common Issues

8. Verify Installation

Using Homebrew to Install Pyenv on Ubuntu

1. Install Homebrew on Ubuntu

2. Install pyenv Using Homebrew

3. Configure pyenv

4. Verify pyenv Installation

Why Use Homebrew on Ubuntu?

Resolving HTTP 302 Errors

Quick Fixes

Backend Adjustment

Mastering Surrounds in Vim: Add, Remove, and Modify Like a Pro

Resolving the "Unable to Resolve Name [org.hibernate.dialect.MySQLDialect]" Error in Spring Boot

Understanding Pattern and Matcher Classes in Java

2. Rebuild Python with `pyenv`

3. Ensure `pip` is Up-to-Date