DEV Community: Naftali Murgor

Running a Full Bitgesell Node on Raspberry Pi (5/ 4 Model B)

Naftali Murgor — Sat, 08 Mar 2025 05:40:01 +0000

Introduction

Running a full Bitgesell node on a Raspberry Pi is now easier than ever! With a pre-built Docker image, you can get up and running without the hassle of compiling Bitgesell Core from source. Whether you have a previous Raspberry Pi model or the latest one, follow this guide to set up your node quickly and efficiently.

Why Run a Bitgesell Node on Raspberry Pi?

Raspberry Pi devices are energy-efficient and cost-effective, making them perfect for running a Bitgesell node. A node helps verify transactions, maintain decentralization, and support the Bitgesell network.

Prerequisites (1/2):

Before getting started with Bitgesell full node on your Raspberry Pi, ensure you have:

A single-board computer like Raspberry Pi (any model supporting ARM architecture)
At least 10 GB of storage space (grows over time as blockchain expands)
500 MB RAM + 1 GB swap file
A stable internet connection for syncing and communication with other nodes

Prerequisites (2/2)

3. Setting Up Your Raspberry Pi

Before running the node, set up your Raspberry Pi by following this setup guide.

4. Installing Docker on Raspberry Pi

Docker simplifies the deployment process. Install Docker on your Raspberry Pi using this quick guide.

5. Quick Start with Docker

Once Docker is set up, follow these steps to run your Bitgesell node.

Once the above are set, let's now set up a full Bitgesell Node on our Raspberry PI!

1. Pull the Docker Image

Run the following command on your Raspberry Pi to download the pre-built Bitgesell node image:

docker pull naftalimurgor/bgld-arm

2. Run the Bitgesell Node

Start the node using:

 docker run -dp 8454:8454 naftalimurgor/bgld-arm

This command maps the necessary ports and runs the node in detached mode.

3. Quick One-Liner Setup (Ubuntu 20.04 LTS)

If you are running Ubuntu 20.04 LTS on your Raspberry Pi, you can set up your node with a single command:

curl https://raw.githubusercontent.com/naftalimurgor/bgld-arm-docker/master/bootstrap-host.sh | sh

This script enables JSON-RPC on localhost and adds an upstart init script for auto-starting the node.

Verifying Your Node

Once your node is running, confirm its status with:

docker ps

This should output details about the running container, including its status and mapped ports:

CONTAINER ID   IMAGE                COMMAND   CREATED         STATUS         PORTS                                                 NAMES
304e5a74a539   naftalimurgor/bgld-arm   "bgld-arm"    5 seconds ago   Up 3 seconds   0.0.0.0:8454->8454/tcp, :::8454->8454/tcp, 8455/tcp   naughty_greider

Monitoring Node Logs

Check real-time logs of your Bitgesell node with:

docker logs -f bgld-arm

Additional Setup

For optional init scripts (Upstart and systemd), check the init directory in the repository.

Documentation

For more details and advanced configurations, visit the documentation folder.

Setting up a Bitgesell node on a Raspberry Pi is now easier than ever with Docker. Whether you're using an older model or the latest Raspberry Pi, follow this guide to contribute to the decentralization of the Bitgesell network effortlessly!

Introduction JavaScript code guidelines

Naftali Murgor — Wed, 23 Mar 2022 07:51:57 +0000

Introduction

In this tutorial, we shall learn about how I structure and how to structure and format JavaScript code for your projects.

1. Semi-colons

The choice is to drop all semi-colons usage because it adds to so much typing for little benefit and makes the codebase look 'ugly' and cluttered. The second choice about semicolons is to stick to them if an existing project uses them to keep the consistency.

JavaScript doesn't explicitly require semi-colons like say, in Java or C and C++. However, one may run into issues if one, for some reason does the following:

const addition = (a, b) => {
  let sum = a + b
  return // will return undefined due to automatic semicolon insertion
  sum // value will be ignored
}

2. Single and double quotes

Single quotes for regular strings and Double quotes for HTML and JSX. Use backticks when need to use interpolation in string templates. Template literals provide powerful ways of doing string interpolation, and usage is not limited to the trivial example above.

