DEV Community: 𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤

Guide to Compiling C++: Making Your Code Run!

𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤 — Wed, 07 Feb 2024 16:17:57 +0000

Welcome. Let’s demystify compiling without making it a whole thing. If you can run a couple terminal commands, you can compile C++.

What compiling is

Your C++ file is readable to you. Your computer wants machine code. Compiling is the translation step that turns your .cpp into something your OS can execute.

In practice, this is you telling a compiler:
“Take these source files and give me a runnable program.”

The compiler you will actually use: `g++`

g++ is the common C++ compiler command on Linux and macOS (and on Windows if you are using something like MinGW or WSL).

General shape:

g++ [flags] [source files] -o [output_name]

Flags you will see a lot

-Wall
Show helpful warnings. Use it. Future you will thank you.
-O2
Optimizes the build (faster program, sometimes slower compile).
-std=c++20 (or c++17)
Picks the C++ language standard.

Example:

g++ -Wall -O2 -std=c++20 main.cpp -o app

Output names, because this trips everyone once

The -o flag sets the name of the program you are creating.

g++ main.cpp -o app

app is now your executable.
Run it like this:

./app

Quick correction on file extensions

If you do not use -o, g++ does not create a .o file by default. It creates an executable named a.out:

g++ main.cpp
./a.out

A .o file is an object file, and you usually only get those when you compile with -c:

g++ -c main.cpp -o main.o

That is useful for multi file projects, but you can ignore it for your first few builds.

A step by step example

Go to the folder with your code:

cd directory_name

Compile:

g++ -Wall -std=c++20 filename.cpp -o filename

Run:

./filename

Compiling with tests (GoogleTest)

If you are linking GoogleTest manually, a simple pattern looks like this:

g++ -Wall -std=c++20 main.cpp tests.cpp gtest_main.a -pthread -o tests

Notes:

-pthread is commonly needed for GoogleTest.
gtest_main.a provides a default main() for running tests.
Depending on your setup, you might link -lgtest -lgtest_main instead of using a .a file. It varies by install method.

Wrap

Compiling is just turning your code into something runnable. The terminal commands look scary exactly one time, then they are just part of your muscle memory.

If you want, paste the exact command you are using and the error you get. I can translate it into plain English and tell you the one line fix.

For more tutorials, visit https://nessakodo.com

Love,
NESSA KODO

GitHub Pages: A Beginner's Guide to Deploying Your Website on a Custom Domain

𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤 — Wed, 19 Jul 2023 14:14:43 +0000

This is the practical flow: publish your site on GitHub Pages, point your domain at it, then connect the domain inside GitHub.

If you are using Hostinger, the DNS screens will look a little different, but the idea stays the same.

Step 0: Decide what kind of Pages site you are deploying

You are basically choosing one of these:

Project site
URL starts as https://username.github.io/repo-name
User site
Repo is named username.github.io
URL is https://username.github.io (no repo name in the URL)

Either option can use a custom domain. User site just looks cleaner by default.

Step 1: Publish using a `gh-pages` branch (only if you want branch based deploy)

You only need this if you are deploying from a branch (common for simple static sites, or when a tool outputs to a branch).

git checkout --orphan gh-pages
git reset --hard
git commit --allow-empty -m "Initialize gh-pages"
git push origin gh-pages
git checkout main

Quick note: this creates an empty branch. You still need to actually put your built site files onto gh-pages (or configure your deploy tool to publish there).

If you are using GitHub Actions to build and deploy, you might skip the manual branch setup entirely.

Step 2: Turn on GitHub Pages in your repo

In your GitHub repo:

Settings → Pages

Then choose your source:

Deploy from a branch → select gh-pages and / (root) or
GitHub Actions if your framework uses a build step (React, Vite, Next static export, etc.)

Once it is enabled, GitHub will show your Pages URL.

Step 3: DNS setup in Hostinger (the part everyone overthinks)

Open Hostinger:

Domains → your domain → DNS / DNS Zone Editor

Before adding new records, remove any old ones that conflict:

Old A records pointing the root domain (@) somewhere else
Any existing CNAME for www that points somewhere else

What records you actually want

A records for the root domain (apex)

These point yourdomain.com (the @ host) to GitHub Pages:

Add four A records:

Name: @ → 185.199.108.153
Name: @ → 185.199.109.153
Name: @ → 185.199.110.153
Name: @ → 185.199.111.153

CNAME record for `www`

This points www.yourdomain.com to your GitHub Pages host:

Type: CNAME
Name: www
Points to: YOUR_GITHUB_USERNAME.github.io

That is it.

One important detail: a standard DNS setup does not use a CNAME for the root domain (@). Some providers support ALIAS or ANAME, but Hostinger typically expects the A records above for the apex.

Step 4: Connect the custom domain inside GitHub

Back in your GitHub repo:

Settings → Pages → Custom domain

Enter:

yourdomain.com

Save, then enable Enforce HTTPS once it becomes available.

GitHub will create or update a CNAME file in your published site automatically.

If you are using a framework build (React, Vite, etc.)

You usually need to make sure the CNAME makes it into the deployed output.

Depending on your setup, one of these is correct:

Option A: `public/CNAME` (common for React)

Create a file:

public/CNAME

Contents:

yourdomain.com

Option B: `docs/CNAME` (only if you deploy from `/docs`)

Only do this if you specifically configured Pages to deploy from the docs folder.

Troubleshooting checklist

DNS changes are not showing up

DNS can take a while to propagate. If GitHub says it cannot verify, it is usually just time.

`www` works but the root domain does not

That means your www CNAME is fine, but your @ A records are missing or wrong.

