DEV Community: Stanley Ugwu

Your Brilliant Idea Might Actually Suck

Stanley Ugwu — Sun, 21 Jul 2024 17:43:59 +0000

Hello wonderful person 👋🏾,

Allow me to attempt describing you and/or most of us developers and entrepreneurs, and a little bit about our journey in few sentences.

I'd bet you've dabbled some few technologies and experimented with various ideas in the past, It's 50/50 chance you have an unfinished project somewhere - if you're a developer - that you used to be very passionate about in the beginning.

What happened? Why is it unfinished? Laziness? lack of resources? You realised the idea won't work? Well I too fit the description above, and even tho sometimes I'm just lazy to finish up what I started, most times it's not that (If I'm motivated by the idea it's hard to be lazy), and it's not lack of resources.

I've just learned - the hard way - that while ideas can change the world, not all ideas should be pursued for some very strong reasons, which I usually miss due to the temporary excitement that comes with ideas.

Misled by Excitement

The excitement of a new idea can be overwhelming. We rush to start building, neglecting to consider some important factors like the time and resources required. We crack open our editor and start coding, only to find ourselves, weeks or even months later, questioning the entire concept.

By this point, we've invested significant effort and resources, and then we start to face some issues like lack of clear user demand, lack of resources, and most times we're just duplicating some product out there that already solves the problem efficiently.

Sometimes we persist on building because we don't want our efforts to be wasted, even when we ourselves no longer believe in the idea. It's crucial to understand that while experimentation is essential, it's equally important to validate our ideas before throwing in our valuable resources into development.

I understand that not all ideas may need validation before we go on to develop it (e.g when you have a way to reverse a binary tree with O(1) time complexity 😂), and I understand that sometimes you just need a proof of concept as soon as you have an idea like when you forget your flash drive at home and have an idea for a program to store your files in the cloud so it can be accesses from all your devices so you don't carry around your flash drive (looking 👀 at you Drew at DropBox. I'm just saying, before you go all in on something you expect to put in front of a lot of users, do some work on validating it.

The Shift in Approach

My initial process for bringing ideas to life was straightforward:
Idea -> Design -> Code

This is a mantra for many, and it was for me. I'd rush from an idea to making sketches and UI designs, then start dabbing keys right away. This approach, however, often led to unfinished projects and abandoned Figma designs because I'd realise midway into design or development that the ideas or the way I thought about them were really flawed. Sometimes I'd realise there's no clear user demand, or the cost of development or maintenance would be too much to start with.

Recognizing this flaw, I adjusted my approach to:
Idea -> Validation -> Design -> Code

Before doing anything design or development, I ensure that I validate the idea thoroughly. This validation step saves me some very valuable resources like time and efforts, helps me think more deeply about the concept and idea, highlights potential errors, and sometimes even unlocks new ideas. The confidence gained from this process alone is invaluable, and also you get to know to some great extent, how likely success is, for your product.

My New Approach

Here's a detailed look at the steps I follow to validate and plan the execution of my ideas. This is not the best approach and you may need to modify or build on it. It's not a one-size-fits-all approach, it's just something I spent time and efforts coming up with, and has really been working for me.

Here are the steps:

1. Ideation

This is the magical moment when you come up with your billion-dollar idea that will change the world. You're in your zen mode, you know exactly the problems your idea would solve, you're very clear on the steps you need to take in bringing your idea to life, you seem to know how everything will work out, the features you'll be adding, and sometimes you even know the features you'd add later in the future.

For me at this point, I let my thoughts run wild without limitations, I don't try to think of what's possible and what's not. I jot down everything, make sketches, and document as much as possible. I don't worry about feasibility at this stage; I just focus on capturing the essence of the idea.

2. Market Research

Now that you have your rough notes and maybe some sketches, try and answer these critical questions:

Who would need your product? Who is your target audience?
What is their demographic?
Has anyone built something similar? Who is that?
What are their offerings and features?
Do you have unique features to offer or can you improve on existing ones?
What will be your revenue model? How can you make money?

These are just some questions to get you thinking. Conduct thorough research to learn as much as you can about your target customers, competitors, and market trends. This step is crucial for refining or validating your value proposition and figuring out how to penetrate the market.

3. Value Proposition

The insights gained from ideation and market research should help you craft a concise value proposition. This statement should clearly articulate how your product uniquely offers value to its target users. It summarises why a customer would choose your product or service.

For me at this point, if I still feel motivated about the idea and believe it offers something unique or different, I proceed. If not, it's usually a sign to stop.

4. Business Model

With a solid value proposition, create a business model that outlines key details such as revenue streams, key activities, resources, cost structure, customer segments, and partnerships. Use a business model canvas template to ensure all necessary aspects are covered.

5. Product Features

List all the features you want your project to have. Prioritise features based on your value proposition and critical users' needs. If using a freemium model for instance, distinguish between free and paid features. Also very importantly, identify the features that will be part of your MVP.

6. UI/UX Design

Now it's time to translate your ideas into sketches and wireframes, and then a polished UI design. Normalize not building a project without a UI design, it's unnecessarily stressful (imagine trying to come up with a good colour for your header, and also the perfect flow for onboarding users). This step helps you visualise the end product and identify any design-related issues early on.

7. Product Roadmap

Create a timeline for completing the project features you mapped out for you MVP and/or the complete product, setting milestones for each major accomplishment along with deadlines. This roadmap will guide your development process and keep you on track. It mustn't be perfect and you also have templates and tools out there to help you. I use (ClickUp)[http://clickup.com] for this, but you can use anything that works. The goal is to have a timeline that'd guide you and keep you in check.

