DEV Community: Jude Ndubuisi 🥷🧑‍💻

🔐 Mastering Account Initialization and PDAs on Solana 🚀

Jude Ndubuisi 🥷🧑‍💻 — Sat, 28 Dec 2024 13:14:12 +0000

Over the past few weeks, I’ve been diving deep into Rust and Solana development, and this snapshot represents one of the key aspects of my journey: initializing accounts and leveraging Program Derived Addresses (PDAs) to build secure and efficient on-chain programs.

This particular project is a Token Lottery System, where I’m implementing:
1️⃣ Account Initialization: Setting up metadata accounts, mint authorities, and user ticket accounts. On Solana, account initialization is a critical step that requires precision to ensure alignment with the program logic and data structures.

2️⃣ PDAs (Program Derived Addresses): Using PDAs to create deterministic and secure addresses that the program can sign for, eliminating the need for private keys. This ensures trustless execution and simplifies the management of on-chain resources.

3️⃣ Cross-Program Invocations (CPIs): Efficiently interacting with Solana programs like the Token Program and Metadata Program to handle NFTs, collections, and token supply.

🔧 One key takeaway is how powerful and flexible Solana's account model is. While it comes with a learning curve, once you understand how to manage accounts and PDAs, the possibilities are endless. The use of Anchor framework has been invaluable in abstracting some of the complexities, making development more intuitive while maintaining performance.

💡 Key Concepts I’ve Gained So Far:

Proper handling of account rents to optimize storage.

Structuring Signer Seeds for deterministic PDA generation.

Verifying collections and metadata in NFT-based systems.

Building on Solana has been an eye-opener, showcasing the true potential of Web3 development and decentralized systems. Excited to continue learning and contributing to this space!

To all my fellow Rust and blockchain developers: let’s connect and exchange knowledge. What’s your biggest “aha” moment in blockchain development?

What happens when you type google.com in your browser and press Enter?

Jude Ndubuisi 🥷🧑‍💻 — Tue, 10 Oct 2023 20:23:45 +0000

In the realm of software engineering, understanding the underlying mechanisms that power our daily internet interactions is crucial. When you type https://www.google.com into your browser and hit Enter, a fascinating journey begins - transcending various layers of the web stack before the desired webpage graces your screen. Let's delve into this journey, demystifying the complexities involved.

The Initiation: DNS Request

Our journey begins with a Domain Name System (DNS) request. The browser seeks to translate the human-friendly domain name www.google.com to an IP address, the language of computers. A query is sent to a DNS server, which acts like a phonebook for the internet, fetching the corresponding IP address for Google's server.

The Protocol Suite: TCP/IP

With the IP address at hand, Transmission Control Protocol/Internet Protocol (TCP/IP) - the protocol suite - kicks in. TCP establishes a reliable connection between your machine and Google's server, ensuring data integrity and order. IP, on the other hand, is responsible for routing the data packets to the correct destination.

The Guard: Firewall

Before the packets venture further, they encounter the firewall - a security system ensuring that only safe and authorized traffic is allowed through. The firewall scrutinizes the packets based on predefined rules before permitting them onward.

The Secure Passage: HTTPS/SSL

As we tread into a secure domain (https), Secure Socket Layer (SSL) or its successor Transport Layer Security (TLS) ensure a secure connection by encrypting the data transferred between your browser and Google's server, safeguarding against eavesdropping.

The Distributor: Load Balancer

Arriving at Google's premises, a load balancer warmly welcomes the packets. Its job is to distribute incoming network traffic across several servers to ensure no single server becomes overwhelmed with too much traffic. This way, it ensures a seamless user experience.

The Frontman: Web Server

Post load balancing, the web server takes the stage, handling the HTTP request. It decides what action is needed, often communicating with an application server to process the request further.

The Processor: Application Server

The application server is the brain behind the operation, executing the necessary business logic, interacting with the database, and preparing the HTTP response to be sent back to your browser.

The Storer: Database

To fulfill your request, the application server might need to fetch or store data. It interacts with the database, where data is stored, retrieved, and managed, ensuring that your search query is successfully executed.

The Grand Finale: Rendering

The HTTP response makes its way back through the channels, reaching your browser which then renders the HTML, CSS, and JavaScript to display the webpage we all know and love as Google.