HTTPS will not enable

Usually this is because the DNS is not stable yet, or you still have conflicting records. Recheck that:

@ has four A records to GitHub IPs
www has one CNAME to username.github.io
No extra conflicting A or CNAME records are hanging around

React app loads but routing breaks on refresh

That is not DNS, it is client side routing. You will need a SPA redirect strategy (commonly a 404.html that redirects to index.html) if you are using React Router.

Wrap

Once DNS is set and GitHub verifies the domain, your site should be live at:

https://yourdomain.com

If you want, tell me which stack you are deploying (plain HTML, React, Vite, Next export) and whether you are deploying from a branch or Actions, and I will tighten this into the exact steps for your repo with zero extra noise.

Love,
NESSA KODO

Growing, Evolving, Developing.

𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤 — Thu, 17 Nov 2022 23:25:15 +0000

I never would’ve thought that upon dropping out of college, I would ever find myself in the position of taking up a 15 week software engineering, Boot Camp, but to my surprise, it turned out to be an experience that has truly shaped so much of my world. Since my early high school years, I’ve had this inclination to learn how to code, and I’ve never properly attended to until recently weeks.

As I continue to navigate through my experience of identifying what career path I want to take seriously as a recent college dropout, I am very grateful that I took this leap of faith towards some thing that is now coming to a close. The were many things that brought me to the point of realizing it was fine time for me to act upon this inclination, but a few months ago I was awakened to the idea of education in the a restructured context.

As much as I wish, I would’ve finished out my degree sometimes, I very much understand why the sort of schools can be so helpful for individuals like myself, who may not always have the mental expenditure to grasp a large scope of course materials the likely never touch once they graduate. I had no idea what to expect, and, for some reason was very lucky to have made my choice at the very time that I did, because not only did I finally find some thing I could easily spend all of my hours doing, but

I also found a community of individuals who will always hold a very special place in my heart. there is something beautiful about what brought us all together, perhaps it was boredom, or maybe dissatisfaction with where we were, and a drive to explore some thing that might enable us to enter a career path that might allow us a sort of freedom, both financially, and intellectually.

I can’t speak so much for everyone else in my cohort, but I most definitely can say the individuals I had the pleasure of learning software engineering with our extremely driven people with many of the same ambitions I have. moving forward from this point in time in which my time in Boot Camp is now done, a scary next step is marked in front of me, one which I’m not sure exactly how I will strive towards.

Regardless of the state of the tech space both now, and in the near future, I know that engineering of all kinds will be an extremely valuable asset, and now that I can understand how many of the websites and interfaces we all interact with on a day-to-day basis or structured, I have a much deeper understanding and appreciation for the many developers, who work so hard to build and maintain the fundamentals of our Internet world.

I think what I find most amusing about my undertaking of this schooling is, perhaps the idea that my initial intention was actually to study cyber security. I know in time I will likely come around to this as now that I have some of the primary development fundamentals locked down it should be much easier for me to get to know other code, bases and languages, but there will always be a part of me that might just love software engineering most of all.

Now I’m not sure whether this is because I can build a full stack application myself and the money ideas for future projects are always popping into my head, or because my experience in an in person, Boot Camp was so comforting to me following a time, where I wasn’t sure what my next move was going to be, And given the circumstances of recent years, I didn’t see many people and wasn’t very inspired to expand my Netwerk or to try to crouch in spaces in which I don’t belong. Some thing I have most definitely understood about the development community is how wonderful it is to be in the presence of individuals who have such a wide span of interests, yet still, there is a common thread, and a desire to constantly learn and evolve within every one of them. This could be taken into many different contexts, as I’m sure you could imagine, and I think it’s incredible that the different skill sets and knowledge we all have outside of coding only enable us to build more imaginatively.

The my 15 weeks in a software engineering boot camp likely will not set me up for success right off of the bat without any further investment of my time or expansion of my knowledge, it has most definitely open my eyes up to the idea of taking risks and venturing into the unknown with hopes that it might facilitate some further understanding of oneself or furthermore, the greater context of life overall. I wrote a blog post when I first started Boot Camp about my observation of life through code, and now that I’m at the end of those 15 weeks, those understandings have only become even more realized.

No I am still a baby dev and have quite a long road ahead of me, I’m grateful that I can at least understand my limitations, as well as areas where there lies great room for improvement. One of my biggest ambitions with making development a primary focus for myself, is to hopefully reach a point in time where I can do what I love as a job, as well as maybe even do it outside of a traditional work environment. I was introduced to many developers in my initial on boarding into the Web3 space, and found this sentiment to be shared among many of them.

Though I know my journey is my own, and there’s no guarantee how it will pan out, I am very excited to take the next steps in advancing my understanding of what I have just learned, as well as continuing to take the very skill of learning, how to learn into every other context of my life. what I have learned most of all is that there is no one way to approach a situation to the point of resolve, and for many of us, finding our own groove as we learn through failure might just be the best way to get there anyway.

In synopsis, I couldn’t be more grateful for my time in Boot Camp, and will forever look back at the last 15 weeks I was one of the most transformational periods of my 21 years thus far, and I will further more carry everything that I have learned into the greater scope of my life, overall as it continues to unfold.

Thank you for reading this, in whatever way you found it, and in whatever form it might have been a value to you, peace out I am grateful for this community of developers and wonderful individuals who consistently and continuously make great efforts to help one another understand many of the difficulties we all face in our pursuits to build an evolve as developers.

I hope that in some way, this has sparked a flame within you to consider a new perspective, and I appreciate you taking the time to take a step within my mind. If you have any questions, or would like to be in touch, feel free to message me, or comment below.

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

