DEV Community: kw4rgs

Multiple GitHub Accounts on the Same Machine Like a Pro

kw4rgs — Mon, 05 Aug 2024 17:55:02 +0000

Hey, awesome developer! Do you have multiple GitHub accounts and find it a headache to manage them on the same machine? Don't worry! Here's a step-by-step guide to set up your SSH keys and use different profiles for each project. Let's get started!

Step 1: Create an SSH Key for Each Account

First, make sure you're in your .ssh directory. If you don't know where it is, don't worry, Git does.

$ cd ~/.ssh

The magic command to generate a unique SSH key for each account is this:

ssh-keygen -t rsa -C "your email" -f "your key name"

-C: A comment to identify your SSH key.
-f: The file name where your SSH key will be saved.

Example:

ssh-keygen -t rsa -C "work@example.com" -f "id_work"
ssh-keygen -t rsa -C "personal@example.com" -f "id_personal"

Now you have two SSH keys, one for your work account and one for your personal account.

Step 2: Add the SSH Keys to the SSH Agent

Generating keys is great, but we need to tell the SSH agent to use them.

ssh-add -K ~/.ssh/id_work
ssh-add -K ~/.ssh/id_personal

Boom! Now your keys are ready to work.

Step 3: Add the SSH Public Key to GitHub

Time to tell GitHub who you are. Copy the contents of your public keys.

cat ~/.ssh/id_work.pub
cat ~/.ssh/id_personal.pub

Next steps:

Log in to your GitHub account.
Go to Settings > SSH and GPG keys > New SSH Key.
Paste your public key and give it a title you like.

Step 4: Create a Config File and Make Host Entries

The ~/.ssh/config file lets us specify many configuration options for SSH.

If you don't have a config file, create one.

nano config

Add these lines, each block for each account:

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

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

For example if you are working on Azure Devops, HostName will be ssh.dev.azure.com

Git Configuration

First, let's change the default Git editor to VSCode. It's optional, but who doesn't love a good GUI editor?

git config --global core.editor 'code --wait'

Let's also create two aliases for easily accessing and editing Git configurations.

alias gcg="git config --edit --global"
alias gcl="git config --edit --local"

Organize Your Projects

Let's organize our projects into different folders so each uses the appropriate configuration.

~
├── .gitconfig <-- global
└── main-folder/
   ├── personal/
   │   ├── repo_1/
   │   ├── repo_2/
   │   └── .gitconfig <-- personal
   └── work/
       ├── repo_1/
       ├── repo_2/
       └── .gitconfig <-- work

Personal Configuration

# ~/main-folder/personal/.gitconfig

[user]
    name = Your Personal Name
    email = personal@example.com

[core]
    sshCommand = "ssh -i ~/.ssh/id_personal -F /dev/null"

Work Configuration

# ~/main-folder/work/.gitconfig

[user]
    name = Your Work Name
    email = work@example.com

[core]
    sshCommand = "ssh -i ~/.ssh/id_work -F /dev/null"

Global Configuration

Let's open the global configuration and add the specific paths for our projects, by typing:

git config --edit --global

#~/.gitconfig

[core]
    editor = code --wait

[includeIf "gitdir:/Users/<your-user>/main-folder/personal/"]
    path = /Users/<your-user>/main-folder/personal/.gitconfig

[includeIf "gitdir:/Users/<your-user>/main-folder/work/"]
    path = /Users/<your-user>/main-folder/work/.gitconfig

And that's it! Now Git will use the correct user configuration based on the project you're working on. Clone your repositories into the appropriate folders and make sure to use the right commands to verify the configuration.

git config user.name

Congratulations! Now you're ready to manage multiple GitHub accounts on the same machine like a pro. If you have any problems, just make sure the paths are correct, Happy coding! 🚀

Machine Learning: To Infinity and Beyond !

kw4rgs — Fri, 05 Apr 2024 12:39:30 +0000

