DEV Community: Rita Nkem Daniel

My Open Source Journey with OpenSauced: From Beginner to Confident Contributor

Rita Nkem Daniel — Tue, 21 May 2024 11:20:46 +0000

Contribution to open source projects is a highly rewarding activity for any developer. This experience boosts not only your technical skills but also the ability to work with people and become part of a community. My first meaningful open source contribution was to a project called open-sauced/app. I got first-hand experience with learning Tailwind CSS, diving into git cherry-pick, and becoming a better communicator in the field under the direction of very supportive maintainers. This post tells you my story of working as an OpenSauced contributor, what I learned, and gives some advice on how to start.

Getting to Know About OpenSauced

The open-sauced/app repository is an incredible platform that allows developers to track their contributions, discover new projects, and monitor their progress. I stumbled upon OpenSauced while searching for beginner-friendly projects, and I was immediately drawn to its mission of making open source contributions more accessible.

Getting Started

Starting can be the hardest part, but with OpenSauced, it was a breeze. I began by:

Exploring the Repository: I familiarized myself with the codebase and set up my development environment.
Solving Beginner-Friendly Issues: Tackling good-first-issue tasks with the help of the community and the detailed documentation.

The community's support and detailed documentation made the process smoother.

My Contributions

My initial contributions focused on fixing bugs and enhancing features. One notable experience I had with the app was how they integrated the GitHub API to enhance the user interface. This experience inspired me to rebuild my portfolio using a similar technique.

My Learnings

Learning Tailwind CSS: In the course of my journey, I developed my skills with Tailwind CSS, which helped improve my ability to create responsive designs.
Using the GitHub API: Understanding how OpenSauced utilized the GitHub API to display user contributions motivated me to integrate this feature into my portfolio.
Community Engagement: Collaborating with the community was a valuable experience that built my confidence and inspired me to continue contributing publicly.
Learning Git Cherry-Pick: An unexpected issue with a pull request led me to learn git cherry-pick, a powerful command to apply specific commits from one branch to another. With guidance from Brian "the Beyoncé of Open Source,” I mastered this tool, which proved invaluable in my contributions.
Becoming a Better Communicator: One of the most valuable aspects of contributing to OpenSauced was the opportunity to improve my communication skills. The maintainers provided constructive feedback on my pull requests and commit messages. They emphasized:

Clear and Descriptive Commit Messages: Writing concise and informative commit messages to explain the purpose of changes.

Detailed Pull Request Descriptions: Including thorough descriptions of changes in pull requests to help reviewers understand the context and impact.

Advice for Aspiring Contributors

Start Small: Begin with manageable issues to build confidence.
Engage with the Community: Join discussions, ask questions, and seek feedback.
Be Patient: Contributions take time to review; persistence is key.

Conclusion

My journey with OpenSauced has been a pivotal experience in my development career. It has equipped me with technical skills and improved my ability to communicate effectively within a community. If you're interested in open source, I highly encourage you to dive in and start contributing!

Call to Action

Have you contributed to open source before? What was your experience like? Share your thoughts and questions in the comments below. If you found this post helpful, please give it a like and share it with your network!

Mastering Git: Effortless Branch Renaming on Visual Studio Code's Terminal

Rita Nkem Daniel — Mon, 11 Mar 2024 09:45:44 +0000

Are you curious about how to efficiently rename branches within your IDE, particularly Visual Studio Code (VsCode), using Git commands? Renaming branches can help ensure your branch name aligns with the specific fixes or features you’ve been working on. Here is a simple guide on how to do that seamlessly:

To rename a branch, leverage the -m flag within Git:

git branch -m new-branch-name

For instance, suppose your current branch is named add-product, and you aim to retitle it as feat/create-product-component.

git branch -m feat/create-product-component

To confirm that your branch name is updated or changed, execute git status or git branch (which will provide you with a list of all your branches).

This straightforward process allows you to maintain clarity and organization within your project by aligning branch names with the respective tasks or features they represent.

Breaking Language Barriers: A Guide to Implementing Localization in Your App

Rita Nkem Daniel — Sat, 09 Mar 2024 00:48:10 +0000

As technology continues to bridge the gap between people across the globe, it is vital to ensure that your application can effectively communicate with your users in their preferred language. This is where localization or internationalization comes into play. By implementing localization in your application, you can enable your users to interact with your app in their native language, thus improving their overall user experience and accessibility. In this guide, I will walk you through the process of implementing localization in your application.

Why Localization Matters:

Expanding the reach of your application beyond language barriers can bring numerous benefits. Here's why localization is essential:

When users can navigate and interact with your app in their native language, they feel more comfortable and engaged.
Localization opens doors to new markets and demographics, allowing your app to resonate with diverse audiences worldwide.
In a crowded app market, offering multilingual support sets your application apart and demonstrates your commitment to user satisfaction.

To add localization to your app, please follow the steps below:

Install the below dependencies:

Begin by installing the necessary dependencies using npm:

npm install i18next react-i18next i18next-browser-languagedetector

Organize Your Project Structure:

Create a folder named i18n inside the src directory to store your localization configurations and translation files. The i18n.js file should contain the code specified below:

Create Translation Files:

To properly support multiple languages in your project, create a new folder called 'locale' inside your 'src' directory. Inside this folder, create individual JSON files for each language you wish to support. For example, you can create 'en.json' for English and 'fr.json' for French. In these files, you can include key-value pairs that map each key to its respective translation.

en.json:

fr.json:

Configure i18n Settings:

Update the 'i18n.js' file to import translation files and configure i18next settings to meet project requirements.

i18n.js

Integrate i18n with Your App:

Import the 'i18n.js' file into your main application file ('app.js' or 'index.js') to initialize i18n settings.

app.js or index.js

Implement Localization in Components:

To enable language switching within specific components, locate the component where you wish to implement this feature. For instance, let's assume we want to integrate language switching functionality into the footer component.

To achieve this, utilize the useTranslation() hook within your component. Below is a simplified example:

If you need to extend localization to other files or components, follow a similar process. Import the useTranslation() hook and function and then enclose the content you want to translate within the t or translate keyword. For instance, in your Navbar.js component:

Remember, it's crucial to keep your translation files updated for each language you support. Ensure that both the keys and their respective translations are accurately maintained in files such as en.json:

Similar steps apply to other translation files for different languages your application supports. Always prioritize keeping your translations synchronized with the evolving content of your application. The same applies to the other translation files.

Conclusion:

Localization is not just about translating words; it's about creating inclusive experiences for users worldwide. By following these steps, you can seamlessly integrate localization features into your application, fostering engagement and accessibility across diverse linguistic backgrounds.

In today's interconnected world, breaking language barriers isn't just good practice—it's essential for building successful, user-centric applications.

Start your localization journey today and make your app resonate with users around the globe!

If you encounter any issues, please don't hesitate to ask for help.

From Banking Sales to Software Success: A Journey of Passion and Perseverance

Rita Nkem Daniel — Wed, 16 Aug 2023 10:23:13 +0000

In the bustling world of finance, where numbers and transactions reigned supreme, I found myself at a crossroads. A crossroads that promised the allure of technology, innovation, and a passion waiting to be unleashed. My journey from a salesperson in the banking sector to a budding software developer has been a rollercoaster of emotions, challenges, and incredible growth.

It all started with a quiet realization, a whisper within my heart that spoke of unexplored territories and unfulfilled dreams. The stark contrast between crunching numbers and the magic of code ignited a fire within me. Armed with an insatiable curiosity and an unyielding determination, I embarked on a path of transformation that would redefine my career trajectory.

My first major milestone was the decision to enroll in a rigorous software development boot camp(Microverse). It became my compass, leading me through the intricate web of programming languages, algorithms, and problem-solving techniques. As I immersed myself in this intense learning environment, I realized that I was not merely acquiring skills – I was crafting a new identity for myself. The challenges were immense, but with each hurdle I overcame, my confidence grew stronger.

Yet, technical prowess was only a part of my journey. I was drawn into the enchanting realm of open-source development. It was as if I had stumbled upon a hidden treasure trove of collaboration and innovation. With bated breath, I clicked on a link that read
Intro to Open Source. Little did I know that this click would forever alter the course of my story.

The world of open source welcomed me with open arms. I made my first contribution, a humble offering of code that carried my aspirations and dreams. The thrill was intoxicating as I anxiously awaited the outcome. The moment my first pull request was merged, a surge of accomplishment washed over me – a feeling that no sales target had ever invoked.
With every new line of code, I was building more than just software; I was crafting my future. The journey was arduous, peppered with sleepless nights and moments of self-doubt. However, these were outweighed by the sense of fulfillment and the camaraderie of fellow developers who shared my passion.

As I stand at the crossroads once again, I can't help but marvel at the path I've walked. From the corporate corridors of banking to the virtual landscapes of code, I've discovered a world that resonates with my deepest desires. The transition wasn't easy, but every challenge was a stepping stone to success.