This orchestrated sequence of events, though appearing instantaneous to us, embodies a marvel of engineering and a testament to the boundless possibilities within the realm of technology.

Understanding parseInt in JavaScript: Usage, Quirks, and Best Practices

Jude Ndubuisi 🥷🧑‍💻 — Thu, 05 Oct 2023 20:58:53 +0000

Introduction to parseInt

JavaScript is a dynamic, flexible language that allows for various ways to achieve a task. One such task is parsing strings into integers, which can be accomplished using the parseInt function. This article delves into the parseInt function, exploring its syntax, quirks, and best practices to arm you with the knowledge you need for effective string-to-integer conversions.

What is parseInt?

parseInt is a function in JavaScript used to convert a string into an integer. It parses through the string until it reaches a character that isn't a numeral, returning the integer formed by the preceding numerals.

Basic Usage and Syntax:



let result = parseInt(string, radix);

Here, string is the string you want to parse, and radix is an optional parameter that specifies the base of the numeral system to be used.

The Importance of Radix

A radix or base in number systems refers to the number of unique digits, including zero, used to represent numbers in a positional numeral system. In JavaScript, the radix can range from 2 to 36.

Specifying a radix is crucial because it ensures consistent behaviour across different environments. Without specifying a radix, parseInt could interpret the string as octal, decimal, or hexadecimal based on its content, which could lead to unexpected results.

Automatic Type Conversion

parseInt is versatile and handles various types of inputs by performing automatic type conversion. When passed a float, it discards the decimal part and converts the integer part. When an invalid string, it returns NaN.



console.log(parseInt('123.45')); // 123

console.log(parseInt('abc123')); // NaN

Handling Invalid Inputs

Passing an invalid string or a string with mixed characters to parseInt can yield unexpected results. If the string starts with a numeral, parseInt will continue parsing until it reaches a non-numeric character and then return the integer value parsed so far. If the string starts with a non-numeric character, parseInt returns NaN.



console.log(parseInt('123abc')); // 123

console.log(parseInt('abc123')); // NaN

Common Use-Cases

parseInt is commonly used in situations where a string representation of a number needs to be operated upon as an integer. This is common in web development when receiving numeric input as strings from form fields or URL parameters.

Alternatives to parseInt

Other methods for converting strings to integers include the Number() function, the unary + operator, and Math.floor(). Each has its own set of behaviours and performance characteristics.

Performance Considerations

parseInt performs reasonably well but might not be the fastest method for all scenarios. In performance-critical code, alternative methods like unary + or Number() might be preferable due to their slightly faster execution times.

Best Practices

It's advisable to use parseInt when you need to parse a string into an integer, especially when the string might have leading non-numeric characters. Always specifying the radix is crucial to avoid unexpected behaviours.

Conclusion

Understanding the parseInt function and its quirks is essential for effective string-to-integer conversions in JavaScript. By following the best practices outlined, you can ensure consistent, reliable behaviour in your code.

Additional Resources

MDN Web Docs - parseInt()

JavaScript.info - Type Conversions

Open Source Made Easy: A Step-by-Step Guide to Contributing to Your First Project

Jude Ndubuisi 🥷🧑‍💻 — Sun, 02 Apr 2023 07:55:58 +0000

Just recently I made my first open-source contribution to a project and it's not as scary or advanced as many taught including me too

So I decided why not make an article about it to help others know and understand it too as I did while removing all the ambiguity attached to it

1.
First, find an open-source project that you're interested in contributing to. You can use websites like GitHub to search for open-source projects, or you can search for projects related to a specific language or technology.

2.
Once you've found a project you're interested in, read the project's documentation to understand its goals, roadmap, and how to contribute. Most open-source projects have a CONTRIBUTING.md file that provides guidelines for contributing.

3.
Next, find an issue that you'd like to work on. You can search for issues that are labelled "good first issue" or "help wanted" if you're new to the project, and the best thing is it doesn't even have to be code, you can start contributing to the project documentation. Eg if to find a typo or an omission you can work on that.

4.
Before you start working on an issue, it's important to communicate with the project maintainers. They can provide guidance and answer any questions you have. You can use the project's communication channels, such as discord, slack, or any medium the project uses for communication.

5.
Once you've communicated with the maintainers and chosen an issue to work on, fork the project's repository to your own GitHub account. This creates a copy of the project that you can work on without affecting the original codebase.