Imagine being in the prehistoric era of programming, where even calculating the sum of two numbers, A and B, required a formula worthy of a trigonometry treaty. But now, with a simple line of code, we can do it:

value = A + B

Easy, right? However, what if we want to complicate things a bit?

We decide to be finicky and set some conditions. For example, what if A is greater than zero and also greater than B? In that case, our formula remains the same: value = A + B. But what if A doesn't meet those rules? That's when we get creative! The formula becomes: value = (A + B) * -1.

def calculate_value(A, B):
    if A > 0 and A > B:
        value = A + B
    else:
        value = (A + B) * -1
    return value

That's how we do things in the wild west of programming, yeehaw!

But wait, the fun doesn't end here. What if we want to add a bit of spice and only calculate the value when A is an even, positive integer and also divisible by 2, and B is a negative integer? And that's not all, what if we also want A to be within a specific range, say between 20 and 50, and B to be a prime number less than 20?

def is_prime(n):
    if n <= 1:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    i = 3
    while i * i <= n:
        if n % i == 0:
            return False
        i += 2
    return True

def calculate_value(A, B):
    if A % 2 == 0 and A > 0 and 20 <= A <= 50 and B < 0 and is_prime(abs(B)):
        value = A + B
    else:
        value = (A + B) * -1
    return value

Exactly, time to add more conditionals as if there were no tomorrow!

It works, my dear cowboy, but let me tell you two things: first, there's a snake in your boot, and second, we don't ride horses or settle things at gunpoint anymore; there are more modern ways to get things done now, and that's where our star commando astronaut comes into play: Machine Learning!

Machine Learning can handle all these conditions with the grace of a juggler in a circus, freeing us from the complications of coded logic and allowing us to explore a territory of infinite possibilities.

Instead of being locked in a cage of rules and conditions, we simply ask the model, "Whats'up my friend, can you tell me what the value is?" And voilà, the model takes care of all the heavy lifting, leaving us free to grab a coffee and laugh about how we could have done the same with lines, rules, conditions, and more lines of code.

Machine Learning not only simplifies our lives but also adds a bit of spice to the boring task of doing mathematics. So put on your cowboy hat and get ready for an exciting ride through the wild west of machine learning.

A practical example

Imagine you're working on a recommendation system for a movie streaming platform. With conventional programming, we would have to design an algorithm that looks a bit like a spy movie: "If the user has watched more action movies than comedies, and has given more than five stars to movies featuring a certain actor, then recommend more action movies with that actor. Operation: Movie Recommendation in Progress!"

However, this approach might make you feel more like a detective trying to solve a mystery than a software engineer. And, to be honest, nobody likes being in the office until late at night searching for clues about user viewing habits.

Luckily, we have the hero of the story: Machine Learning! Instead of trying to decipher the complexities of user preferences, we simply feed historical viewing data to our model and let it do the heavy lifting. The result? Movie recommendations so perfect that they'll make you wonder if the model has been spying on your conversations with your friends about what you want to watch tonight.

For this, we can use one of these approaches:

Content-based recommendation: Think of this as the friend who always suggests movies because "if you liked Toy Story, you'll surely love Shrek." It's like the system is a movie buff who knows you so well that it can predict your preferences just by looking at movie characteristics. It's like having a movie buddy who knows all your dark screen secrets and serves you the best recommendations effortlessly.
Collaborative filtering: This approach is like if a bunch of your movie buff friends got together to form a "Recommendation League." They observe your viewing habits, the movies you've liked or disliked, and then take turns suggesting movies based on what they've liked. It's like if your friends said, "Hey, you loved that alien sci-fi movie, and I did too! You should watch this other one that's just as great." We just hope none of your friends are horror movie fanatics, or you'll end up with a nightmare recommendation list!

Just a reminder

Ultimately, both conventional programming and Machine Learning are powerful tools in the software development arsenal. Conventional programming has served us well for decades, allowing us to build robust and reliable systems based on rules and coded logic. However, Machine Learning has taken computer capabilities to a whole new level by allowing them to learn from data and autonomously adapt to new situations.