NESSA KODO

Ruby && Web 3.0 -- Gems

𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤 — Tue, 11 Oct 2022 20:29:33 +0000

If you've ever played Mario Kart, then you know how awesome those magic rainbow item boxes are, and what an absolute GAME CHANGER they can be...

giving you powers and tools to help you succeed ✨

In a similar way, Ruby gems serve as seemingly magic packages of code that have tremendous capabilities, and a vast number use cases, all of which can help you create full scale applications much more efficiently, and effectively.

Within the last few weeks, I've spent a lot of time learning how to build out functional backend databases using Ruby in conjunction with Sinatra, a gem which serves as a domain specific language (DSL) that helps build out applications with minimal effort. I've newly shifted to utilizing the Rails gem, which is a full-stack framework that has greatly simplified the process of building out databases and their corresponding frontend features, especially as they come to scale.

Following the rise and evolution of both Web 1.0 and 2.0...

"Web 3.0" exposes us to a new generation of web applications that are fueled by user ownership and decentralization.

The fundamentals of what Web 3 is built upon extends past the scope of this post, but I've created a brief overview of the generalized idea here.

My recent exploration of Ruby as a language, and the frameworks that it can run on, have sparked my curiosity to discover what applications it might have within the Web 3 space. Though there is yet a plethora of use cases to be identified as well as resources for developers to both create and utilize, I have found some gems that serve to enable interaction with the blockchain, and personal wallets.

Web 3.0 Concepts 💱

It's crucial to realize that servers are no longer used to host web services and components, as web apps today can render content from consensus protocols like Ethereum, or decentralized storage systems like IPFS.

Notably, integrating such components into web applications can be done in a variety of ways. However, as a web browser is the most popular method of accessing the internet...

the majority of Web 3 material is most easily accessible through browser extensions.

For instance, IPFS Companion is an addon that enables access to IPFS-hosted data through local or remote nodes. Additionally, there are add-ons like MetaMask for blockchains like Ethereum, which allow you to create a wallet from which you can transfer and purchase digital assets and currencies.

The ability for users to manage their Ethereum accounts as well as the many methods of accessing blockchain states are just a few of the advantages that an Ethereum extension provides.

There are a number of individuals who have taken the initiative to create libraries and frameworks for other developers to more effectively build and scale decentralized applications.

In regards to Ruby and Ruby on Rails, the remainder of this post will highlight a couple of gems I've found intriguing, and I plan on writing more about my own experiences using these gems and working through their documentation further in the near future.

Gems 💎

While serving a similar function, the gems listed below are Ruby gems from which a user can create, sign, broadcast, and connect with Ethereum transactions.

Web3 RPC client for Ethereum

This Ruby Gem is used to connect and communicate with Ethereum node ( geth, parity, etc), having RPC interface. RPC(Remote Procedure Call) is a set of protocols and interfaces that the client interacts with blockchain system.

gem install web3-eth

Connecting to local node ( or by SSH Tunnel )

web3 = Web3::Eth::Rpc.new

If you need to connect to remote host, you can specify host, port and HTTP connection options:

web3 = Web3::Eth::Rpc.new 'node.host.com', 8545, { use_ssl: true, read_timeout: 120 }

Calling eth interface:

>> web3.eth.blockNumber
4376369

>> web3.eth.getBalance '0x829BD824B016326A401d083B33D092293333A830'
3916.6597314456685

>> block = web3.eth.getBlockByNumber 4376369
#<Web3::Eth::Block:0x007f844d6f1138 @block_data={"author"=>"0x829bd824b016326a401d083b33d092293333a830", ...

>> block.timestamp_time
2017-10-17 12:51:36 +0300

>> block.transactions.count
129

>> block.transactions[0].from
"0xb2930b35844a230f00e51431acae96fe543a0347"

>> block.transactions[0].value_eth
0.51896811

Ethereum For Ruby

A straightforward library to build, sign, and broadcast Ethereum transactions. It allows the separation of key and node management. Sign transactions and handle keys anywhere you can run Ruby and broadcast transactions through any local or remote node. Sign messages and recover signatures for authentication.

gem install eth

Build a transaction from scratch:

tx = Eth::Tx.new({
  data: hex_data,
  gas_limit: 21_000,
  gas_price: 3_141_592,
  nonce: 1,
  to: key2.address,
  value: 1_000_000_000_000,
})```



Or decode an encoded raw transaction:



```rb
tx = Eth::Tx.decode hex

Then sign the transaction:

tx.sign key

Get the raw transaction with tx.hex, and broadcast it through any Ethereum node. Or, just get the TXID with tx.hash.

These are just a couple of gems out there that enable the division of key management from node management.

Anywhere Ruby can be executed and transactions can be disseminated across any local or remote node, you can sign transactions and manage keys.

If you're curious, documentation for the original gem can be found here.

Applications 📱

The following is a tutorial utilizing the "eth" Ruby gem from QuickNode.

Installing the Eth Gem

Before installing the gem, let us first ensure that Ruby is installed. Simply open a terminal and run:

ruby -v

If this returns a version later than 2.6, you're all set! If the command is not recognized, then you will need to install Ruby. If it is and the version is older than 2.6, you will need to use a newer one.

Once you're ready to move on, we can install the eth gem. This gem will allow us to connect to the Ethereum blockchain network using the Ruby language.

We can install it from the command line

gem install eth

Getting Started with QuickNode

To build on Ethereum, you'll need an API endpoint to talk to on their network. If you'd like to deploy, host, and manage your own infrastructure, you can skip this section.

Otherwise, QuickNode.com. offers a free 7 day trial!

Create an Endpoint