6.
Make your changes to the codebase, but before doing that make sure you created a new branch for the task you want to work on so this way you can still have the original code in the master before pushing, your changes should be made following the project's code style and guidelines. Write tests for your code if the project has a test suite

7.
Once you've made your changes, commit them to your forked repository and create a pull request. In the pull request, explain what changes you've made and why they're important. Be sure to reference the issue you're addressing in the pull request.

8.
The project maintainers will review your pull request and provide feedback. You may need to make additional changes to your code based on their feedback.

9.
Once your pull request is accepted and merged into the project's codebase, congratulations! You've contributed to an open-source project.

10.
Remember to stay engaged with the project's community. Follow the project on GitHub, participate in discussions, and continue to contribute to the project. This will help you build your skills, network with other developers, and make a positive impact on the open-source community.

That's it! Good luck with your open-source contributions!🤓

If you like this and want more content like this please do well to follow me and turn on the notification for more.

Unleashing the Power of Memphis.dev: A Guide for Developers and Data Engineers

Jude Ndubuisi 🥷🧑‍💻 — Mon, 20 Mar 2023 14:49:12 +0000

You might be wondering, "What is Memphis?" In this post, we'll go into great detail about it and some of the incredible capabilities it has to offer to both developers and data engineers, as well as what they can accomplish with it.

Prerequisites

Knowledge of command-line tools: Memphis is installed and configured using the command line, therefore readers should be comfortable using it.
A fundamental understanding of any of the following programming languages and frameworks: Go, JavaScript, Python, Typescript, etc. This will make it easier for you to understand the idea presented in this post, but don't worry—I've got you covered.

What exactly is a message broker?

You might be asking what these "messages" are because a message broker is a middleman who makes it easier for producers and consumers to exchange messages. These fundamental data packets are transmitted between producers and consumers. In general, messages in Memphis are an important part of the model for data streaming pipelines employed by the tool, which is necessary for creating reliable and adaptable data pipelines and event-driven systems and is frequently referred to as Message Queue

What exactly is Memphis Broker?

Memphis is a cloud-native message broker that is simple, robust, and durable. When they say it, they are just stating the fact that Memphis is a next-generation replacement to existing message brokers. Combining Rapid Development, stability, performance, and efficiency all at once, it delivers a positive developer experience. How frequently does a message broker do that?

Memphis also includes a UI and CLI to assist you to speed up development and let you concentrate on what is important.

Memphis is currently supported by NodeJS, TypeScript, NestJS, Go, and Python, with support for additional languages coming soon.

Why is Memphis significant in data engineering and why?

Memphis differs from other message brokers, such as Apache Kafka and RabbitMQ, in that it requires less coding on the part of developers to set up. Memphis allows you to embed processing an application and perform activities while it's inside, in addition to ingestion and data collection. Memphis uses extremely few lines of code and Schema management is a key component of what it does.

Here are some explanations on why message brokers like Memphis are crucial in data engineering and development.

Stability: It might be challenging to make sure that all of your systems can handle the load as the amount and complexity of data increase. You may spread the load across several systems and make sure that your pipelines can scale up or down as necessary by employing a message broker.
Microservices async communication: In the Kubernetes context, it offers a potent tool for managing asynchronous communication between microservices. By separating your systems and services using a message broker, you can add, remove, or modify components without affecting the pipeline as a whole. Your pipelines may be simpler to maintain and develop as a result.
Effectiveness and Performance: Making use of a message broker can help to ensure that data is not lost in transit and that messages are delivered consistently. In mission-critical systems, where data loss can have negative effects, this can be very crucial.
Real-time processing: Instead of waiting for batch processing, you may process messages as they come in via a message broker. This can be especially crucial in systems that depend on quick processing, like fraud detection or real-time analytics

Memphis installation and configuration

Memphis may now be set up and configured in one of two ways: using Kubernetes, which is primarily for production, or using Docker to run it locally on your workstation. In this article, Docker will be used. A group of platform-as-a-service solutions known as Docker provide software in packages known as containers using OS-level virtualization.
Containers can communicate with one another through well-defined channels and are insulated from one another while bundling their software, libraries, and configuration files. Docker must be installed and operational before you can install Memphis.

Run this command on your terminal to install Memphis.

curl -s https://memphisdev.github.io/memphis-docker/docker-compose.yml -o docker-compose.yml && docker compose -f docker-compose.yml -p Memphis up