8. Development

Now you have most things in check. You know what you're building, who you're building for, what problems you're trying to solve, how long it'll take you to come up with a solution, what the solution would look like, how it'll generate you revenue, etc.

You're essentially ready to run a business. Now it's time to go into development and its life cycle. It's time for birthing. It's time to change the world.

Conclusion

By integrating validation into my process, I've been able to save time, focus my efforts, and build with confidence. While this approach may not be a one-size-fits-all solution, it has worked well for me and can be adapted to fit different needs. I encourage you to refine and build upon this process to suit your unique journey.

Remember, validating your ideas is not just about preventing wasted effort; it's about ensuring that the solutions you build are impactful and truly solve the problems they are meant to address.

Thanks for reading, happy coding. ✌🏾

Image credit: https://images.app.goo.gl/smNDbijbRjZt6m5u7

JavaScript in the threads: Unveiling React Native Threads and Differential JS Handling in Debug versus Release Modes

Stanley Ugwu — Wed, 16 Aug 2023 01:02:32 +0000

Heyo dev! 👋

Below is a lil bit extended version of the answer I gave to a SO question I came across recently. I decided to spread it here too incase anyone is still stuck with the same question or just want to get an overview of how a React Native app is architected and work internally.

I'm just going to try to explain the roles of the three threads used in a React Native app, how they work together, and how JavaScript is handled for a React Native app in debug/dev mode and in prod/release mode.

In Dev / Debug mode

Metro bundler (which runs on top of Node.js) bundles all your JavaScript codes: The ones you wrote, the ones in your app's dependency packages, and the ones that comes with React Native. It bundles them into one big JS file, then spins up a local server on port 8081 to serve the bundled file when requested.