Once you’ve signed up, create an endpoint running on the Ethereum network. Then, navigate to the "Get Started" tab and copy the HTTP Provider link:

This will be used to help us connect to the Ethereum network.

Putting It All Together

Now, we'll use the eth gem along with our QuickNode endpoint to create a short script to fetch the latest block number using our node.

Create a new file, script.rb, through your Terminal or directly in your file system. If you choose to use a Terminal, you can use this command:

echo > script.rb

Open script.rb in a code editor of choice and add the following code:

require 'eth'
client = Eth::Client.create 'YOUR_ETHEREUM_NODE_URL'
block_number = client.eth_block_number
puts block_number["result"].to_i(16)

Replace the YOUR_ETHEREUM_NODE_URL with the HTTP provider from the instructions above.

Let us break down the code:

Line 1: We are importing the eth gem we installed earlier.
Line 3: We are creating a new Ethereum RPC client, passing in our Ethereum node URL. Visit the official eth.rb Github repo for more information.
Line 4: We are getting the latest Ethereum block number using the eth_block_number method and storing it in block_number.
Line 5: We are printing the block number. Note that the returned result is in hexadecimal format, thus we use the to_i(16) function to convert it into an integer, base 16.

Run the Script

Execute the script by running the following in your Terminal:

ruby script.rb

After running this command, you will see the latest Ethereum block number returned on the following line. That’s it! We've successfully connected to the Ethereum network using Ruby.

This is just one application of the "eth" gem, and upon utilizing more of its features, there are a seemingly infinite number of ways we could put these capabilities to use.

Conclusion 🔑

Web 3 offers up a plethora of new opportunities for individuals from all circles of life, and with ever evolving and incoming resources for developers to explore, the possibilities are endless.

Though this post was primarily focused on interacting with the Ethereum blockchain, the examples which I've covered are merely that--

examples from which I hope anyone reading this might be inspired by the extended use cases of smart contracts, and blockchain technology.

I hope that in some way, this has sparked a flame within you to consider a new perspective, and I appreciate you taking the time to take a step within my mind. If you have any questions, or would like to be in touch, feel free to message me, or comment below.

Instagram Twitter Discord

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

NESSA KODO

The Heart of Web 3.0

𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤 — Mon, 19 Sep 2022 06:36:03 +0000

Decentralizing the internet is at the heart of Web 3.

As new technologies and systems continue to rapidly emerge, it is essential to understand why decentralization is so important.

The cornerstones of Web 3 are built on ideas of user ownership, and transparency. The goal of establishing this new phase of the internet is intended to end our collective reliance on a handful of tech giants while reducing the amount of control that any one company can have over the internet moving forward.

As reported by according to the analysis by Emergen Research...

The Web 3 market size was $3.2 billion in 2021 and is forecasted to reach $81.5 billion in 2030, growing at a CAGR of 43.7%

Though this is only one analysis taken into scope, I truly believe that the future will make great strides towards the developments currently being built in the Web 3 space, and I think it would be greatly beneficial for us all to contemplate how we might like to be a part of this technological and artistic renaissance...

as builders, creatives, and visionaries.

The world of Web 3 has truly changed my life, and so many experiences have shaped my path in ways I could have never anticipated. From selling Jake Paul my own digitized artwork, to working as a community manager for a 10,000 piece NFT collection, I have gotten the chance to understand many realms within this new evolution of the web, and the fire within my heart to both pursue it and to help build it, grows stronger every day.

Following 3 weeks of learning to create React apps from scratch at Flatiron School, I have been greatly inspired to continue building upon my budding software engineering skills, and will actively work towards learning the fundamentals of what will enable me to become a strategic and intentional blockchain developer.

I entered the Web 3 space in early 2021, and since then have only come to see more and more each day the endless possibilities in which our societal frameworks could re-establish themselves for the betterment of our collective future. This will be the first of a few posts simply overviewing some of the information I have found to be integral to truly understanding the Web 3 space, and will always do my very best to perpetuate the idea of decentralization -- even if all hope of a truly decentralized future may not be feasible on a global scale.

What is Web 3.0? 💱

Web3 is the metamorphosis of the world wide web. It includes, but is not limited to the realms of NFTs, blockchains, DAOs, the metaverse, and crypto.

Despite the growing awareness of Bitcoin and Ethereum, along with the emergence of new categories like DeFi, NFTs, GameFi and DAOs, blockchain developers represent less than 1% of the 31.1M software developers globally.

Facilitating the ease of use and interaction with decentralized apps (dApps) on a global scale where all blockchain networks are interlinked may require extra steps and more engagement, but many will see it as a worthwhile and necessary effort.

The Web Evolution 🌱

Web 1.0 - Information (Past)

In this initial version of the web, a user was only able to read the content of news sites, portals, search engines etc.

The Web 1 era was highly decentralized for a couple of reasons:

Low bandwidth infrastructure (up to 1Mbps)
Underdeveloped infrastructure went hand-in-hand with simple coding practices. Everyone could learn HTML or copy a template to deploy a website

Web 2.0 - Interaction (Present)

In the late 2000s, ventures such as YouTube and Netflix were able to scale as they delivered streamed content to the mass market.

In essence, Web 2 is the merger of Server-side (programs executed on a server) and Client-side (programs executed in a browser) programming, with web browser languages as the starting point.

Development stacks that have shaped the world as we know it today:

These programming layers made it possible to create dynamic web content, sandwiched between the Client-side and Server-side.

Web browser stack: HTML, JavaScript, CSS
Advanced Server-side and Client-side stack: PHP, JavaScript, Ruby, Python, Java
Server-side web frameworks: Django, Ruby on Rails, Laravel, etc.