Once Memphis is installed, you may choose the language you want to use to create and consume messages. Memphis queues are referred to as stations, just like RabbitMQ has queues and Kafka has topics.

Once Memphis has started running in your terminal, you can access the UI by navigating to "http://localhost:9000/." Memphis has a stunning user interface that makes it the best available and is friendly for beginners.

When Memphis is operating, you can see this in your terminal.

2023-03-13 23:25:36 UI/CLI/SDK root username - root 2023-03-13 23:25:36 UI/CLI root password - memphis 2023-03-13 23:25:36 SDK connection token - memphis
Use the standard login credentials of "root" and "memphis" to log in. When you install Memphis using Docker, these are the "root" user's default login credentials.

I'll be using stock feed as my station name and factory name for this project, but you may choose whatever name you choose to depend on the project you're working on.

What will we be constructing?

For this project, I'll create a straightforward program that downloads a set of firms' random stock values and delivers them to the "stock prices" station. By subscribing to the same station, the consumer receives and prints out the stock prices for their separate clients. The "price producer" and the "price consumer" are the only two functions this app will have. This allows you to create any complex software you want, which is what Memphis is for.

Let's get going

I'll be utilizing Python to create this application.

Make a new, empty directory and give it any name you like; I'm calling my stock feed.

mkdir stock_feed
cd stock_feed

as soon as you enter the directory, launch the Python virtual environment

python -m venv .venv

Use the pip command to install Memphis in your project.

pip3 install --upgrade memphis-py

You can now get going and begin writing your code.

Let's first create the producer, which we'll call "price producer.py," from which all signals flow.

import asyncio
import random
from memphis import Memphis, Headers, MemphisError, MemphisConnectError, MemphisHeaderError, MemphisSchemaError

async def main():
    try:
        # Create a Memphis instance and connects to the Memphis server
        memphis = Memphis()
        await memphis.connect(host="localhost", username="stock_feed", connection_token="memphis")

        # Create a producer for the stock_prices station and set headers
        producer = await memphis.producer(station_name="stock_prices", producer_name="stock_price_producer")
        headers = Headers()

        while True:
            # Continuously sending the prices to the Memphis server
            company = random.choice(["META", "MSFT", "AAPL", "GOOG", "FB", "AMZN", "TSLA"])
            price = round(random.uniform(100, 500), 2)
            headers.add("company", company)

            print(f"Producing: {company} - ${price}")
            await producer.produce(bytearray(f"{price}", 'utf-8'), headers=headers)
            await asyncio.sleep(1)

    except (MemphisError, MemphisConnectError, MemphisHeaderError, MemphisSchemaError) as e:
        print(e)

    finally:
        await memphis.close()

if __name__ == '__main__':
    asyncio.run(main())

When the aforementioned code is executed using "python price_producer.py," it transmits stock feed messages to the Memphis station continually while it waits for a user to access them.

Second, we'll create the consumer—call let's it "price_consumer.py"—from where all messages originate. The consumer can then access these messages.

import asyncio
from memphis import Memphis, MemphisError, MemphisConnectError, MemphisHeaderError

# Define the asynchronous main function for the price consumer
async def main():
    async def msg_handler(msgs, error, context):
        try:
            for msg in msgs:
                company = msg.get_headers().get("company", "UNKNOWN")
                price = msg.get_data().decode('utf-8')
                print(f"Received: {company} - ${price}")
                await msg.ack()

                if error:
                    print(error)

        except (MemphisError, MemphisConnectError, MemphisHeaderError) as e:
            print(e)
            return

    try:
        # Create a Memphis instance and connect to the Memphis server
        memphis = Memphis()
        await memphis.connect(host="localhost", username="stock_feed", connection_token="memphis")

        # Create a consumer for the "stock prices" station 
        consumer = await memphis.consumer(station_name="stock_prices", consumer_name="stock_price_consumer", consumer_group="stock_price_group")
        consumer.set_context({"key": "value"})
        consumer.consume(msg_handler)

        # Keep your main thread alive so the consumer will keep receiving data
        await asyncio.Event().wait()

    except (MemphisError, MemphisConnectError) as e:
        print(e)

    finally:
        await memphis.close()

if __name__ == '__main__':
    asyncio.run(main())