// this:
console.log('App running on PORT' + PORT )
// becomes:
console.log(`App is running on PORT ${PORT}`)
// or better still:
const apiEndpoint = `http://api.awsomeness.com/v1/api_key=${API_KEY}/`
// instead of 
const apiEndpoint = 'http://api.awsomeness.com/v1/api_key='+API_KEY+'/'

3. Indentation

Spaces over tabs. with tab-size of two spaces improves readability.

4. Structure

Every statement goes into its line and every related block is grouped together and separated by a blank line to improve readability and group logical blocks of code together.

5. Variable naming and naming conventions

Use PascalCase (lowerPascalCase in this case) for variable and function names and starting class names with Capital letters. This convention follows the following style:

lowerPascalCase - first letter in the variable name to be lower case and the preceding words to be in uppercase

const carModels = ['Nissan FB15']
const userId = 400
// versus
const user_id = 500 // meh

The best approach is to use descriptive function names that clearly show the intent of the code at a glance.

Summary

These are basic conventions I use regularly, however, most projects have popular guides with help of plugins such as Prettier formatter and Eslint linter to handle the formatting based on such guides. Formatter does the code formatting while linter catches imminent bugs. Setting up each of these is subject to a future article.

Read more about the common conventions from the MDN docs.

Some popular style guides:

While it might not be a must to use a style guide, maintaining consistency across the codebase is not only helpful but useful to the next developer who will be working on the codebase, say after 6 months or even 3 years later.

Found this article helpful? You may follow me on Twitter @nkmurgor where I tweet about interesting topics on web development or follow more topics on web development at naftalimurgor

Truthy and Falsy values in JavaScript

Naftali Murgor — Tue, 22 Feb 2022 23:19:54 +0000

Introduction

In this article, we shall learn about the concept of Truthy and Falsy values in JavaScript and why this concept is useful. Let's jump in!

What are truthy values?

Truthy values are values that evaluate to boolean in a conditional such as if..else and switch...case. In Computer Science, a Boolean is a logical data type that can only hold the value of true or false. Booleans are often used in conditionals like if...else

if (boolean conditional) {
  // code to be executed if conditional is true
} else {
  // if boolean conditional resolves to false
}

Truthy values are values that resolve to true when used in conditionals.

Truthy values in JavaScript

JavaScript treats the following values as Truthy:

true - A boolean of value true
{} value of an object with no properties, declared using Object literal
[] an empty array
51 any non-zero number, including negative and positive numbers
"0" any non-empty string
new Date() any value constructed from the Date object


if (true) { } // evaluates to true
if ({}) { }// evaluates to true
if ([]) { }// evaluates to true
if (51) { }// evaluates to true, negative and positive numbers except zero
if ("0") {...}// any string value execept an empty string
if (new Date()) {...} // value constructed from the Date Object

Why are Truthy values important?

Consider the following example:


const updateKeys = (keys = []) => {

  // this will resolve to true always for both an empty keys argument and nonempty
  if (keys) {

  }
}

An array with no elements will evaluate to true, hence the if(toDoItems) {...} will always evaluate to true and execute for both empty and none empty arrays.

What are falsy values

Falsy values are values that resolve to false when used in conditionals.

Falsy values in JavaScript

JavaScript treats the following values as Falsy:

false - A boolean of value false
"", '' value of an object with no properties, declared using Object literal
null, a value of null, no vale given
undefined, a value of a variable not assigned to a value
NaN a value representing Not-A-Number, usually as a result of adding a value of type number to the value of a non-number 8 + 1
0 a value of number zero

if (0) {...} // evaluates to true
if ("") {...}// evaluates to true
if (null) {...}// evaluates to true
if (undefined) {...}// evaluates to true, negative and positive numbers except zero
if (NaN) {...}// any string value execept an empty string

Considering falsy values, it's more beautiful for instance to do this:

  if (userName) { }

And not this:

 if (username === "") { }

 // or worse still
 if (typeof txString !== undefined) { }

Summary

JavaScript has a set of truthy values and falsy values that are important to know:

Evaluating an empty array, will always evaluate to true in a conditional
Evaluating an object with no properties will always evaluate to true in a conditional

That's all for this week!, I've been setting up a new domain for my blog naftalimurgor.com.. You may follow my Twitter handle https://twitter.com. Any questions queries shoot me an email, at nmurgor10@gmail.com

Introduction to JavaScript Strings

Naftali Murgor — Tue, 15 Feb 2022 21:00:53 +0000

Introduction

JavaScript Strings provide a way of representing and handling characters.

JavaScript Strings

A JavaScript string is a set of character(s) written inside quotes.

// with single quote
let emptyString = '' // an empty string
let name = 'Elon Musk'

// with double quotes
let project = "SpaceX"

Declaring a String in JavaScript does not restrict usage of single '' and double quotes ""

Acess character

String objects provide a useful method for accessing a character in a string

let catName = 'Anita'
console.log(catName.charAt(0)) // prints 'A', character at a position 0

Strings behave like Array-like objects, so above can be:

let catName = 'Anita'
console.log(catName[0])// prints 'A'
// looping throug each character
for (let i = 0; i < catName.length; i ++) {
  console.log(catName[i]) // A, n, i, t, a
}

Get length of a JavaScript String

const THREAD_NAME = 'Moonspiracy'
console.log(THREAD_NAME.length) // prints number of characters// 11

Summary

JavaScript Strings provide a way of presenting strings using double or single quotes. Both syntaxes are valid and usage is based on project style guide and preferences.

ES6: Default parameters explained

Naftali Murgor — Tue, 08 Feb 2022 16:28:14 +0000

Introduction

ES2015(ES6) introduced default parameters. Let's jump right in and learn about default parameters.

Default parameters

What would happen if we called a function with all or some parameters missing? It turns out JavaScript assigns undefined to the missing arguments.

Let's see example in code:

const add = (num1, num2) => num1 + num2

const sum = add(2) // one argument is missing // gets called as 2 + undefined
console.log(sum) // prints NaN

Default parameters allow us to define a default parameter value and will be used when no argument is provided for the paramter during funcion call:

const main = (port = 3000) => {
  // possible code ommitted here
}
main() //port will default to value of 3000
main(5000) // call main with 5000

Another dummy example:

// add default parameters at the end of parameter list
const restoreWallet = (privateKey, dumpToJson=true) => {
  // posible code omitted
}

const myWallet = restoreWallet('0xFEEDBEEFFEEDBEEF', false) // dumpToJson supplied as false
const myWalletTwo = restoreWallet('0x05417') // dumpToJson defaults to true if not supplied


const fetchItems = async (storeName, keys = []) => {
  // possible code omitted here

}
const itemStore = await fetchItems('Electronics') // keys defaults to an empty array object

Summary

Default parameters allow us to provide a default value for the argument when not supplied during the function call.

Default parameters are added at the end of the paremeter list.

ES6: Rest parameters

Naftali Murgor — Tue, 08 Feb 2022 16:24:27 +0000

Introduction

In this article, we shall learn about rest parameters.

Rest Parameters

Rest parameters allow several arguments to be supplied to a function. console.log(...args) follows this pattern. We can supply as many arguments to console.log() because console.log() takes rest parameters.

Example in code snippet showing the rest parameters:

// syntax for rest parameters:
const addSeveralNumbers = (...args) => {
  let result = 0
  args.forEach((num, index) => {
    result += num
  })

  return result
}
const addToTen = addSeveralNumbers(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
console.log(addTo) // prints 55

Summary

Rest parameters allow us to supply a non-fixed number of arguments to a function.
Syntax for rest parameters:function multiply(...args) { // function body}
Calling a function that takes rest parameters is done as one would do with a normal function like multiply(1,2,3,4)
The arguments supplied are accessed as an array of values inside of the function body like in the example

I've rarely used function rest parameters but it's good to learn and know they exist

How to fix Error 404 on Netlify for SPAs built with Reactjs

Naftali Murgor — Mon, 31 Jan 2022 20:25:47 +0000

Introduction

Hosting a React application on the Netlify platform often runs into an "Error 404". This is because an app built with Reactjs is a SPA (Single Page Application). Routing is done on the application and no HTTP calls are made to fetch pages server-side.

To fix this error,

go to the public folder of your application
create a file name _redirects( no file extension)
add the following content to the _redirects file:

/*    /index.html   200

Rebuild the application and the error is fixed.

This tells Netlify to route all redirects to the index.html which is the root entry of your application. In Firebase hosting, this is usually handled inside a config file inside the project root.

ES6: Object destructing

Naftali Murgor — Mon, 31 Jan 2022 20:19:50 +0000

Introduction

In this blog article, we shall learn about Object destructing in JavaScript. Object destructuring syntax was introduced in ES6 to make accessing Object properties much easier and cleaner

Object destructing

In pre-ES6, normally you'd read object properties and store the values associated to these properties in a variable like this:

// some code omitted
const result = {
  userId: 'dummy_id_001`,
  username: 'foo_bar'
  avatar: 'https://gravatar/xrkpxys/k1szh.png',
  accent: '#fff'
}

// reading a few properties off this object literal: pre-es6
var username = result.username
var accent = result.accent

In ES6, the above becomes:

// some code omitted
const result = {
  userId: 'dummy_id_001`,
  username: 'foo_bar'
  avatar: 'https://gravatar/xrkpxys/k1szh.png',
  accent: '#fff'
}

// reading a few properties off this object literal: pre-es6
let {username, accent, userId} = result
// now use username, accent as normal variables

This is useful especially if you need to read more than one property from the same object.

Summary

Object destructuring syntax provides a cleaner way of accessing more than one property off an object literal.

Use object destructuring when accessing more than one property of an object and pre-ES6 syntax(using the "dot" operator) when accessing only one object.

// possible code ommitted
const username = result.username // OK for single property
const {accent, avatar, userId} = result // use object destructing

Found this article helpful? You may follow my twitter handle @nkmurgor where I tweet about interesting topics on web development.

Freelancing, the stage of feeling stuck

Naftali Murgor — Tue, 25 Jan 2022 20:36:28 +0000

Introduction

In this article, I will share my experience freelancing lately and share insights.

Let’s jump right in!

What freelancing is

Freelancing is selling services at a fee to people who need those services. Say you are a plumber in a big city or town, you could market yourself as a plumber who is available on call to fix leaking faucets, etc.

The same goes for copywriting, Software development, Graphic design, UI/UX design.

The hardest work in freelancing is combining:

Interpersonal skills
Business skills
Technical skills (expertise)

Interpersonal skills involve communicating with clients being empathic with their needs and finding a better way to solve these needs.

Business skills on the other hand involve running a business- Market, paying bills, saving some money, and keeping the business running.

Technical skills are the skills you offer and apply to your problems brought forward by clients. This is essentially your craft.

As a freelancer, you have to juggle the three aspects and balance both which can be a bit overwhelming.

How success stories paint Freelancing

Perhaps I'm still getting into freelancing, but freelancing is painted as a very successful niche. In my experience, freelancing can go from:

Everything working out well, clients, income, emails all over, to
1 client with a very COMPLEX project that takes months
Weeks, to months of no clients.

As you know: Business - Customers = No income.

Perhaps this resonates well with this statement:

Everything’s going great for months and then everything gets turned on its head: weeks of no clients. DEMONIC projects. Stress. Feeling stuck — all the things you feared.
I kept these problems to myself as I felt embarrassed each time I found myself on a barren run. But talking with other freelancers — and pouring my freelance guts here on Medium — I realized I wasn’t alone. You can read more here

Freelancing is filled with challenges, is fun, and sometimes riddled with doubt and a lot of "what-if"s and sometimes regrets and doubts.

Freelancing on Online Platforms

Over the years, Most freelance communities have become saturated with an overwhelming steady stream of new users to the point Upwork had to pause new Graphic design and WordPress developer registrations for these categories.

Competition has become stiff and with new accounts, nobody knows what's going on there. Most categories have become overly saturated and low-paying. Making $5.00 websites might seem a way to get started but at times you end up doing more work for little income.

Offering services on these platforms might be great but you might end up short selling your skills and time. Well-paying clients exist on these platforms but are quite rare.

I recently made $250.00 doing 10 hours of work on one of the common freelancing platforms. Good clients are hard to come by and this can be devastating. I live in a low-income economy and $400 a month is a decent income where I live.

Summary

Freelancing is a challenge and it's a lot of work than working a full-time job. Having clients on a retainer can be a great way to earn a steady income as compared to one-off projects. One-off projects can be great if it's a decent size project and pay well like $5000 or even more.

What's your experience freelancing? How do you make recurrent income? Feel free to leave a comment down below.

Thanks for stopping by! Until next week, adios!

Introduction to E2015 Set Objects

Naftali Murgor — Tue, 25 Jan 2022 20:30:51 +0000

Introduction

Set objects are constructed using new Set().

Set object

A set is a “set of " unique values. Say you have a simple game and need to track the position of mouse clicks. You’d store every position in a set object. Duplicate values are discarded when an attempt to add the set object is made.

Sample code showing a simple Set object usage:

function main() {

    const gameScreen = document.getElementById('game-screen')
    gameScreen.addEventListener('click' updateAction)

    const cursorPositions = new Set()
    function updateAction(event) {
      let position = {x: e.clientX, y: e.clientY}
      cursorPositions.add(position) // any duplicate values are discarded, which is ideal in this case
    }
    // use unique cursorPositions below
}

while(true) {
  main()
}

Duplicate values are discarded when added to a set. This is useful for capturing and storing unique values where duplicate values are not needed.

const letters = new Set()
letters.add('A')
letters.add('B')
letters.add('A') // duplicate entry is ignored
console.log(letters) // Set {2} {'A', 'B'}

Summary

The set object provides a way of storing data where duplicate values are not required.

Note: Most languages including JavaScript offer a lot of language features but it’s not a good approach to try learning all these language features at a go. However, knowing they exist is enough as it helps one know where to look when the need arises.

Introduction to ES6 Map objects

Naftali Murgor — Tue, 25 Jan 2022 20:26:39 +0000

Introduction

In this blog article, we shall learn about map objects introduced in ES2015. Maps are key-value pairs, where the key can be of any type.

It's a typical practice in JavaScript to use Object literals as maps, most likely because Object literal predated Maps.

Map objects

Map objects can be created using new Map() syntax.

Sample code showing how to create a map object and add some values using Map.set():

const studentDetails = new Map()
studentDetails.set('age', 25)
studentDetails.set('class', 2018)
studentDetails.set('name', 'Naftali Murgor')

In object literal, the following would have been equivalent of the above:

const studentDetails = {
  age: 25, // made up
  class: 2018,
  name: 'Naftali Murgor',
}

Map offers useful helper methods compared to using object literal.

Some of the methods and properties include:

const map = new Map()
// helper methods and properties
map.clear
map.delete
map.entries
map.forEach
map.get
map.has
map.keys
map.set
map.size
map.values

Let's explore some of the helper methods and properties.

1. `Map.clear()`

Map.clear() deletes the map values entries leaving an empty map.

studentDetails.clear()
console.log(studentDetails) // Map(0) {} // all key-values cleared!

2. `Map.delete()`

Map.delete('key') deletes the value in the a map based on the key passed to as an argument. Returns boolean of true on succesful deletion or false on failure.

studentDetails.delete('age') // remove age entry
console.log(studentDetails)// Map(2) { 'class' => 2018, 'name' => 'Naftali Murgor' }

3. `Map.has('key')`

Checks if a key exists in a map. Returns boolean. true if key is existent and false otherwise.

console.log(map.has('class')) // true
console.log(map.has('height')) // false

4. `Map.size`

Map.size is a getter that returns the number of entries in the map object.

console.log(studentDetails.size) // 4

5. `Map.keys`

Map.keys is a getter that returns a Map iterator that contains all the keys of the map object.

 console.log(studenDetails.keys()) // Map iterator { 2018, 'Naftali Murgor' }

6. `Map.set()`

Map.set('key', 'value') method takes a key and value as arguments and adds new entry to the map object.

studentDetails.set('weight', 59)

7. `map.get()`

Map.get('key') returns the value associated with the key passed as an argument.

console.log(studentDetails.get('age')) // 25

Summary

Map objects are key-value pairs, where a key is associated with a value. Maps are called a dictionary, a HashMap in other languages.
We create a map object by using new Map(). We then add key-value pairs using Map. set(‘key’, ‘value’)
Object literals are a common style of using maps. In JavaScript, we use Object literal as a map, how hilarious is that. However, Object literals provide methods that aren’t useful. The takeaway is that the JSON interface and JSON encoding/decoding are interoperable with object literals.

ES6: JavaScript for...of statement

Naftali Murgor — Tue, 18 Jan 2022 19:24:39 +0000

Introduction

This tutorial will learn about for-of introduced in ES6 version of JavaScript.

The for...of statement is used for iterating over arrays, maps or sets.

Looping over an array

Example in code:

const fruits = ['Orange', 'Apple', 'banana', 'Lemon']

// looping through
for (fruit of fruits) {
  // do something with fruit
}

Looping over a string

for...of can also be used to loop over contents of a string.

const words = 'Happy new year!'
for (char of words) {
  console.log(char) // H a p p y n e w y e a r !
}

Looping over a Set

A set is a collection of unique values.

const letters = new Set(['a', 'b', 'c'])

for (letter of letters) {
  console.log(letters) // a, b, c
}

Looping over a map

A map is key-value pair, where key can be of any type. In JavaScript it's common to use object literals as maps

const details = new Map( [
  ['name', 'Michael Myers'],
  ['age', 45] // made up
])

// or a cleaner way:
const details = new Map()
details.set('name', 'Michael Myers')

for (detail of details ) {
  console.log(detail)
}

Summary

for...of introduces a cleaner way of looping over arrays, sets, strings and maps.

DEV Community: Naftali Murgor

Running a Full Bitgesell Node on Raspberry Pi (5/ 4 Model B)

Introduction

Why Run a Bitgesell Node on Raspberry Pi?

Prerequisites (1/2):

Prerequisites (2/2)

3. Setting Up Your Raspberry Pi

4. Installing Docker on Raspberry Pi

5. Quick Start with Docker

1. Pull the Docker Image

2. Run the Bitgesell Node

3. Quick One-Liner Setup (Ubuntu 20.04 LTS)

Verifying Your Node

Monitoring Node Logs

Additional Setup

Documentation

Introduction JavaScript code guidelines

Introduction

1. Semi-colons

2. Single and double quotes

3. Indentation

4. Structure

5. Variable naming and naming conventions

Summary

Truthy and Falsy values in JavaScript

Introduction

What are truthy values?

Truthy values in JavaScript

Why are Truthy values important?

What are falsy values

Falsy values in JavaScript

Summary

Introduction to JavaScript Strings

Introduction

JavaScript Strings

Acess character

Get length of a JavaScript String

Summary

ES6: Default parameters explained

Introduction

Default parameters

Summary

ES6: Rest parameters

Introduction

Rest Parameters

Summary

How to fix Error 404 on Netlify for SPAs built with Reactjs

Introduction

ES6: Object destructing

Introduction

Object destructing

Summary

Freelancing, the stage of feeling stuck

Introduction

What freelancing is

How success stories paint Freelancing

Freelancing on Online Platforms

Summary

Introduction to E2015 Set Objects

Introduction

Set object

Summary

Introduction to ES6 Map objects

Introduction

Map objects

1. Map.clear()

2. Map.delete()

3. Map.has('key')

4. Map.size

5. Map.keys

6. Map.set()

7. map.get()

Summary

ES6: JavaScript for...of statement

Introduction

Looping over an array

Looping over a string

Looping over a Set

Looping over a map

Summary

1. `Map.clear()`

2. `Map.delete()`

3. `Map.has('key')`

4. `Map.size`

5. `Map.keys`

6. `Map.set()`

7. `map.get()`