Web 2 was built upon ideas of raising capital and the traditional management of business, leading to centralization and the network effect. Even if someone could clone Twitter, the value of Twitter is not in its software, but in the number of people using it.

Ultimately, this reality is what has brought about the reign of large tech giants in which many of us have indirectly become reliant on.

Example: Google.

(where it started) search engine start-up

(where it is today) ad integration and monetization, news aggregation, video-sharing, payment rails, AI, robotics, and smartphones

In the end, Web2 turned into an expansive ecosystem made up of a handful of organizational nodes. These nodes make it convenient to interact with the world, but centralized companies control the nodes and can change their policies whenever they like, inevitably leading to the lack of user ownership and transparency we so desperately need today.

Web 3.0 (The Future)

A year after the Great Recession of 2008–09, Bitcoin emerged as peer-to-peer (P2P) digital money, its genesis block directly referencing bank bailouts.

Bitcoin emerged as an alternative to central banking.

Bitcoin’s blockchain technology laid out the groundwork for what Web 3 is built upon.

After all, if money can be made both digital and decentralized, it is a layer that can easily be integrated into the internet.

Essentially, Web 3 mirrors Bitcoin, in the ways that it is a permission-less, trustless, and decentralized way of generating content, distributing it, and owning it.

Web3 is in many ways a continuation of Web2 in terms of interactivity, but at the bottom of the stack is a blockchain protocol.

On top of the blockchain protocol are four layers that bind blockchain to the end-user experience:

Smart contracts
Web3 libraries
Nodes
Wallets

These layers offer the same Web2 functionality, but with decentralized monetization, funds/data ownership, and censorship-resistant content.

Building the Future 🛠️

Given a brief overview of the evolution many of us have seen the Web emerge as, the time is now here to ideate, create, and further implement projects and organizations that can fuel us all to embrace a future where ownership is ours, and transparency bolsters ethical business practices.

Just a few months ago when I happened to be living in Silicon Valley working for a Web 3 social media startup, I quickly came to learn how many resources are becoming more and more readily available for developers to access and utilize as they craft software and applications for this new sphere of the Web. I was lucky to encounter some developer friends in my time living there who greatly encouraged me to learn React and Solidity to build dApps.

In future posts, I will make a point of delving deeper into the core fundamentals of the technology that Web 3 has emerged from, as well as the up and coming changes from which blockchain development will only become easier and more accessible. For the remainder of this post however, a few of the key factors in which I will touch upon include a bit about the blockchain, and the data that is stored on it.

What is Blockchain? 🔗

At its core, a blockchain is a public database of transactions

Blockchains themselves are pretty straightforward. They offer a public record which stores a history of transactions between parties, and this information can be accessed by anybody.

1) Immutability
A blockchain is append-only. Once data has been written, it can't be changed (known as immutability).

2) Validation
A blockchain takes the form of a linked-list instead of a table. That is, every set of transactions (known as a block) that is added to the blockchain must point to the previous block.

That way, there's a linear history of every transaction that has ever occurred the blockchain.

3) Decentralization
Because blockchains are decentralized - they're not owned by any particular organization, and can't be taken down in the same way as a regular database.

There are two primary forms of data that are stored on the blockchain:

Cryptocurrencies and Smart Contracts

Cryptocurrency

Cryptocurrencies are basically digital currencies that can be exchanged online as a form of payment for goods and services.

Crypto differs from traditional digital payment methods in a variety of ways:

1. Instead of having to register on a financial platform, anyone in the world can access and transfer cryptocurrency directly. Users don't need to worry about their assets being frozen or controlled by a third party.

2. Financial platforms are regulated by governments, and require personal data to use their services as a result. Cryptocurrencies allow transferring ownership without necessitating proof of identity.

3. As a result, market value can vary wildly, based on expectations for the project or blockchain tech as a whole. Volatility is very important in understanding which crypto investments are more risky or stable than others.

Smart Contracts

Smart contracts offer those who interact with them:

1) Immutability: Because smart contracts are immutable, an entity cannot change the agreement for personal gain. There is no possibility of a third party altering data on the blockchain

2) Transparency: Smart contracts are published to the blockchain, and can be read and written by anyone who has access to the blockchain.

3) Simplicity: Because smart contracts are expensive to deploy onto the blockchain and contain sensitive logic dictating the flow of financial transactions, they tend to be much smaller and simpler than most codebases.

If you're a JavaScript developer and want to explore writing your own smart contract, you may want to get familiar with Solidity. This is the most popular smart contract language and it's syntactically similar to JavaScript, which may make it easier to learn.

The best place to start to understand the fundamentals of blockchain is the Ethereum and Solidity documentation.

I have only begun to experiment with using Solidity in conjunction with React, but have included a React snippet here to show what the starter code for an app to display your connected Web 3 wallet would consist of.

Initializing the relevant library

Establishing the state of the connected account

And the return that would render your data...

With some additional code and configurations, you can easily build a simple dApp that would allow you to build a blockchain-based todo list powered by Ethereum smart contracts on the blockchain.

If you are interested into diving into creating a react dApp for yourself, check out this resource for an in depth guide.

A smart contract is a mechanism involving digital assets and two or more parties, where some or all of the parties put assets in, and assets are automatically redistributed among those parties according to a formula based on certain data that is not known at the time the contract is initiated.

— Vitalik Buterin, Co-Founder of Ethereum

Simply put, a smart contract is an if/when … then that is written into code. Two parties agree on certain terms that are translated to code and then added to the blockchain. Smart contracts automatically execute whenever a certain condition is met making them efficient.

Metamorphosis 🦋