While conventional programming is ideal for problems with well-defined rules and clear logical structures, Machine Learning shines in situations where rules are hard to specify explicitly or where data is complex and changing. Its ability to uncover hidden patterns in large datasets and make accurate predictions makes it an invaluable tool in fields such as data analysis, computer vision, and natural language processing.

In summary, the choice between conventional programming and Machine Learning largely depends on the nature of the problem being addressed and the resources available. Both approaches have their strengths and weaknesses, and what's more important, they coexist in a world where innovation and adaptability are key.

And what if instead of having to have thought of all the conditionals to find the value, I had asked ChatGPT to give me the code?

Well, that's another tale for another post.

30 Tips Every Python Jedi Should Master: Episode I – The Python Menace

kw4rgs — Tue, 20 Feb 2024 18:40:51 +0000

Let's Hack Python Like Pros!

Hey there, fellow Python enthusiast! Get ready to level up your Python game with these killer tips and tricks that'll make your coding life way easier. We're talking about some seriously cool hacks that'll save you time, hassle, and maybe even a headache or two.

From sharing files effortlessly to slicing and dicing sequences like a boss, we've got it all covered. No more boring, tedious coding—just slick, efficient Python magic that'll make you feel like a coding ninja.

So grab your favorite energy drink, kick back, and let's dive into the wonderful world of Python hacks together. Trust me, once you start using these tips, you'll wonder how you ever lived without them! Let the Python hacking begin! 🐍✨

Tip 1: Share Files Smoothly with Python

Hey, want to make file sharing between your gadgets a breeze? Python's got your back with a slick trick: whip up your very own file sharing server using FTP.

With just one simple command, you'll have a file server running on your computer, ready to sling files to and fro between devices, whether it's another computer or your trusty smartphone.

Here's the scoop: fire up your terminal and type this magic spell:

python -m http.server 5000

You're the boss of the port range, so pick any number from 0 to 65353. Once you hit enter, your server's online and good to go, waiting for action at 127.0.0.1:5000.

Now, grab your phone, open your favorite browser, and punch in YOUR_COMPUTER_IP_ADDRESS:PORT_NUMBER. Need your IP address? Just run ipconfig in your terminal and snag the IPv4 address. For example, if your IP is 192.168.39.145 and your Port Number is 5000, your file-sharing hub's at 192.168.39.145:5000.

Boom! Get set to share files like a pro with this nifty Python file sharing setup!

Tip 2: Passing Loads of Stuff Without Saying How Many

Alright, check this out, in Python you can throw a bunch of stuff into a function without even saying how many things you're chucking in there.

So, here's the deal. You use this *args thing. It's like a magic wand that lets you pass as many arguments as you want to a function, without giving a single care about how many you're throwing in.

def calculate_average(*numbers):
    total = sum(numbers)
    return total / len(numbers)

print(calculate_average(10, 20, 30, 40, 50))  # Output: 30.0

See that? You just call the function calculate_average() and chuck in as many numbers as you like. It'll find the average for you, no questions asked.

Oh, and there's more! If you wanna get fancy and pass a bunch of keyword arguments (key:value), you can use **kwargs. It's like the VIP treatment for your functions.

Tip 3: Crafting Lists the Smart Way

So, you know about lists in Python, right? They're like arrays, but cooler. You can change 'em up, throw all sorts of stuff in there, and they're super easy to handle. But hey, adding elements to a list can be a bit of a drag, especially if you're doing it the old-fashioned way with loops and conditionals. Lucky for us, Python's got this slick trick up its sleeve called List comprehension, which lets you do it all in one neat line.

Let's break it down.

Creating a Simple List (The Old Way)

numbers = []
for i in range(5):
    numbers.append(i * 2)
print(numbers)  # Output: [0, 2, 4, 6, 8]