Now, the messages that are already on the Memphis server may be accessed by the consumer when it is launched using python price_consumer.py.

Memphis has a stunning UI that allows you to view each packet of data sent and received, along with its payload, all with only a few lines of code, boosting productivity and allowing developers to concentrate on what counts.

Source Code

Conclusion

Memphis is a potent distributed messaging system that gives programmers and data engineers a very dependable, scalable, and effective way to exchange messages across programs, services, and systems. Teams may create and scale large-scale applications using Memphis' messaging technology, which can be utilized to create distributed systems and microservices architectures.

The ease of use, scalability, and simplicity of Memphis are three of its main advantages. The Memphis API is straightforward for developers to use from the get-go since it is clear and simple to understand. Developers may send and receive messages across various apps, systems, and languages with just a few lines of code. Memphis is a flexible option for teams that use a variety of technologies because it supports a wide range of programming languages, including Python, TypeScript,.NET, and Go, among others.

In conclusion, Memphis is a fantastic option for programmers and data engineers who require a strong, scalable, and trustworthy messaging system for their distributed systems.

Buy me a coffee ☕

Use one of the buttons below to purchase a coffee for me if you enjoyed and found value in my essay. In ahead, I appreciate it.

Buy me a coffee

Please like and follow for more material if you can. This is my first in-depth technical essay on a project, so if you have any questions or find any mistakes, just let me know.

References

Memphis Docs

The Power of Generative Adversarial Networks (GANs) in creating realistic digital images!

Jude Ndubuisi 🥷🧑‍💻 — Sun, 05 Mar 2023 19:34:07 +0000

I know most of us have been seeing a lot of AI Generated Realistic Images out online, by the big tech companies and small ones,but do you know how it works 🤔

Let’s talk about the Power of Generative Adversarial Networks (GANs) in creating realistic digital images!

GANs are a type of neural network that are trained to generate new data that is similar to a dataset of existing data. This is done by training two neural networks, a generator and a discriminator, against each other.
The generator creates new images, and the discriminator tries to determine if the generated images are real or fake. As the training progresses, the generator gets better at creating images that can fool the discriminator

This technique has been used to create realistic digital images of everything from faces to landscapes, and even entire scenes from movies
One of the most impressive examples of GANs in action is the creation of ultra-realistic digital humans. This could have a wide range of applications, from video games to virtual assistants to virtual reality experiences
GANs also have the potential to revolutionize industries such as fashion and interior design. By creating digital images that are indistinguishable from photographs, GANs could be used to create virtual clothing and home decor collections, reducing the need for physical samples
GANs are not without their limitations, however. They can be difficult to train, and the generated images can still have flaws that reveal them to be fake. But as the technology continues to develop, we are likely to see more and more realistic and impressive images generated by GANs

Overall, GANs are a powerful and exciting tool for creating realistic digital images, and we are only just beginning to scratch the surface of what is possible with this technology
If you love this content and wants more of tech related content, please support it by commenting, giving it a like and following my page, I will really appreciate ☺️. I post informative post on Web Development, Programming, Tech news and more in-between 💯

The Benefits of Learning a New Programming Language

Jude Ndubuisi 🥷🧑‍💻 — Fri, 03 Mar 2023 12:40:37 +0000

As a Developer, it’s important to continually expand your knowledge and skillset. One way to do this is by learning a new programming language.

But why is it worth the effort to learn a new language? Here are just a few benefits:

Improved problem-solving skills: Learning a new programming language forces you to think in different ways and approach problems from a different perspective. This can help you become a more versatile and effective problem-solver, which is a valuable skill in any field.
Increased job opportunities: Knowing multiple programming languages can make you a more attractive candidate for job openings. It shows that you are dedicated to staying current and expanding your skillset, which is highly sought after by employers.
Enhanced ability to learn other languages: Once you have learned one programming language, it becomes easier to pick up additional languages. This is because you have already gained the fundamental skills and knowledge that are needed to learn a new language.
Improved efficiency: Knowing multiple programming languages can also make you more efficient in your work. If you are working on a project that requires the use of a specific language, having a familiarity with that language can help you get up to speed more quickly and get the job done more efficiently.

Overall, learning a new programming language can bring numerous benefits to your career as a web developer. It can improve your problem-solving skills, increase your job opportunities, make it easier to learn additional languages, and enhance your efficiency. So why not consider learning a new language today?