Now when you open your compiled debug app (.apk for Android or .ipa for iOS), it makes a request to the local metro server to fetch the bundled JS file so that the JS interpreter (JavaScriptCore or Hermes which is packaged into your app can begin executing it. But you may ask, what happens to the native codes (Java/Kotlin or Obj-C/Swift) that is also part of the compiled app?

The simple answer is, these native codes cannot be executed by the JS interpreter, so it has to be executed separately but within the same app. That means JS has to be executed separately and native codes also has to be executed separately, but all within the same app because the two has to come together to make your app whole.

Fortunately, Threading allows for such things, they allow you to run multiple sub-programs (threads if you will) within the main program (process). With threading, you can execute two or more programs which can be written in different programming languages concurrently within the same process.

So when your compiled React Native app is launched (as a process), what actually happens is it spins up three threads from within it:

JS thread

This is where the JavaScript interpreter which executes your bundled JavaScript - sent from metro server - lives

Shadow thread

This is where the flexbox-based styles and layout you give to your elements are converted into layout and styles that the native platform (Android or iOS) can understand. This is done by Yoga, a cross-platform layout engine.

Main/UI/Native thread

This is where all the native Java/Kotlin or Obj-C/Swift codes are executed. It is here that native platform APIs (e.g Camera) are accessed from and native platform UI elements (e.g View for Android and UIView for iOS) are rendered. It is from this thread that the other two threads are spawn.

The communication between the three threads mentioned above are facilitated by the React Native Bridge or Turbo Native Modules which is the new approach.

In Prod / Release mode (when you compile for release to app stores)

Everything is the same as in Dev/Debug mode except that the bundled JavaScript file is packaged together with your app (apk or ipa) as an asset when the app is being compiled, rather than being loaded from metro server.

So when you open the compiled app, the JS bundle is just loaded to the JS thread from within the app's assets folder and is executed. That also means there's no need for Metro or Node.js from that point as everything the app needs to work is already precompiled into it.

That's it,

Hope this helped at least a bit ✌

Time Bending Technology: Orchestrating Perfection in a World of Milliseconds

Stanley Ugwu — Tue, 16 May 2023 16:56:59 +0000

Hello 👋🏽 guys, I learnt about real-time systems recently and felt like passing the knowledge on. I Hope you’ll learn too.

Real time computer or systems are systems where tasks and operations are carried out within a guaranteed period of time called deadline. The main keyword there is "guaranteed" because that’s one of the major things that differentiates regular computer systems from real-time systems.

In a regular computer system, time is important but not as critical as in real-time systems. A regular computer system can prioritize tasks based on some other factors apart from time, such as overall system throughput, latency, complexity, user input, etc.

In contrast, on a real-time system, tasks are prioritize based on their deadline (maximum allowed time for execution) and failure of the system to complete a given task within its deadline can have various catastrophic consequences such as overall system failure, system inefficiency, loss of funds, and even loss of lives.

Here are some classic examples of real-time systems:
1. Aircraft control system
2. Automated assembly line
3. Industrial control system

Above examples are all classified under hard real-time systems, which are systems where deadline must be met or catastrophic consequences would occur. On the other hand, there are soft real-time systems which have more flexibility in meeting their real-time constraints and may still function adequately even if some constraints are not met. An example of a soft real-time system is a video streaming application.

To illustrate the criticality of time in hard real-time systems, consider an aircraft control system, timing is critical, and the system must be able to respond quickly and predictably to events. For example, if the plane encounters turbulence, the control system must be able to adjust the control surfaces to keep the plane stable within a very short period. Real-time systems in aircraft control are designed to respond within milliseconds or even microseconds.

Because of this time importance, a real-time system is architected slightly differently with a variety of specialized components (hardware and software) and techniques to ensure that tasks are completed within their deadline.

Some of these components and techniques that enable real-time systems to perform tasks real fast are:

1. Real-time operating system

A real-time operating system (RTOS) is a specialized operating system designed for real-time applications. RTOS provides services optimized for real-time performance, such as real-time scheduling, task management, inter-process communication, and memory management. An example of this is RTLinux.

2. Real-time Scheduling

Real-time scheduling is a technique used to schedule tasks in a real-time system to ensure that they are completed within their specified deadline. Real-time scheduling algorithms prioritize tasks based on their criticality and deadline, ensuring that the most important tasks are completed first.

3. Interrupt Handling

Interrupts are signals that are generated by hardware devices to notify the system of an event. In a real-time system, interrupt handling is crucial to ensure that the system can respond quickly to events. Interrupt handlers are designed to run quickly and efficiently, and they may disable other interrupts during their execution to ensure that the critical task is completed.

4. Preemption

Preemption is a technique used to interrupt a lower-priority task to allow a higher-priority task to execute. In a real-time system, preemption is crucial to ensure that the system can respond quickly to events.

5. Hardware Support

Real-time systems may also use specialized hardware components, such as real-time clocks, timers, and dedicated processors for specific tasks. These hardware components are optimized for real-time performance and can handle tasks with strict timing requirements.

Real-time Programming Languages

Real-time programming languages are programming languages built to be used on real-time systems or to be used in developing apps and programs that run on real-time systems. These programming languages offer some special features to enable developers write predictable and efficient codes that meets the time constraints of the host real-time system.

Some of these features are:

1. Determinism

These languages prioritize predictable and consistent execution of programs which is critical in a real-time environment

2. Low-level access

These languages provide access to the underlying system’s hardware, allowing developers to write codes that interact with the hardwares.

3. Memory management

Real-time programming languages often provide memory management features that allow developers to manage memory more efficiently, reducing the risk of memory leaks and other memory-related issues.

4. Preemption and scheduling

Real-time programming languages also provide features for scheduling and preempting tasks. This allows developers to prioritize tasks, and ensure more critical tasks takes precedence in execution.

Some examples of real-time programming languages are: C/C++, Ada, and VHDL

In summary, regular computer systems can handle tasks in a specific period of time, but they are not optimized for real-time performance. Real-time systems are designed to handle tasks with strict timing constraints and prioritize predictability and responsiveness over throughput.

Programming on a real-time system should be done with much care, attention, and understanding as a single flaw can lead to a big loss. Thanks for reading ✌🏽✌🏽

Deep linking 🔗 in React Native

Stanley Ugwu — Mon, 19 Dec 2022 07:14:10 +0000

Hello Dev 👋 trust you're hacking good. Let's talk about setting up deep linking for react native projects. Grab your laptop and let's grab some knowledge .

So what is deep linking?

Deep linking is a way to move directly to a particular screen in a particular mobile app through URLs.

You know the way you click a link for e.g dev.to/stanleyugwu and it takes you to a particular page within a website, with mobile deep linking, you'll be able to achieve the same result for mobile apps. In short you'll be able to navigate to a particular screen/view of a mobile app by clicking a link.

Without deep linking

The traditional way of getting to where you want in any mobile app without deep linking is to launch the app, and then follow whichever route the app puts you through, till you get to where you want.

Consider below diagram as the UI flow of an example mobile app. Each box represents a screen within the app.

Say you want to edit your profile from the Profile screen, you have to move from Home to Settings then to Profile screen.

With deep linking

With deep linking setup for our example app, we'll be able to move directly to the Profile screen without going through the intermediate screens (Home, Settings).

A common use-case scenario of deep linking is when slack sends you an email with a magic link which you click on and it takes you to slack app if you have it installed. That's deep linking at work there 😎

Benefits of deep links

There are numerous advantages of setting up deep links for your mobile app:

Improves app discoverability
Improves user engagement
Enhances the user experience
Re-Engages users to your app fast
Campaign opportunity (campaign can be run for individual screen)
e.t.c

Configuring deep links

Deep links are regular links, it's just the underlying operating system and the mobile app been deep-linked into that makes them powerful.

Configuring your mobile app to support deep linking is just about informing the operating system that the app can handle certain URLs and/or URL schemes. So that when the user clicks on a URL matching the specifications, your app can take over, and handle the user's request.

A typical URL has different parts or segments as denoted by the image below:

You can configure your app to handle each segment or combination of segments. What that means is you can configure your app to handle URLs with certain scheme, second-level domain, top-level domain, subdirectory, or a combination of them.

In this tutorial, we will be setting up our React Native app to handle the scheme myapp:// so that URLs having myapp:// scheme would be handled by our app.

I think I've said enough 🤐, let's get to work 💻.

1. Create a new React Native app (let's call it deepLinkApp 😉)

npx react-native init deepLinkApp

Move into the app's directory

cd ./deepLinkApp

Click here to learn how to setup your environment for React Native.

2. Configure deep links for android

On Android, deep links works through intents. The Android OS broadcasts an intent when a link is clicked, and apps that can handle the intent and link shows up for user to choose. Now let's tell Android that our app can handle myapp:// scheme.
The easiest way to do this is with the uri-scheme package:

npx uri-scheme add myapp --android

If you want to set it up manually, open up deepLinkApp/android/app/src/main/AndroidManifest.xml, and make the following adjustments:

Set launchMode of MainActivity to singleTask in order to receive intent on existing MainActivity.
Create a new intent-filter inside the MainActivity entry with a VIEW type action

Below is how your .MainActivity activity tag should look like with the intent-filter and launchMode set, so you can just copy and paste it:

...
<activity
    android:name=".MainActivity"
    android:launchMode="singleTask">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="myapp" />
    </intent-filter>
</activity>
...

3. Configure deep links for iOS

Include the following lines in your project's AppDelegate.m file in order to be able to listen to incoming app links:

Copy/paste below code at the top of the file
#import <React/RCTLinkingManager.h>

Copy/paste below code inside @implementation AppDelegate above @end:

- (BOOL)application:(UIApplication *)application
   openURL:(NSURL *)url
   options:(NSDictionary<UIApplicationOpenURLOptionsKey,id> *)options
{
  return [RCTLinkingManager application:application openURL:url options:options];
}

Now let's add the scheme to our iOS project configuration.
The easiest way to do this is again with the uri-scheme package. Run the following command:

npx uri-scheme add myapp --ios

Again, if you want to do it manually, open up the project deepLinkApp/ios/deepLinkApp.xcworkspace in Xcode. Select the project in sidebar and navigate to the info tab. Scroll down to "URL Types" and add one. In the new URL type, set the identifier and the URL scheme to myapp.

This is how it should look in Xcode:

Imge Source: react-navigation

4. Rebuild and install the app

We have made changes on the native side of our app, so you need to rebuild and install the app in your emulator, simulator, or device.

For iOS, run:

npx react-native run-ios

For Android, run:

npx react-native run-android

5. Test out the deep link (the moment of truth 😆)

Now we're going to use our handy uri-scheme command line package to test out the deep link we just set up for both Android and iOS.

For iOS run:

npx uri-scheme open "myapp://any/host/and/path" --ios

For Android run:

npx uri-scheme open "myapp://any/host/and/path" --android

Running above command will launch/start-up our app on the emulator/simulator/device if it's not already running, otherwise nothing really happens. Yes nothing 😎.
The reason is because we didn't specify what happens next after our app is granted permission to handle the deep link.

6. Handle the deep link

We need to handle the deep link on the Javascript side of our app so that we can specify what happens next after our app is launched or foregrounded as a result of running above command, or user clicking on URL with myapp:// scheme. Fortunately, React Native provides us with a Linking module which we can call from JavaScript to handle deep linking easily 😇👌.

There are two ways to handle deep links that open your app:

If the app is already open/launched, the app is foregrounded and a Linking 'url' event is fired
You can handle these events with Linking.addEventListener('url', callback) - it calls callback({ url }) with the URL which was used to open the app.
If the app is not already open/launched, it is opened and the url which was used to open the app is passed in as the initialURL
You can handle these events with Linking.getInitialURL() - it returns a Promise that resolves to the URL, if there is one.

To handle these cases in our app, open up App.js and add the following code to it:

useEffect(() => {
      // handles deep link when app is already open
      Linking.addEventListener('url', evt => {
        console.log(evt.url);
      });

      // handles deep link when app is not already open
      Linking.getInitialURL()
        .then(url => console.log('Initial URL:', url))
        .catch(console.warn);

    return () => {
      // clears listener when component unmounts
      Linking.removeAllListeners('url');
    };
  }, []);

Now lets' run the uri-scheme test command one more time:

For iOS run:

npx uri-scheme open "myapp://any/host/and/path" --ios

For Android run:

npx uri-scheme open "myapp://any/host/and/path" --android

Now you should see your app opened, and "myapp://any/host/and/path" logged to the console. Bravo!! 💃🕺 your deep link setup is working.

Note that we're just logging the URL (which opened our app) to the console, in real apps however, you might need to parse the URL and perform further operations such as navigating the user to the appropriate screen. Luckily if you use react-navigation package for your app navigation, there's an easy way to bind certain deep link URLs to certain screens in your app. You can read more on that here.

Summary

We've just learnt how to setup deep links for our React Native (Android and iOS) app. If you've not been doing this for your apps, you really need to consider it as it comes with so many benefits.

The technicalities involved in setting up deep links are not really that much, the lengthiness of this article can be attributed to the stretch in explanations (I was more concerned with how it worked, sorry 😉).

Phew! 😌 that was a long one 😅. I hope you learnt something?. happy hacking 💻 ✌🖖

NFTs and Crypto tokens in clear terms

Stanley Ugwu — Wed, 27 Jul 2022 13:22:15 +0000

Hello 👋 awesome person, in this post, I'll show you how to make $1,000,000 by mintin....No! this is not yet another NFT-is-the-new-heaven post to tell you how many millions of dollars an NFT was sold, how minting your soul as NFT could make you $$$, or how creating your own ERC20 token (without utility) will make you a boss.

NFTs and crypto tokens generally are quite profitable and the idea, revolutionary. Just that the way it's been portrayed on the internet have made a lot of people tie the whole idea to JUST colorful pictures of apes and kitties, buying low and selling high and a lots of money.

This post is my attempt to give more meanings to fungible tokens and NFTs (Non fungible tokens), I hope it sheds some light on what is possible with these tokens apart from trading and minting them. Let's get into it already...😃

FIRST, WHAT IS AN ASSET

An asset is something that contains value. An asset can exist physically or digitally, E.g money, skills, phone, car, buildings, lands, diamond, photos, audio, PDFs etc.

An asset can benefit you in one way or the other that's why it's valuable. E.g your car can benefit you by serving as means of transportation, so you value it.

FUNGIBLE ASSETS

Fungible means exchangeable.
A fungible asset is an asset that can be exchanged with another asset of the same kind, with no change in value.

A Dollar bill is an example of a fungible asset because it can be exchanged with another dollar bill and still have the same value.

Five $1 dollar bills can be exchanged with one $5 bill and they'll still have the same value and offer the same benefits.

A bottle of Pepsi is a fungible commodity because it can be exchanged with another bottle of Pepsi with no change in value.

NON FUNGIBLE ASSET

Non fungible or non exchangeable assets are assets that cannot be exchanged with another of the same kind without value loss or gain because each of the asset, even though are of the same kind, has unique qualities that add or subtract value.

An example of a non-fungible asset is a land. Even though you have two same-sized lands, they can never have the exact same qualities - one may be tougher or richer in soil than the other so lands are non-fungible.

Another example is a diamond, you cannot have two diamonds that are same in all aspects. They must differ in either shape, size, weight, quality, etc.

Another example is a piece of physical or digital art. Arts are very unique, two pieces of art can never have the same value. So are non fungible assets.

WHAT IS A TOKEN?

A token is a representation of something which can be priced. Put simply, the representation of an asset.

A token and/or what it represents can be physical or digital, tangible or intangible, fungible or non-fungible. For example a tangible dollar bill represents an intangible currency. An intangible "thank you" message on Facebook can represent an intangible appreciation.

For example, when you give someone flower as a token of appreciation, what you intend to give the person is appreciation, but it's intangible so you choose to represent it with a flower (tangible token) which should be valued also. You can represent that appreciation with something else like labor, hug, or treat.

If a token represents an asset which is valuable, the token automatically becomes as valuable as the asset as soon as it can be verified and agreed that it actually represents the actual asset. Take fiat money for example, since it's generally accepted as money, it automatically gains as much value as the currency it represents.

WHAT ABOUT DIGITAL TOKENS?

A digital token is a digital representation of an item. A Digital token exists digitally in any digital format e.g symbol, codes, sound, cryptographic hash, fingerprint, etc but can represent something digital or physical, tangible or intangible, fungible or non-fungible.

That means you can create a digital token to represent a fungible item like an event ticket, or a non-fungible item like a piece of artwork. Yes! they're just representatives.

A digital token can represent anything like skills of a game character, lottery ticket, fiat currency, reputation points, an art, ...name it.

Digitally Tokenizing (creating a digital token to represent) a fungible or non-fungible asset makes the asset easy to be bought, sold, and/or traded.

For example if you tokenize an artwork, it'll be easier, more efficient and secured to buy or sell the artwork online since buying the token automatically grants you ownership of the artwork.

In Ethereum, which is the most popular development blockchain platform, these digital tokens are created as computer codes, and with the help of cryptography and are called smart contracts. The smart contract facilitates the trading and ownership of the asset it represents. E.g. A smart contract which implements/is an NFT, facilitates the trading and ownership of the NFT and thus the asset it represents, all in a secured, trusted, decentralized and transparent way - because of the backing platform Ethereum blockchain.

FUNGIBLE CRYPTO TOKEN

Fungible tokens are tokens which represents fungible assets like event tickets, currencies, subscription plan of an app, etc.

You can create a fungible crypto token on the blockchain to represent anything fungible, but for the token to be valuable, it has to represent something that's valuable as well, like Drake's live event ticket 😉.

Utility has to be given to a crypto token for it to gain value, otherwise people won't want to buy a token that won't benefit them in any way 🤷‍♀️. For example, the SHIB crypto token can be used to buy lands in SHIB metaverse.

NON-FUNGIBLE CRYPTO TOKENS

Non-fungible tokens are crypto tokens which represents non-fungible assets like a pic of you and your cat in Hawaii 😋, audios, PDFs, digital artworks, real estate, physical artworks, physical lands, lands in the metaverse, etc.

Because NFTs represent non-fungible items which are unique, they're also unique across the blockchain. So for example if you buy an NFT of a digital art, the ownership of the digital art is automatically transferred to you, and the token which you bought is uniquely identifiable across the blockchain. Then with ownership of the token, you can claim ownership of the underlying asset - the digital art.

As an example, With the power of NFTs, Next Earth is building a platform for users to purchase, develop, and sell virtual land mapped onto the Earth 😃.

Summary

I crafted this post as a note while learning about NFTs and ERC20 tokens. Again it's my attempt to shed more light on crypto tokens, NFTs, and their possibilities for anyone who might be confused by the hype, complexity, and/or big grammars.

As usual, this post is open for discussions and correction. Thanks for stopping by ✌✌

This is all you'll need to develop web3 apps (dApps)

Stanley Ugwu — Sat, 19 Feb 2022 00:12:50 +0000

If you've been following the tech trends recently, you may now be just getting used to seeing and hearing these words - NFTs, blockchain, web3, cyberpunk, smart contracts, decentralisation, solidity, (add your own word).

Posts housing these terms have been thrown all over the web, I even bet some people would be mentioning NFTs in their morning prayers 😅😄.

However, there's still one term missing from the list that's now common especially among developers, the almighty "dapp" or "decentralised app".

In this post I'll try to explain what it is and the technologies you'll need when developing one.

What is WEB 3.0

Web 3.0 is an idea for a new iteration of the world wide web based on blockchain technology.

It's an idea for a new way of information communication on the web based on blockchain.

Web3 App (dApp)

A web3 app or dapp(decentralised app) for short, is a software in the form of websites, desktop apps, mobile apps, etc that has its backend code running on a blockchain network.

A web3 app has a backend that's deployed on a blockchain network from where it serves the frontend which can be written with any programming languge and deployed anywhere.

Web3 Developer stack

A developer stack is a bag of technologies that a developer possesses. An example is MERN Stack which is short for MongoDB, Express, React, and Node.

Similarly, web3 developer stack is a bag of web3 technologies that a web3 developer possesses. They are tools and technologies essential for web3 app development.

The tech stack of a web3 developer are:

Web3 libraries
Smart contracts
Nodes or Web3 providers
Wallet

1. Web3 libraries

Web3 libraries are packages that we would usually use on our frontend which helps us interact with our backend which is running on a blockchain network, through a node (computer) on the blockchain network.

Web3 libraries are like regular web2 libraries like axios, react, graphql, etc; They are basically installed and used on the frontend side of our apps much like other libraries, except that web3 libraries help us interact with our backend servers which are made up of smart contracts deployed on blockchain network(s).

Web3 libraries simply creates an interface between our frontend app hosted on a cloud service like aws, and our backend smart contracts hosted on a blockchain network like Ethereum blockchain network.

Through this interface we can execute our contracts and make transactions on the blockchain network.

Note: The frontend of our apps or dApps can also be hosted on a blockchain network.

2. Smart contracts

Smart contracts are pieces of codes or programs that reside on a blockchain network. They are like functions hosted and executed (on-call), on the blockchain.

Smart contracts can be thought of as open APIs; they are public on the blockchain and as such can be invoked from anywhere e.g from terminals, web apps, web browser consoles, mobile apps, desktop apps, even from other smart contracts on the same blockchain network; with the help of web3 libraries.

Blockchain networks have specified programming languages which it's smart contracts should be written in.

For example, if you want to write smart contracts that will run on Ethereum blockchain network, you have to write it in a programming language called Solidity.

Other blockchain networks have their own required programming languages and there are tools that will help you create and deploy the contracts from within one place e.g Remix for Ethereum blockchain.

3. Nodes/Web3 Providers

Smart contracts on blockchain networks are decentralised, which means every computer connected to the blockchain network as a participant, has a copy of every smart contract deployed on the blockchain.

The computers on a blockchain network are also called "nodes" or "web3 providers", and it's in one of these nodes that the smart contract youdeploy to a blockchain network wll be executed when invoked.

Without a node there won't be any blockchain because the nodes are the participants that form the blockchain network. Because of this, the only criteria for invoking a smart contract is that you must be connected to one of these nodes that houses and can execute it.

You must connect to a node on a blockchain to be able to execute a smart contract deployed on that blockchain network.

This connection is what web3 libraries help you to setup and without access to a node, it can't really do anything.

4. Digital Wallet

Each transaction run on a blockchain is run by the nodes on the network, some examples of transactions are: Transferring 1 Ethereum crypto currency from Bob to Alice, deploying your smart contract to the network, invoking your smart contract, etc.

Each of these transactions takes computing power from the node that it will be run in, therefore you have to pay a fee to that node; these are called "gas fees", and they are basically paid in native cryptocurrencies of the blockchain e.g ETH for Ethereum blockchain.

Note: For deploying contracts, the deployer has to pay. For executing contracts the user of the contract usually pays and the fee goes to the miner(node) that runs the transaction.

A Digital wallet is much like a physical wallet used to store currencies, except that digital blockchain wallets are used to store cryptocurrencies instead of fiat currencies like dollars, etc.

You will need a wallet for developing web3 apps because it is what will facilitate payments for the fees you have to pay for your transactions that will be run on the blockchain. Some example of crypto currency wallets are Metamask, Coinbase, etc.

That's all 🤷🤷...

So that's it folks!!. Those are pretty much the technologies and tools you'll be needing when developing a dapp.

Thanks for reading 🥕🥕... See you on the other side of the web 😅😅

Web 3.0 & blockchain - how they work together

Stanley Ugwu — Wed, 16 Feb 2022 15:34:57 +0000

Hello guys! In this post we'll be looking into the web and internet, the problems of the current web, blockchains, web3, and how web3 and blockchains works together.

Let's dive in!!.

What is internet

Internet is a decentralised network of computers interconnected together for different purposes.

This purposes are defined by what we - the users of internet, use it for; example communication, providing services, watching videos, playing games, etc.

Then what is Web/World Wide Web/W3

The World Wide Web or Web or W3 was invented by Sir Tim Berners-Lee in 1989 as a system of information communication built on top of the internet, where information is communicated through webpages made of HTML(Hypertext Markup Language) and other web resources like images, documents, all delivered by a web server and rendered by the web browser, and interlink to one another via hyperlinks.

The Web is just one way of information communication that relies on the internet. Email is another way in which information meant for a specific user - identified by an email address, is sent to an email server which then relays the information to the identified user's email client.

The internet and the web from their origins has been decentralised in nature.

No one one entity controlled most of it. Anonymity and privacy was built into its nature, users would dial up to a specific server to get or share information and that's all - no data tracking, no data privacy violation, no data black markets.

But as the web and internet evolved, innovations and improvements came in, some companies dominated the web space, and so did issues and problems. Let's talk about the problems a bit - Centralisation

Centralisation in itself is not a problems as it has its advantages. But it turns out the disadvantages are more critical.

Because a handful of companies now own larger portions of the services that run on the internet, they have more control.

Google for example has services that run on the internet and with very large user and data base, think Gmail, Google cloud, Google Search Engine, etc.

Same is true for other companies like Facebook, think WhatsApp, Instagram,

They've dominated almost the entire space and it's now almost impossible to compete with them as they consistently buy out or copy features of other growing services which means more control and data.

So what happens is that they're in control of most of the data people put out on the web and internet at large and as such, centralisation and it's disadvantages have come in picture.

The following problems have emerged.

They decide what to do with your data.
They do what they like on the space as nothing can stop them.
They control what you can do on the internet since they're the providers of most of the services you use.
They experience outages and downtimes in which case there's almost nothing else you can do except wait.
As all the data is stored in one place, attacks are attracted, so your data may end up in the wrong hands.
You can't really compete with them on the space as they have the resources to buy you out or copy you when you walk in their steps.
Because they run a centralised architecture, when they experience outages or server failures, all the websites and softwares that depends on their services stops working.

The Solution

With all the above problems, the solution to most of it would be to decentralise the Web we have now, and that's what Web 3.0 or web3 has come to do and in a moment, we'll understand how.

Based on the history of internet and how the Web has being used, the Web can be split into two generations or eras.

Web 1.0
This is the era of the beginning of internet, when the web mostly consisted of static webpages that the user just read information from. No interaction. Only the website owners created information and the web was decentralised at this time. It's also called reading era.
Web 2.0
This is the era we are in now. The era where interactivity has being incorporated into the web. Now users can read and as well as create contents on the web. It's the social interaction era. It's also called reading and writing era. It's in this era that all the above problems have emerged because of centralisation by the big players.

And now the third era Web 3.0 has kicked off.
This is a new era of the web. This era is supposed to deliver the web from the shackles of the disadvantages of centralisation and solve alot of the problems web 2.0 is facing currently like ones mentioned above.

Web 3.0 is an idea for a new iteration of the web based on blockchain technology.

Because of how blockchain works, it'll be the backbone of web3; let's see how.

So what is Blockchain

Blockchain is a network of peer-2-peer connected computers aka nodes, where each node maintains and updates a copy of a distributed ledger or record which is synced across the network.

Blockchain is much like every other network that forms the internet, except that in this network, they share a record of data among the computers (nodes) on the network, and each node can update the record.

When the record is updated by a node, the updated record is then shared across the other nodes; which means at each point, all the nodes has to have an up-to-date version of the record.

Blockchain network is said to be decentralised because there's no central control of the network. If one node goes down, the other nodes will still be active. And other nodes can freely join the network.

The record or ledger shared on the blockchain is also decentralised because there's no single source of truth. All the nodes are sources of truths. Each node has up-to-date version of the record.

It's because of the decentralised nature of blockchain along with the features that decentralisation brings like transparency and security, that Web 3.0 would be based on it.

There's more...

Adding to the decentralisation of blockchains, some blockchains also allow for running codes on the network.

They allow computer codes to be added to the network's record, and those codes would be executed, on-call, inside one computer(node) on the network.

These codes are called smart contracts and amazingly, these smart contracts can read/write data to the shared record/ledger on that network. These are what makes web3 amazing.

In web3, things still look same as in web2; web browsers would still be used to access apps on the web3, apps can still have backend and frontends, webpages will still be made up of HTML, you can still use regular frontend libraries and frameworks.

But in web3 though, apps are now called dApps(decentralised apps), and their backend codes would be smart contracts which will run on the blockchain. This is why they're called dApps.

Summary

The fact that dApps have their backend codes running on a decentralised network (blockchain) paves the way for new ideas, opportunities, and innovations.

Your dApp can leverage on that feat and shock the world....

Thanks for reading and your corrections are welcomed...😃😃

"Blockchain Developer", What does it mean?

Stanley Ugwu — Wed, 09 Feb 2022 17:08:00 +0000

Hi Guys! 👋, Today I will be attempting to give a straight-to-point explanation about Blockchain, Blockchain Developers and the types of developers in the blockchain space.

Let's jump in!! 😉

WHAT IS BLOCKCHAIN

Blockchain is a distributed database existing on multiple connected computers at the same time.

Blockchain is an example of Distributed Ledger Technology (DLT), blockchain network is a network of peer-to-peer connected computers
called nodes, and these nodes each have a record of the transactions that has being carried out in the chain. sort of like a database. (that's what makes it decentralized, each node has up-to-date records)

APPLICATIONS OF BLOCKCHAIN

Cryptocurrencies, NFTs, and other buzz trends are all applications of blockchain technology. They're all possible
because of how Blockchain works and it's decentralized nature. The nature of Blockchain has made way for so many
applications and NFTs, Cryptocurrencies, are just few of the applications.

These application is just a matter of writing
programs that will run on the chain, and then that program will leverage the features of the blockchain (think decentralization),
and do mind blowing things. You can build a simple todo-app that runs on the blockchain, that way you don't need a database
to store the data as you have access to the blockchain which you can use as storage.

BLOCKCHAIN CLIENT

Blockchain Client is what makes it possible for the nodes in a blockchain to be connected to each other.

It is a software that runs on each of the nodes and is responsible for verifying and relaying the transactions and blocks
to other nodes across the chain (network). Parity Ethereum and Geth are two examples of Blockchain clients for Ethereum
blockchain.

TYPES OF BLOCKCHAIN DEVELOPERS

There are two main types of developers in blockchain development:

Core Developer
App/dApp Developer

1. Core Developers
Core Developers are the developers that does core development on the blockchain.
They write codes for the Blockchain Client Software using low-level programming languages like C, C++, Rust, etc.

Blockchain core development is not an easy task as you need to understand system architecture and low-level programming
languages. Blockchain core developers are very rare and prefer to stay anonymous.

2. App or dApp Developers
App or dApp(decentralized application) Development is what most blockchain developers do and what is commonly meant when
"Blockchain Developer" is mentioned. It can also be called dApp development because of the fact that the app you deploy to a
blockchain exists on all the nodes on the chain.

Just like Web developers write codes that'll be executed in the web browser, Blockchain
App Developers write codes that'll be executed in a Virtual Machine environment, and these VMs are created by the Blockchain
Clients which reside in the nodes on the chain. With that for a fact, your app can read/write data from/to the blockchain.

Wanting to be a blockchain developer is one thing, the second important thing is choosing a blockchain network to develop on.
There are some important factors to consider such as Transaction fees, Privacy, scalability, etc.

That's it guys!, I hope you got an idea of what blockchain and blockchain development is about. Good-luck on your journey to hacking in the blockchain space and I'll be making a future post on things to consider when choosing a blockchain network to develop on.

Your appreciation and corrections are highly welcomed. Thanks for reading 🥕🥕.

Write javascript conditionals like a pro with Truthy and Falsy values.

Stanley Ugwu — Wed, 29 Sep 2021 22:14:37 +0000

Hi dev 😉, in this post I'll show you how to cut the length of your conditional statements by leveraging the power of javascript truthy and falsy values. Let's get this broken.

Before discussing truthy and falsy values, let's dig in a bit on how javascript handles conditional statements.

In javascript, the condition passed to any conditional statement is first coerced (transformed) to it's Boolean context.

It's based on the result of this coercion/transformation that javascript knows if it should execute the statement's body or skip it.

Take for example.

if(1+1 == 2){
  console.log('passed');
}else{
  console.log('failed');

when javascript encounters that conditional statement above, it first evaluates 1+1 == 2 and the result of that evaluation can only be true or false because 1+1 (which will result to 2) can only be equal to 2 (true), or not (false).

The result of that evaluation is what determines whether javascript would execute console.log('passed')
or console.log('failed').

And in our case it will end up logging "passed" to the console because the result of that evaluation will be true (1+1 is 2).

That is how javascript and pretty much other languages work. Just know that anything passed into the condition block of a statement will be coerced to true or false by evaluating it. And here comes the interesting part, i said anything and I mean anything. Any valid expression.

You can pass in function calls, and the return value of that function will be coerced.

if(getName()){
  // do something
}

You can pass in reference to variables, and the referred value will be coerced.

if(localStorage.todos){
  // do something
}

Now you may be wondering how data types like strings, arrays, objects, will be coerced. Now let's see how javascript decides what is true or false.

Truthy and Falsy Values

A truthy value is a value that is considered true when encountered in a Boolean context.

A falsy value is a value that is considered false when encountered in a Boolean context.

1. Falsy values

false, 0, -0, 0n, "", null, undefined,
and NaN).

2. Truthy values

Every other thing not listed above is considered truthy. e.g [], {a:1}, 1, etc.

The beauty of this is that javascript would evaluate your expression before determining if it's Truthy or Falsy. So you can do something like

if([]){...}
if(null){...}
if({a:1}){...}

So that gives you a powerful shorthand to checking conditions.
if(3 > 2 == true) can be shortened to if(3>2).

Here's a quick flow of how the execution will be performed for if(3 > 2 == true)

From:

if(3 > 2 == true)

To:

if(true == true)

To:

if(true)

Summary

having this knowledge gives you the power to write conditionals like a pro, it reduces your lines of codes and makes execution faster.

I hope you learnt something, I would love to know your thoughts on this. Happy coding 💻.

I Broke into Dev.to, and you should too.

Stanley Ugwu — Tue, 28 Sep 2021 21:13:53 +0000

Hi 👋, am glad you're here. This is my first post and am glad am making it. You might be here to know exactly what I mean by "broke into Dev.to", and that you'll know in a bit.

This is my first post on dev.to but not my first blog post generally. I've written in some few blog platforms but i haven't been consistent in any.

I would say part of the reason for the inconsistency in writing/blogging is due to the consistent hassles and struggles i/we face as a developer.

I've learnt this and that, and there's still lot of things to learn; that new technology, this new trend, the new way to do that old thing, that new javascript framework/library, there's no time and (add your own worries).

Along the line of these are what runs through the minds of so many developers, including myself.

While those statements are true, and you need to keep learning, there's one thing you should start doing (if you haven't) that'll help your career and others' in a big way. Start Writing/Blogging.

It may not be easy, but it's something that'll yield benefits to you,your future career, and others.

Yes i know you want to be a better developer.
You want to network, you want to engage yourself in the community, you want to follow discussions, you want to contribute to open source, you have to be well...a developer 🤷.

One way of actually getting engaged (i believe) is to start blogging your developer journey.

With that said, one of the challenges of maintaining a blog is actually knowing what to write about, and here's what i have to tell you. Write whatever you feel is/will be useful to someone, and don't over-think it. Grab a notepad and start writing.

Did you just understand that concept? Tell others who may have not. Did you just realize a better way to go about that stuff? Tell the world. Did you finally fix that tough bug that left you hitting your head on the wall? Tell others how you did it (you might be saving someone's head 😆).

Thanks to development, now you don't need to start building your own full-fledged blogging site to express yourself. Just hop on to Dev.to or any blogging platform of choice and let it go.

Summary

This post is actually a letter to myself (advising myself as I wrote 🙈), but i feel it would be useful to someone else, somewhere.

Even if you don't find blogging any useful to yourself as a developer, write for your future sons and daughters 🙂 and other persons whose day will be saved by your little sentences. Happy coding..🤟

happytobeindevto
gladtoengage
firstpost
grace