My story is a testament to the power of embracing change and pursuing one's genuine vocation. It's a reminder that no matter where you start, your passion can lead you to remarkable destinations. The journey is ongoing, and the road ahead is filled with endless possibilities. With code as my canvas and innovation as my muse, I step into each day with a heart full of excitement and a determination to shape my destiny in the world of software development.

My Open Source Odyssey: Git Cherry-Pick and Collaboration

Rita Nkem Daniel — Thu, 10 Aug 2023 19:56:06 +0000

Embarking on the open-source journey is an exhilarating endeavour where the world of code unfolds with endless possibilities. As an ardent open-source enthusiast, I've ventured into this realm with a passion for contributing to projects that resonate with my interests. Throughout my journey, I encountered a challenge that piqued my curiosity and led me to discover the powerful tool known as git cherry-pick. This tale reflects my exploration of this tool and the importance of seeking help and embracing collaboration in the open-source community.

A Surprising Twist in the Open-Source Odyssey

Imagine this scene: I’ve poured my heart into a pull request (PR), shaping and refining code to perfection, with a sense of accomplishment, I eagerly open the PR, anticipating the moment of unveiling, only to be confronted by bewildering changes in the CHANGELOG.md file – changes that I never made. The realm of open source is a grand adventure that can bring unexpected twists. In this case, the integrity of version history and the accuracy of my contribution are at stake. In these moments of challenge, the open-source community shines, offering insights and solutions that pave the way forward.

Adding a layer of complexity to this puzzle, it's worth noting that the code reviewer, with a discerning eye, pointed my attention directly to the CHANGELOG.md file as the root of the issue. This revelation added a new layer of urgency to resolve the matter, as it was clear that rectifying the inconsistency in the changelog was crucial for the transparency and clarity of the project's development history.

The Power of Collaboration: Support Emerges

In the dynamic landscape of open source, collaboration is not just a concept; it's a way of life. Faced with the enigmatic changes, I found myself embraced by the essence of open source as support emerged unexpectedly. Collaborators within the open-source community are more than willing to share their expertise and lend a helping hand. Enter Brian with a wealth of experience. My query about the unexpected changes led him to share a technique that would shape my open-source journey git cherry-pick. His knowledge became my North Star, guiding me through unfamiliar terrain and illuminating a path that led to a deeper understanding of git cherry-pick.

Understanding Git Cherry-Pick

git cherry-pick is a powerful command in Git that allows you to apply specific commits from one branch to another. In essence, it enables you to pick a single commit or a range of commits and apply them to a different branch. This is particularly handy when you want to selectively incorporate changes without merging the entire branch.

Step-by-Step Guide to Using Git Cherry-Pick:

Identify the Problematic Commit: First, pinpoint the commit that introduced the unintended changes in the (CHANGELOG.md) file. This can be done by reviewing your commit history and PR.
Create a New Branch: Before performing any operations, create a new branch. It ensures that your original branch remains intact and any changes you make won't affect it directly.
Copy the Commit Hash: Locate the commit hash of the problematic commit. This hash uniquely identifies the commit you want to cherry-pick.
Execute the Cherry-Pick Command: Open your terminal and navigate to your repository. Use the following command to cherry-pick the specific commit onto your new branch:
```
 git cherry-pick <commit-hash>
```

Replace with the actual commit hash.

Resolve Conflicts: When applying the commit to your new branch, there might be conflicts. Git will prompt you to resolve these conflicts manually. Use a merge tool or edit the conflicting files directly.
Test the Changes: Once conflicts are resolved, thoroughly test your code to ensure that the cherry-picked changes have been applied correctly and haven't introduced any new issues.
Review and Merge: With your new branch containing the cherry-picked commit and verified changes, you can create a new pull request. Ensure that your changes are reviewed before merging.

The open source odyssey is an exciting journey of discovery, where every challenge becomes a stepping stone towards greater understanding. My expedition into the open source realm brightened the path to git cherry-pick, a tool that has emerged as my ally in resolving the unexpected changes puzzle. As I reflect on this adventure, it's clear that open source is more than just code – it's a vibrant community united by the spirit of collaboration and support.

As you navigate your own open source path, remember the lessons from this tale – the thrill of overcoming challenges, the appreciation for the knowledge shared, and the profound impact of collaboration. Embrace the journey wholeheartedly, for within its twists and turns, you will find not only the lines of code that shape projects but also the connections and possibilities that shape you as a developer and a collaborator.