Web 3 offers up a plethora of new opportunities for individuals from all circles of life.

This is likely just the start of many posts on this topic, as the heart behind this evolution of the Web has changed my life for the better in so many ways.

My biggest goal as a developer is to share the fire within me that is my dedication to promoting the idea of decentralization, a future being built, operated, and owned by its users.

Rather than continuing to rely on a structure monopolized by large technology companies, the future of what this new evolution of the Web offers *puts power back into our hands as individuals, rather than corporations. *

Instagram Twitter Opensea Discord

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

NESSA KODO

Observing Life Through Code

𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤 — Tue, 06 Sep 2022 17:18:29 +0000

“Simplicity is the soul of efficiency.”

— Austin Freeman

Just a few months ago, I dropped out of college in an effort to take a bet on myself. Though I wasn’t totally sure what my next move would be, I felt compelled to lean into my interests in the Web 3 space. About a week after disclosing my withdrawal from the remainder of the Spring 2022 semester, I was given the opportunity to attend a crypto conference within my own city — an experience that has forever shaped my path for the better.

I attended ETH Denver as a “BUIDLER”, and though I was not well versed in many programming languages at the time, I was able to encounter many remarkable individuals with communities and projects in the making that I know are changing the future as we know it.

Many developers from all backgrounds came together to collaborate with others to create applications and projects that could be selected and further funded by VCs and companies within the Web 3 space. Being able to watch the formation and development of these ideas sparked a flame within me that I haven’t been able to tame since, and I am forever grateful that somehow I took the leap towards exploring that which truly strikes a chord within me, the path of pursuing a new practice that pushes me to continue to be a lifelong learner, observing my own growth through progress, and observation.

Many conference attendees were eager to share their knowledge, and upon relaying my ambitions to be a blockchain developer, I was told about the Flatiron School, a programming school with live classes in my city.

I am now writing this as a student who has just completed the first out of five phases within the Software Engineering Bootcamp at Flatiron School in Denver, and following the last three weeks of exploring HTML, CSS and JavaScript, I have come upon some observations I’d like to at least try to express in words.

Patterns Extending to the Etheric 🧬

Though I would consider myself a spiritual person, I feel as if the meaning of that word has been convoluted by trends in recent years that perpetuate ideals of spirituality that detract from what it at least seems to me — a lifelong journey of introspection, rather than a lifestyle filled with superficial practices and ritual that may negate from the observation, learning, and growth that an organic and free-flowing spiritual path facilitates.

Etheric: of or relating to the heavens or a spiritual world or plane of existence

Within the context of programming, it’s become quite obvious to me that there are a seemingly infinite number of ways to write code, even if the intended goal is to perform the same function.

Regardless of how a developer may structure their code, there remains a consistent set of underlying structures that must remain the same for any code to work properly.

I personally believe that by observing themes and patterns on a micro level, we can better understand what might happen on a larger, more macro level. Individually, collaboratively, and systematically, many of the same underlying structures and elements remain constant, just as code does.

Ultimately, following my first week of collaboratively working on my first project for school, I have been inspired to contemplate what some of my realizations might suggest about life on a larger scale.

I’ve been reminded of some thoughts and ideas I’ve come across in other life contexts too — which only reinforces my belief that much of life stems from a very similar base, one which we shape and form to fit our individual styles and expressions as intellectuals and creatives.

In a very similar way, JavaScript, HTML, and CSS in conjunction with one another and separately, have enabled me to come to both new and familiar realizations, which I will elaborate on in the remainder of this post.

Communication is 🔑

In order to create effective communication, clear definitions of how you will express ideas and thoughts are essential.

Among the three primary programming languages I’ve been learning, there are different syntax rules that can sometimes make or break your code, meaning that **you can’t just copy and paste content **from one language to another and expect it to work.

Within the realms of programming, friendships, and partnerships, clear communication, and expression of needs, tendencies, and wishes, must be present in order to establish and create something solid, sound, and functional.

While this may sound a bit cliche, I found it worthy of touching on regardless.

Meet Me at the Function 🥳

Throughout the last few weeks, my many attempts to write and adjust JavaScript codes through trial and error have enabled me to understand the fundamentals of how functions work much more in-depth than ever before.

A JavaScript function is a block of code designed to perform a particular task.

There are A LOT of different ways to write functions in JavaScript, and two expressions that I have found particularly interesting are the arrow and anonymous functions.

In the code snippets below, I have tried to render the **same result **using these different function methods.

You can test these in Replit to verify that this is the result for the codes written below.

smile, you are awesome!

These are just a few examples of the ways you can write the same function, and I’d like to think that this further enforces the idea that a similar backbone exists behind many of the things that stem from an initial effect.

Traditional Functions

function encouragement(smile) {
    console.log(smile, "you are awesome!")
};
encouragement("smile")
//result
//smile, you are awesome!

Within this statement, we are introducing the function with the typed-out word “function” before the name of what we will call the function.

2. Anonymous Functions

const encouragement = function (smile) {
    console.log(smile, "you are awesome!");
};
encouragement("smile")
//result
//smile, you are awesome!

Anonymous functions allow us to call a function by simply assigning a variable, and follow the same structure as a traditional function.

3. Arrow Functions

const encouragement = (smile) => console.log(smile, "you are awesome!");
encouragement("smile")
//result
//smile, you are awesome!

Arrow functions allow us to condense the length of our function, enabling us to define it in a single line, while still computing the same result.

The variety of function expressions I have briefly discussed here are just a few of the many ways you can structure a function in JavaScript. Though the particularities of their styles vary, they still require the same core elements.