Creating a List (Using List comprehension)

numbers = [i * 2 for i in range(5)]
print(numbers)  # Output: [0, 2, 4, 6, 8]

Creating a List (Conditionals, List Comprehension)

Only if

squared = [i ** 2 for i in range(1, 10) if i % 2 == 0]
print(squared)  # Output: [4, 16, 36, 64]

If and else

modified = [i ** 2 if i % 3 == 0 else i / 3 for i in range(1, 10)]
print(modified)  # Output: [0.3333333333333333, 1.0, 4, 4.0, 1.3333333333333333, 36, 7.0, 64, 7.333333333333333]

See that? With list comprehension, you can whip up lists like a boss, with all the conditions and whatnot, in just one line. How cool is that?

Tip 4: Type Checking Made Easy

Type checking is a bit like the backbone of programming, you know? It's basic stuff but super crucial for keeping your code rock-solid and dependable. And in Python, we've got this handy little tool called isinstance() that's like your trusty sidekick for checking types. It's dead simple yet seriously powerful, helping you figure out if something is what you think it is or not.

# Define a class
class Person:
    pass

# Create an object of Person
someone = Person()

# Check if someone is an instance of Person
if isinstance(someone, Person):
    print("Yep, that's a Person alright!")
else:
    print("Nope, definitely not a Person.")

# Define another class
class Animal:
    pass

# Check if someone is an instance of Animal
if isinstance(someone, Animal):
    print("Wow, they're an Animal too!")
else:
    print("Nah, not an Animal.")

# Check if a variable is of a certain type
age = 25
if isinstance(age, int):
    print("Looks like an integer to me!")
else:
    print("Hmm, not an integer.")

Output:

Yep, that's a Person alright!
Nope, definitely not a Person.
Looks like an integer to me!

See what's happening here? We're using isinstance() to check if our objects and variables are what we expect them to be. It's like having a superpower for your type checking game!

Tip 5: Trimming the Fat - Cleaning Up Scraped Data!

So, picture this: you're scraping some text off the web, right? But along with the good stuff, you end up with a bunch of junk like tabs, newlines, and whatnot. Total nuisance, am I right? Well, fear not! Python's got your back with a nifty little method called strip() that'll help you tidy up that mess.

# Let's say you scraped some text and it's a bit messy
scraped_text = "\t   Some text with unwanted spaces and tabs   \n"

# Use strip() to clean it up
clean_text = scraped_text.strip()

print("Before stripping:", repr(scraped_text))  # repr() is used to display non-printable characters
print("After stripping:", repr(clean_text))

Output:

Before stripping: '\t   Some text with unwanted spaces and tabs   \n'
After stripping: 'Some text with unwanted spaces and tabs'

See that? strip() neatly trims away all the unwanted whitespace from the beginning and end of your text, leaving you with just the good stuff. So next time you're cleaning up scraped data, remember to reach for that trusty strip() method!

Tip 6: Unlocking the Mystery of the Underscore Operator

Alright, let's talk about this little guy in Python: the underscore _. Yeah, it might look like just a plain ol' character, but it's actually got some tricks up its sleeve.

You see, _ is totally legit as a variable name in Python. But here's where it gets interesting: it's not just any old variable. According to the Python docs, _ is a special character that stores the result of the previous evaluation.

# Let's say you did some calculations
result = 10 + 5

# Now, let's use the underscore to access the previous result
previous_result = _

print("Previous result:", previous_result)  # Output: 15

See what happened there? We used _ to grab the result of our previous calculation. It's like a little memory bank for your Python interpreter, holding onto the last thing you did.

So yeah, don't underestimate the power of the underscore. It might seem small, but it sure can come in handy!

Tip 7: Shortening Library Names

Alright, let's talk about a neat little trick in Python that can save you some typing when you're using libraries. So, you know how Python's got this massive treasure trove of libraries, right? They're like these treasure chests full of pre-made code that you can just plug into your own programs. Super handy, right?

