DEV Community: Moyomade

From Introvert to Tech: A Journey of Personal Growth and Community Connection

Moyomade — Sun, 11 Aug 2024 22:43:31 +0000

The Extrovert Years

In high school, I was the quintessential extrovert. As the sports prefect for two years, I lived and breathed athletics. The outdoors called to me, and I answered with enthusiasm. But alongside my love for sports, I harbored a secret passion for technology, actively participating in the JETS (Junior Engineers, Technicians, and Scientists) club.

The Turning Point

Everything changed on a fateful Wednesday during a routine sports session. An accident left me with a broken left leg, and for nearly a year, walking was impossible. When I finally recovered, my dreams of a sports career had evaporated. It was a crushing blow, but little did I know, it was also the beginning of a new chapter.

The Introverted Cocoon

Fast forward to a few months after college, and I found myself retreating inward, becoming an introvert I never thought I'd be. This introspective period lasted about two years, during which I contemplated my next move.

Discovering Tech

My entry into the tech world was unconventional. A friend's social media status about learning HTML and CSS caught my eye, and I reached out, eager to follow in his digital footsteps. Without a laptop, I turned to my smartphone, downloading apps and tapping out code on a tiny screen. It wasn't ideal, but it was a start.

The Solo Mistake

In my newfound introversion, I made a critical mistake – I tried to go it alone. For a while, it seemed to work, but soon I hit a wall. Questions plagued me: Where do I go from here? How do I know if I'm good enough?

Embracing Community

It was time for another transformation. Swallowing my fears, I joined tech communities and reached out to others in the field. The results were immediate and profound:

I found a mentor who's been guiding me for over a year
LinkedIn became a source of contracts and internships
I rediscovered the joy of peer interactions

Where I Am Today

Today, I'm not just a coder – I'm part of a vibrant community. I help others, seek help when needed, and continually grow alongside a group of amazing individuals who inspire me daily. This journey has taught me the power of resilience, adaptability, and community in tech.

Lessons Learned

Setbacks can lead to unexpected opportunities
It's okay to change and evolve – from extrovert to introvert and back again
Learning in isolation has its limits; community is key
Putting yourself out there can be scary, but it's worth it
The tech journey is a marathon, not a sprint

A Message to Fellow Tech Enthusiasts

To those standing where I once stood, hesitating at the threshold of the tech world, I say this: It's not as daunting as it seems. That first step may feel scary, but it's the gateway to incredible opportunities and personal growth.

Remember, the tech journey is a marathon, not a sprint. Embrace the community around you, help others along the way, and watch yourself grow exponentially. You're amazing at what you do – or what you will do. Be bold, put yourself out there, grow with a community, and unlock your potential.

Your future in tech awaits. Take that step, and let's code this journey together!

Masking vs Encryption in JavaScript: A Comprehensive Guide for Secure Data Handling

Moyomade — Thu, 11 Jul 2024 11:50:05 +0000

In today’s digital world, securing sensitive data is paramount, especially when working on applications that handle financial information. Recently, while developing a finance dashboard, I implemented a technique I initially believed to be encryption but later realized was masking. This realization spurred a deep dive into the differences between masking and encryption, leading to this blog post. Here, I’ll share my findings to help you understand these techniques, their applications, and their importance in data security.

Why This Topic?

Personal Experience:
As a developer, I always strive to implement the best security practices in my projects. While working on a finance dashboard, I used a technique to obscure sensitive data, thinking it was encryption. This technique involved displaying only partial data, like showing only the last four digits of a credit card number. Curious about whether this approach was truly encryption, I embarked on a research journey. My goal was to clarify the distinctions between masking and encryption and share this knowledge with others who might face similar confusion.

Understanding Masking

Definition and Purpose:
Masking is a technique used to hide parts of sensitive data, making it readable only in a limited context. Unlike encryption, masking does not transform the data into an unreadable format but rather obscures certain parts to protect sensitive information while maintaining some level of visibility.

Example: Masking a Credit Card Number:

In this example, the function replaces all but the last four digits of the credit card number with '*', effectively masking the sensitive parts.

Applications:

Displaying partial data in user interfaces (e.g., last four digits of a credit card).
Protecting data in logs and reports.
Ensuring privacy in testing and development environments.

Understanding Encryption

Definition and Purpose:
Encryption is the process of converting plaintext into ciphertext, an unreadable format, using a specific algorithm and key. The primary goal is to protect data confidentiality, ensuring that only authorized parties with the correct decryption key can access the original information.

Example: AES-256-CBC Encryption:

In this example, the AES-256-CBC algorithm securely encrypts and decrypts a text message, demonstrating the transformation of plaintext into ciphertext and back.

Applications:

Securing data in transit (e.g., HTTPS).
Protecting stored data (e.g., database encryption).
Ensuring confidentiality in messaging apps.