In many ways, I believe that our separate journeys as individuals within the human collective reflects this…leading us to also utilize some of the same elements or structures in the context of our lives.

Though many of us at this point have cultivated a number of different lifestyles and interests that allow us to experience vastly different life paths from one another,** we still seemingly come across the same themes, lessons, and ideals.**

Less is More 🤏

Within many other contexts within my life, I have come to realize that less really is more, and **being able to make a point that can be clearly understood, yet is still precisely to the point **is truly a skill I hope to better harness and utilize as I continue to evolve as a person, and a developer.

“Success is rarely determined by the quality of your ideas. But it is frequently determined by the quality of your execution.”

― Jeff Atwood Effective Programming: More Than Writing Code

Arrow functions provide a beautiful point of introspection for me, as they emphasize the point of how important it is to keep things meaningful and succinct.

**Further examples of how arrow functions can work are included below, **and I have included them to not only display their structure and functionality, but also hope that they can elude to the idea of embodying the vast array of ways that a function can be written.

While negating much of the extra “fluff” a function might normally contain, arrow functions may not have all the capabilities of other structures.

That being said…to any developers who may be reading this, I would advise you to avoid using the arrow function for event handlers, object methods, prototype methods, and functions that use the arguments object.

const a = 'smile'
const b = 'a shining star'
const add = (a,b) => (`${a}, you are ${b}!`)
console.log(add(a,b))

This function would return the following text in the console:

//smile, you are a shining star!

One final example of an arrow function:

phrase = “smile, you are amazing!”
phrase => expression
console.log(param) // this would return:
Resulting in the following phrase:

//smile, you are amazing!

The arrow function allows for the bulkiness of extra syntax elements to be replaced by simpler, shorter arrangements. I find this fascinating, and have found myself striving to reanalyze my coding techniques in efforts to cut down on some of the extra lines I’ve written, allowing me to more clearly establish what is going on within the function itself.

Within my life outside of coding, I have begun to also see how much more easy to understand clear and concise communication can be.

As my journey both with development and through life continues to unfold, I look forward to challenging myself to be more succinct with what the information I am trying to relay, in any medium I might be using.

Conclusion 🧠

Though I am still quite new to coding, the concepts I‘ve been able to learn have inspired me in many contexts outside its realm. Clear communication is key, and learning to express that in the most understandable and to the point way, is an effort I think would all help us to better understand one another better.

“Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.”

— Antoine de Saint-Exupery

There is no better time than now to exercise this, as we are in the midst of what seems like a modern renaissance, enabling us to create and share with the world ideas and visions that would only be possible given the technological and ideological advancements of the modern age.

Within the context of code and everyday life, infinite possibilities exist in terms of the various styles we might use as forms of expression.

At the core, the same fundamental elements exist and furthermore serve as cornerstones of the structure that is integral to the success of creating our desired result.

“Programming, in essence, must become the act of reducing complexity to simplicity.”

— Max Kanat-Alexander Code Simplicity: The Fundamentals of Software

I look forward to writing more content on this platform regarding more of my introspective thoughts as they surface within my journey of learning to code. I hope that in some way, this has sparked a flame within you to consider a new perspective, and I appreciate you taking the time to take a step within my mind. If you have any questions, or would like to be in touch, feel free to message me, or comment below.

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

NESSA KODO

Experiments && Progress

𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤 — Thu, 25 Aug 2022 16:47:00 +0000

Context

Within the scope of this post, I am going to delve into some of my understandings in my process of experimenting with the idea of coded music synthesizers. I have created a relatively simple audio synthesizer using the Web Audio API and in future posts will deploy my synth as I enhance its interface and functions.

To get an idea of what I will be discussing,

here is what the synth I've coded so far looks like!

Objective

My primary objective in exploring this project, is to utilize the knowledge I've gathered with HTML, CSS, and JavaScript to build a functional synthesizer and furthermore determine what possible parameters and displays I can add to it to create

an epic tool for creating algorithmic sound.

This synthesizer uses an oscillator as the source of its sound, which I will briefly touch on in my thoughts below.

Inspiration

Much of my inspiration stems from the live coding synthesizer Sonic Pi which has been created by the wonderful Sam Aaron. This program is free for anyone to use!

Sonic Pi is basically an incredible Ruby based program in which you can build functions to create sounds and manipulate them in front of live audiences, AND Sam created a very in depth guide for how to use it.

The photo below is a photo of the program, and a bit of code I've put into it to create a basic techno beat.

Intention

As I continue to work on this project, it will evolve in the way it works and functions, as my primarily goal is to integrate a container for code to generate and display as some of the parameters are adjusted within the synth.

I really appreciate what Sonic Pi has to offer its users, and really just want to bring more focus to the "algoraving" scene.

This post serves to mainly delve into some of the code I created with my novice understanding of JavaScript, and I hope as I continue to work on this and other related projects, to display the skills I am harnessing as I (hopefully) become a better coder.

The basic framework for creating a modular synth should involve a master volume control, and I established this with a JS variable:

const masterVolume = context.createGain();
masterVolume.connect(context.destination);

Though I am only going to tap on the topic of what an oscillator is for the sake of simplicity, (as I am not discussing my assignment of notes in this post) I will include the general definition of what an oscillator is.

An electronic oscillator is an electronic circuit that produces a periodic, oscillating electronic signal, often a sine wave or a square wave or a triangle wave.

To add an oscillator to the sound source I created this variable, and also connected it to the volume variable in the code above.

const oscillator = context.createOscillator();
oscillator.frequency.setValueAtTime(220, 0);
oscillator.connect(masterVolume);

ASDR