But sometimes, these library names are a bit of a mouthful, especially if they're not in English. And if you're using them a lot in your code, typing out those long names over and over again can get old real fast.

Well, fear not! Python's got a slick solution for this: the as keyword. It lets you give a library a shorter, more user-friendly name that you can use in your code.

# Let's say you're using the popular 'pandas' library for data manipulation
import pandas as pd

# Now, instead of typing 'pandas' every time, you can just use 'pd'
data = pd.read_csv('data.csv')
print(data.head())

See what we did there? We imported the pandas library but gave it the nickname pd. So now, whenever we want to use pandas functions, we just use pd instead. It's like giving your library a cool nickname!

So yeah, next time you're tired of typing out those long library names, just reach for the as keyword and give 'em a snappy new name!

Tip 8: Mastering Iteration Over Multiple Lists

Alright, let's talk about a slick little hack for iterating over multiple lists like a pro. So, picture this: you're scraping data from the web, right? And you end up storing that data in different lists because, well, that's just how things go sometimes.

Now, here's the cool part. This hack lets you print out each element of one list alongside the corresponding element of another list. It's like a tag team of lists, working together seamlessly.

# Let's say you've got two lists, one for names and one for ages
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

# Now, let's iterate over both lists together
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

# Output:
# Alice is 25 years old
# Bob is 30 years old
# Charlie is 35 years old

See what happened there? We used the zip() function to pair up elements from both lists, and then we looped over those pairs. It's like a synchronized dance of data!

So next time you've got multiple lists and you want to work with them together, just remember to reach for zip(). It's the secret sauce for professional list iteration!

Tip 9: Unlocking the Power of Slicing in Python

Alright, let's talk about slicing in Python. It's like this built-in superpower that lets you slice and dice sequences like a pro. And not just that, you can also use slicing to modify or even delete items from them. Talk about versatile!

There are tons of examples where slicing can come in handy and help you trim down your code to make it sleeker and more efficient.

# Let's say you've got a list of numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Now, let's say you only want the first 5 numbers
first_five = numbers[:5]
print("First five numbers:", first_five)  # Output: [1, 2, 3, 4, 5]

# Or maybe you want every other number
every_other = numbers[::2]
print("Every other number:", every_other)  # Output: [1, 3, 5, 7, 9]

# And hey, why not reverse the list while we're at it?
reversed_numbers = numbers[::-1]
print("Reversed numbers:", reversed_numbers)  # Output: [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

See what happened there? With just a few simple slicing tricks, we were able to do all sorts of cool stuff with our list of numbers. And that's just scratching the surface!

So next time you're working with sequences in Python, remember to reach for slicing. It's like a Swiss army knife for your code!

Tip 10: Code Clarity Tip - Breaking Long Lines with "\"

Alright, let's talk about a nifty little trick for keeping your code nice and readable, even when you've got some seriously long lines. We've all been there, right? You've got these super long file paths, URLs, or lists that just stretch on forever, making your code look like a mess.

But fear not! Python's got your back with the \ character. It's like a magic wand that lets you break those long lines into smaller, more manageable chunks.

# Let's say you've got a super long file path
file_path = "C:/Users/username/Documents/Projects/SomeReallyLongFolderName/AnotherReallyLongFolderName/YetAnotherReallyLongFolderName/file.txt"

# Instead of one super long line, you can break it up like this
file_path = "C:/Users/username/Documents/" \
            "Projects/SomeReallyLongFolderName/" \
            "AnotherReallyLongFolderName/" \
            "YetAnotherReallyLongFolderName/file.txt"

print("File path:", file_path)

See what we did there? By using the \ character, we were able to break our super long file path into smaller, more manageable chunks. It's like giving your code some breathing room!

So next time you've got a line of code that's threatening to take over your entire screen, just remember to reach for \ and break it up into smaller pieces. Your fellow developers will thank you!