Practical Applications and Examples

Masking Use Case:
In a finance dashboard, you might want to display only the last four digits of a customer's credit card number to protect their privacy:

Encryption Use Case:
For storing sensitive data in a database, encryption ensures that even if the database is compromised, the data remains secure:

Conclusion: Making the Right Choice

When it comes to data security, both masking and encryption have their roles. Masking is ideal for situations where you need to obscure data without changing its format, while encryption is essential for ensuring data confidentiality. Understanding the differences and appropriate use cases for each technique will help you make informed decisions in your development projects.

Final Thoughts:

My journey from confusion to clarity on this topic has reinforced the importance of continuous learning and sharing knowledge. I hope this guide helps you navigate the complexities of data security and implement the best practices in your projects.

Understanding JavaScript Function Declarations: 'function' vs 'const'

Moyomade — Wed, 15 May 2024 02:39:35 +0000

JavaScript, as a versatile and dynamic language, offers multiple ways to define functions. Among these, 'function' declarations and 'const' function expressions stand out as two common approaches. Understanding the differences between them is crucial for writing efficient and error-free JavaScript code. In this article, we'll explore the nuances of 'function' declarations and 'const' function expressions, their implications, and best practices.

Exploring the Basics
'function' Declarations: These are traditional function definitions that are hoisted within their scope. This means you can call them before they are declared in the code.

'const' Function Expressions: When defining functions using 'const', it creates a function expression. Unlike 'function' declarations, 'const' function expressions are not hoisted and result in an error when called before declaration.

Understanding Hoisting in JavaScript
Hoisting is a JavaScript mechanism where variables and function declarations are moved to the top of their containing scope during compilation.
'function' declarations are hoisted, allowing them to be called before their declaration in the code.
Conversely, 'const' function expressions are not hoisted, and calling them before declaration will result in an error.

Practical Example

Conclusion
Understanding the differences between 'function' declarations and 'const' function expressions enables cleaner, more efficient JavaScript code. By mastering hoisting implications and choosing the right method, developers enhance code reliability and maintainability. Whether leveraging hoisting or constancy, mastering these concepts is essential for JavaScript proficiency.

Beyond the Calculator: Exploring Reverse Polish Notation with JavaScript

Moyomade — Thu, 18 Apr 2024 23:22:27 +0000

Have you ever gotten frustrated with all those parentheses in your calculator expressions? Especially when dealing with complex calculations? Well, fret no more! This article will introduce you to Reverse Polish Notation (RPN), a way to write expressions that eliminates the need for parentheses altogether. We'll even build a simple RPN calculator in JavaScript!

The Struggle with Infix Notation

Traditional calculators use infix notation, where operators (+, -, *, /) sit between the numbers they operate on. For example, 2 + 3 * 4 means "add 2 to the product of 3 and 4". This works fine for simple expressions, but as things get more complex, parentheses become necessary to specify the order of operations. Imagine trying to write something like "(2 + 3) * (4 - 1)" without parentheses!

Introducing Reverse Polish Notation (RPN)

Reverse Polish Notation (RPN) flips the script on operators. Instead of being placed between operands, operators come after the numbers they act on. This eliminates the need for parentheses entirely! Let's rewrite our previous example in RPN:

2 3 + 4 *

Here, we read from left to right: add 2 and 3, then multiply the result by 4. Much simpler, right?

Want to learn more about RPN?
Check out this resource: http://www.computersciencebytes.com/array-variables/reverse-polish-notation/

Building our RPN Calculator

Now, let's translate this concept into code and build a basic RPN calculator in JavaScript. We'll use a concept called a "stack" to keep track of operands during the calculation. Think of a stack like a stack of plates - you take the top plate (the last one added) first, i.e Last In First Out (LIFO) implementation.

Wanna learn more about the Stack Data Structure and it’s Basic Operations?
Check out this resource: https://www.geeksforgeeks.org/stack-data-structure/amp/

Here's a breakdown of the code:

Explanation:

The calculate function takes an RPN expression as input.
We split the expression into tokens (numbers and operators) based on spaces.
An empty stack is created to store operands.
We loop through each token:
If it's a number, we convert it to a floating-point number and push it onto the stack.
If it's an operator, we pop two operands from the stack, perform the operation, and push the result back onto the stack.
Finally, if there's only one element left in the stack (the answer), it's returned. Otherwise, the expression is invalid.

Let's Try it Out!

Now that we have our calculator, let's see it in action! Here are some examples of how to use the calculate function:

console.log(calculate("2 3 + 4 *")); // Output: 20
console.log(calculate("4 5 - 2 *")); // Output: -2
console.log(calculate("1 2 3 + *")); // Output: 5

Give it a try!

Want to learn more about converting infix expression to prefix expression?
Check out this resource: https://www.geeksforgeeks.org/convert-infix-expression-to-postfix-expression/amp/