In sound and music, an envelope describes how a sound changes over time, and is essentially an amplitude effect typically made up of 4 values: (A)ttack time, (D)ecay time, (S)ustain level, and (R)elease time, or ADSR.

These are the four main controls of an envelope. Envelopes are what make a sound short and punchy, and also what enables you to fade in and fade out a sound.

Here is a visual that might simplify this concept.

Within my code, I used JavaScript to create these variables for the synthesizer to call from.

Web Audio API doesn’t have an envelope built in, it is possible to simulate the same effect using gain nodes. Here is the code I used to set initial parameters for the sound envelope.

// Envelope
let attackTime = 0.3;
let sustainLevel = 0.8;
let releaseTime = 0.3;
let noteLength = 1;

const attackControl = document.querySelector('#attack-control');
const releaseControl = document.querySelector('#release-control');
const noteLengthControl = document.querySelector('#note-length-control'):

Within the synthesizer I've coded, I've included three interactive levels that a user to adjust the range of the Attack, Release, and Note Length.

The event listeners below enables the levels that a user chooses to be registered as values that can greatly change the dynamic of the oscillator chosen.

attackControl.addEventListener('input', function() {
  attackTime = Number(this.value);
});

releaseControl.addEventListener('input', function() {
  releaseTime = Number(this.value);
});

noteLengthControl.addEventListener('input', function() {
  noteLength = Number(this.value);
});

Conclusion

It might have made sense for me to write this post on the way the sounds were implemented for the synthesizer to play, but I think that would be more appropriate for a more in depth post lightly tapping into music theory, and some of the ways Sonic Pi also generates notes from numbers.

Though I am only a few weeks into my journey with JavaScript, I am looking forward to better understanding it through creating and contributing towards projects within my coding school curriculum at Flatiron School, as well as personal projects I find myself working on incessantly in my free time.

If you're interested in exploring the Web Audio API for yourself,

you can explore some documentation here.

DEV Community: 𝙉𝙚𝙨𝙨𝙖 𝙆𝙤𝙙𝙤

Guide to Compiling C++: Making Your Code Run!

What compiling is

The compiler you will actually use: g++

Flags you will see a lot

Output names, because this trips everyone once

Quick correction on file extensions

A step by step example

Compiling with tests (GoogleTest)

Wrap

GitHub Pages: A Beginner's Guide to Deploying Your Website on a Custom Domain

Step 0: Decide what kind of Pages site you are deploying

Step 1: Publish using a gh-pages branch (only if you want branch based deploy)

Step 2: Turn on GitHub Pages in your repo

Step 3: DNS setup in Hostinger (the part everyone overthinks)

What records you actually want

A records for the root domain (apex)

CNAME record for www

Step 4: Connect the custom domain inside GitHub

If you are using a framework build (React, Vite, etc.)

Option A: public/CNAME (common for React)

Option B: docs/CNAME (only if you deploy from /docs)

Troubleshooting checklist

DNS changes are not showing up

www works but the root domain does not

HTTPS will not enable

React app loads but routing breaks on refresh

Wrap

Growing, Evolving, Developing.

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

NESSA KODO

Ruby && Web 3.0 -- Gems

giving you powers and tools to help you succeed ✨

"Web 3.0" exposes us to a new generation of web applications that are fueled by user ownership and decentralization.

Web 3.0 Concepts 💱

the majority of Web 3 material is most easily accessible through browser extensions.

The ability for users to manage their Ethereum accounts as well as the many methods of accessing blockchain states are just a few of the advantages that an Ethereum extension provides.

Gems 💎

Web3 RPC client for Ethereum

Ethereum For Ruby

Anywhere Ruby can be executed and transactions can be disseminated across any local or remote node, you can sign transactions and manage keys.

Applications 📱

Installing the Eth Gem

We can install it from the command line

Getting Started with QuickNode

Otherwise, QuickNode.com. offers a free 7 day trial!

Create an Endpoint

This will be used to help us connect to the Ethereum network.

Putting It All Together

Let us break down the code:

Run the Script

Conclusion 🔑

examples from which I hope anyone reading this might be inspired by the extended use cases of smart contracts, and blockchain technology.

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

NESSA KODO

The Heart of Web 3.0

Decentralizing the internet is at the heart of Web 3.

The Web 3 market size was $3.2 billion in 2021 and is forecasted to reach $81.5 billion in 2030, growing at a CAGR of 43.7%

as builders, creatives, and visionaries.

What is Web 3.0? 💱

The Web Evolution 🌱

Web 1.0 - Information (Past)

Web 2.0 - Interaction (Present)

Development stacks that have shaped the world as we know it today:

Example: Google.

Web 3.0 (The Future)

Bitcoin’s blockchain technology laid out the groundwork for what Web 3 is built upon.

Web3 is in many ways a continuation of Web2 in terms of interactivity, but at the bottom of the stack is a blockchain protocol.

Building the Future 🛠️

What is Blockchain? 🔗

Cryptocurrencies and Smart Contracts

Cryptocurrency

Crypto differs from traditional digital payment methods in a variety of ways:

Smart Contracts

A smart contract is a mechanism involving digital assets and two or more parties, where some or all of the parties put assets in, and assets are automatically redistributed among those parties according to a formula based on certain data that is not known at the time the contract is initiated.

Metamorphosis 🦋

ʕっ• ᴥ • ʔっ Thanks for reading!

Love,

The compiler you will actually use: `g++`

Step 1: Publish using a `gh-pages` branch (only if you want branch based deploy)

CNAME record for `www`

Option A: `public/CNAME` (common for React)

Option B: `docs/CNAME` (only if you deploy from `/docs`)

`www` works but the root domain does not