DEV Community: Ebenezer Enietan (Niza)

Code Optimization Is Tricky

Ebenezer Enietan (Niza) — Sat, 15 Jul 2023 17:54:50 +0000

I want you to look at the code below and guess which code will run faster. The console.time() method starts a timer you can use to track how long an operation takes. After guessing run the script and check your console to find out which one runs faster let me know if you guessed right

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>speed test</title>
</head>
<body>
  <h1>check your console</h1>
  <script>
    console.time("first");
      console.groupCollapsed()
      let count = 2;
      while( count <= 5000){
        if(count % 2 == 0 ){
          console.log(count);
        }
        count ++;
      }
      console.groupEnd()
    console.timeEnd("first");


    console.time("second");
      console.groupCollapsed()
      let trick = 2;
      while( trick <= 5000){
        console.log(trick);
        trick += 2;
      }
      console.groupEnd()
    console.timeEnd("second");
  </script>
</body>
</html>

Goodbye StackOverflow

Ebenezer Enietan (Niza) — Sun, 04 Jun 2023 09:26:08 +0000

If you've been a programmer for more than two years, you're probably familiar with Stack Overflow, a popular online forum where developers can ask and answer questions about programming languages and problems. It's a valuable resource for programmers of all levels, and it's also a source of many jokes about developers who rely too heavily on Stack Overflow answers.

I've recently noticed that there is an increasing reliance on ChatGPT, Bard, and other AI platforms among up-and-coming programmers. Could this signal the end of Stack Overflow? Are these new AI tools good replacements for Stack Overflow? Is the idea of relying on a platform for debugging a good one?

In conclusion, are AI-generated codes suitable for young developers to add to their codebase without extensive refactoring? I'd love to hear your thoughts.

Legislating AI

Ebenezer Enietan (Niza) — Sun, 19 Mar 2023 09:31:20 +0000

Every field including artificial intelligence calls for the development of public sector policies and laws for regulating them in every jurisdiction (all legal boundaries) globally, Regulation is necessary to both encourage AI and manage associated risks. I liken the current state of AI regulation to kids playing and all of a sudden they come back crying with various injuries because no rules were laid down for how they should play.

There are still a lot of unanswered questions in many territories about simple things like copyright; do AI(s) have copyrights? if an AI is modeled on a person's data does the person have any ownership? are there forbidden AI algorithms or is it the wild west? these and many more are some of the things to consider deliberately.

It is important that there are legislative frameworks for judges and lawyers to follow on how to approach AI-related cases. If all the legal cases involving AI are brought to court without existing legal frameworks the AI companies will win most of the cases; they typically have more money and better lawyers. It will also continue to favour them in future because of the legal precedence established.

What do you think important components of AI law should be?

When she marries one of you!

Ebenezer Enietan (Niza) — Thu, 02 Feb 2023 05:56:52 +0000

Alternatives To Node Js

Ebenezer Enietan (Niza) — Thu, 19 Jan 2023 04:06:21 +0000

There are a lot of standalone JavaScript runtime built on various engines like V8 but in order for them to qualify as an alternative to node they must be actively developed and designed to be used as back-end for web. These really narrows down the list; with that in mind here are the alternatives to node js.

Deno

Deno is a JavaScript/TypeScript runtime built with V8 JavaScript engine, (the same as Node js). It was created by Ryan Dahl, the original creator of Node.js, in 2018. Are you thinking what I'm thinking?

Deno Claims to provide a more secure and efficient runtime environment for JavaScript and TypeScript development, Deno includes built-in support for features such as TypeScript, WebAssembly, WebSocket, more modern and secure approach to handling modules, file system access, network operations and implements fetch API* (a pain point for many Node developers which is fixable with the Node-Fetch API only starting with the Node version 17.5).

Deno does not use a package manager such as npm. Instead, it uses a more modern approach where modules can be imported directly from a URL. Documentation, tutorials, and examples can be found at Deno website

Deno is relatively new so it's not as widely adopted as Node.js but it is getting there. As for speed; they are almost the same with node having slight advantage generally performance is a big argument among developers. Your Node js project are not easily migrated to deno.

Bun

Bun is a JavaScript runtime that stands out for its speed and built-in bundling & transpiling features. Developed using the Zig programming language, Bun constructs its runtime on the lightning-fast JavaScriptCore engine, used in Apple’s Safari web browser. It was released in 2022 by former Stripe developer Jared Sumner.

Other runtimes rely on outside tools for bundling your JavaScript projects and for transpiling code from another language. Bun handles all of these features. It also implements the Node.js algorithm for resolving modules. This means that Bun can make use of NPM packages. Bun’s bundler can find and install packages from the vast NPM repository and manage their dependencies, it also comes with first-class support for the TypeScript and JSX languages.

Bun claims to offer some advantages over Node.js in simplicity of tooling and speed. Documentation, tutorials, and examples can be found at Bun Website

Have you tried any of these alternatives? please share your experience.

These newer programming Languages could be the future

Ebenezer Enietan (Niza) — Sun, 15 Jan 2023 10:49:11 +0000

It is commonly said that one "dog year" is equivalent to seven "human years". Sometimes I feel like programming years are like "dog years", so let say a dog lives 15 years; in this article i will like to list some of the note worthy languages of the past 15 years and links to their official documentation. Here is my list in no particular order:

Rust 2010 Rust Docs
Dart 2011 Dart Docs
Julia 2012 Julia Docs
Swift 2014 Swift Docs
Kotlin 2016 Kotlin Docs
TypeScript 2012 Typescript Docs
Ballerina 2017 Ballerina Docs
Crystal 2014 Crystal Docs
Nim 2008 Nim Docs
Zig 2013 Zig Docs
Elixir 2011 Elixir Docs
Go 2009 Go Docs
Red 2011 Red Docs
Perl 6 2015 Perl 6 Docs
Ceylon 2012 Ceylon Docs

So there you have it, how many of these have you used, and what would you add or remove from the list?

JavaScript null is weird

Ebenezer Enietan (Niza) — Sun, 08 Jan 2023 10:10:26 +0000

JavaScript has a unique way of implementing common programming concepts. Some things you assume will work a certain way will definitely give you a result but not the one you were expecting.

Let's say you read some literature that Null is a data type then you run typeof(null) then you find out null is not an object, but it is of type object:

let x = null;
console.log(typeof x);  // logs "object"
//also this not-object-fake-object  has no properties
let x = null;
console.log(x.prop);  // TypeError: Cannot read property 'prop' of null

Also consider this, in JavaScript, null is considered a falsy value, which means it will be coerced to false when used in a boolean context. This means that when null is compared to 0 using the less-than-or-equal-to operator (<=), the result will be true.

console.log(null < 0);  // logs "false"
console.log(null > 0);  // logs "false"
console.log(null == 0);  // logs "false"
console.log(null === 0);  // logs "false"
console.log(null <= 0);  // logs "true"
console.log(null >= 0);  // logs "true"

Talking about weird things here is another example NaN is never equal to NaN the best way to test NaN is to use isNaN();

NaN === NaN; //false
console.log(isNaN(NaN)); // true
console.log(isNaN(123)); // false
console.log(isNaN('hello')); // true
//But beware
console.log(isNaN('123')); // false

I know you have experienced other weirdness in your JavaScript journey, please share it and the reason why you think it exists? Do you think there were too many opinions in the development of the language? Are there too many people taking advantage of these quirks for them to be changed? Let me know your opinion.

Asymmetric encryption

Ebenezer Enietan (Niza) — Fri, 30 Dec 2022 18:35:13 +0000

Asymmetric encryption is a method of encrypting data so that the encryption and decryption keys are different. This means the key used to encrypt the data is not the same as the key used to decrypt it.

In asymmetric encryption, there are two keys: a public key and a private key. The public key is used to encrypt the data, while the private key is used to decrypt it. The public key can be shared with anyone, while the private key should be kept secret.

One of the main benefits of asymmetric encryption is that it allows for secure communication between two parties without needing to exchange a shared secret key beforehand. This makes it useful for secure communication over the internet and other untrusted networks.

There are many different algorithms that can be used for asymmetric encryption, including RSA, ElGamal, and Diffie-Hellman. These algorithms use complex mathematical operations to generate public and private keys, and they are designed to be challenging to crack even with advanced computing power.

JavaScript libraries that provide support for asymmetric encryption
node-rsa: https://www.npmjs.com/package/node-rsa
jsrsasign: https://kjur.github.io/jsrsasign/
jsencrypt: https://www.npmjs.com/package/jsencrypt

PHP libraries that provide support for asymmetric encryption
OpenSSL: https://www.php.net/manual/en/book.openssl.php
phpseclib: https://github.com/phpseclib/phpseclib
Sodium: https://www.php.net/manual/en/book.sodium.php

Python libraries that provide support for asymmetric encryption
pycryptodome: https://pycryptodome.readthedocs.io/en/latest/
pycrypto: https://pypi.org/project/pycrypto/
cryptography: https://cryptography.io/en/latest/

Asymmetric encryption has various applications, including secure communication between two parties, digital signatures to verify the authenticity of messages, secure login systems, secure key exchange, and secure file transfer, secure API. It is a powerful tool for protecting data and communication in many different contexts, such as online banking, e-commerce, and secure messaging. Asymmetric encryption uses a public key to encrypt data, which can only be decrypted using a private key, ensuring that only the intended recipient can access the data.

Alternatives to Git.

Ebenezer Enietan (Niza) — Mon, 26 Dec 2022 20:12:20 +0000

Git is a popular version control system that is widely used by software developers to track changes to their code and collaborate with other team members. However, there are several alternative version control systems available that offer similar functionality to Git. Here are a few examples:

Mercurial:

Mercurial is a free, open-source version control system that is similar to Git in many ways. It is known for its simplicity and speed, and is popular among developers who prefer a lightweight tool. The official website for Mercurial is https://www.mercurial-scm.org/. Some basic commands in Mercurial include:

hg init: Initializes a new Mercurial repository.
hg clone: Makes a copy of an existing repository.
hg add: Adds a new file to the repository.
hg commit: Saves changes to the repository.
hg push: Sends changes to a remote repository.

Subversion:

Subversion (also known as SVN) is another popular version control system that is similar to Git. It is known for its reliability and simplicity, and is often used in large organizations. The official website for Subversion is https://subversion.apache.org/. Some basic commands in Subversion include:

svn checkout: Downloads repository from a remote server.
svn add: Adds a new file to the repository.
svn commit: Saves changes to the repository.
svn update: Downloads latest changes from a remote repository.

CVS:

CVS (Concurrent Versions System) is an older version control system that is still used by some developers today. It is known for its simplicity and ease of use, but lacks some of the more advanced features found in newer systems like Git and Mercurial. The official website for CVS is https://www.nongnu.org/cvs/. Some basic commands in CVS include:

cvs checkout: Downloads repository from a remote server.
cvs add: Adds a new file to the repository.
cvs commit: Saves changes to the repository.
cvs update: Downloads latest changes from a remote repository.

Comparison of Git, Mercurial, Subversion, and CVS

1. Speed:
Git is generally considered the fastest version control system, as it utilizes a decentralized model and stores data in the form of hashed values, allowing for faster data transfer and retrieval. Mercurial is also known for its speed, as it utilizes a similar decentralized model and stores data in a similar manner. Subversion and CVS are both centralized systems and may not be as fast as Git and Mercurial in terms of data transfer and retrieval.

2. Flexibility:
Git and Mercurial are both highly flexible version control systems, as they allow for the creation of multiple branches and merging of changes easily. Subversion is also flexible, but may not be as user-friendly in terms of branching and merging compared to Git and Mercurial. CVS is not as flexible as the other version control systems, as it does not support branching and merging as easily.

3. Security:
Git and Mercurial both utilize a decentralized model, which means that there is no central repository for data. This makes it more difficult for data to be lost or compromised. Subversion also has good security measures, as it uses SSL/TLS encryption for data transfer and has options for authentication and authorization. CVS has weaker security measures compared to the other version control systems, as it does not utilize encryption for data transfer and has limited options for authentication and authorization.

4. Ease of use:
Git and Mercurial can both be somewhat difficult for new users to learn, as they utilize a command-line interface and have a steep learning curve. Subversion is more user-friendly, as it has a GUI interface and is easier to understand for new users. CVS is also user-friendly, as it has a simple command-line interface and is easy to learn for new users.

Reading, writing and handling files/directories why should a web developer care?

Ebenezer Enietan (Niza) — Fri, 23 Dec 2022 18:57:25 +0000

I teach programming and sometimes while going through a class and its properties/methods a student will ask why they are learning a certain method and what can it be used for in the real world. With the exception of shell scripting and maybe python programmers Many programmers, especially self-thought programmers ignore certain things like how to read, write and handle files/directories in their chosen language.

Regardless of your chosen language here are some things you can do when you learn how to read, write and handle files/directories

Multi-themed applications
Document generators
Website builders
Self-installing/updating apps
File-based data storage

Multi-themed applications

File and directory reading and writing functions can be useful in creating a multi-themed application, which is an application that allows the user to switch between multiple visual themes or styles.

To create this, you could follow these steps:
Determine the structure and content of the application, including the different visual themes or styles that will be available.
Create separate directories or files for each theme or style, and include the necessary CSS, image, and other files for each theme.
Write a program that uses the file and directory reading and writing functions to read in the appropriate theme or style files based on the user's selection. The program could also allow the user to create and save custom themes or styles.
Test the multi-themed application

It's worth noting this process can be complex and requires careful planning and testing to ensure that the themes or styles are applied correctly and consistently throughout the application. Also, the specific steps and approach you take will depend on your specific needs and requirements.

Document generators

A document generator is a program that generates documents automatically, either by creating new documents from scratch or by modifying existing documents.
To create a document generator you could follow these steps:

Determine the type of documents you want to generate and the information that needs to be included in the documents.
Create a template for the documents, using placeholders for the information that will be filled in by the generator.
Iterate through the template and replace placeholders with the actual information, and generate the final documents.

This can be especially useful for generating large numbers of documents.

Website builders

A website builder is a program that generates a website automatically.
To create a website you could follow these steps:

Determine the structure and content of the website that you want to generate. This could include the layout of the pages, the types of content that will be included (such as text, images, and videos), and the navigation structure of the site.
Create templates for the different types of pages/components and content that will be included on the website. These templates could include placeholders for the actual information that will be filled in by the builder.
Read in the templates and map placeholder to actual information and then generate the final website. The program could also create the necessary directories and files for the website, such as the HTML files for the pages, the CSS files for the styles, and the image and video files.

<?php

// Read in the template file
$template = file_get_contents('template.html');

// Read in the variable data from a CSV file
$data = array_map('str_getcsv', file('data.csv'));

// Replace the placeholders in the template with the actual data
$page = str_replace('[TITLE]', $data[0][0], $template);
$page = str_replace('[HEADING]', $data[0][1], $page);
$page = str_replace('[CONTENT]', $data[0][2], $page);

// Write the generated page to a file
$filename = 'index.html';
file_put_contents($filename, $page);

You could make the example above mor interactive by receiving actual information from the user through form elements and visually display the result as the fill out the forms

Self-installing/updating apps

a self-installing or self-updating website, which is a website that can install or update itself automatically without requiring manual intervention.
To create a self-installing or self-updating website you could follow these steps:

Determine the structure and content of the website, including any updates or changes that will be made to the site.
Write the program by using the file and directory reading and writing functions to track the current version in the case of an update then download the necessary files for the website from a remote server and install them on the local server.
It's worth noting that creating a self-installing or self-updating website can be complex and requires careful planning and testing to ensure that the process goes smoothly. For example, you will need to consider issues such as security, compatibility, and rollback in case of errors or incompatibility of system requirements.

File-based data storage

To build a custom data storage system using file reading and writing functions in any programming language, you will need to perform the following steps:

Open a file in the appropriate mode (e.g. write mode to store data, read mode to retrieve data).
Write the data to the file using the appropriate method (e.g. write() in Python, fwrite() in C).
Close the file when you are finished writing to it.
Open the file again in the appropriate mode (e.g. read mode to retrieve data).
Read the data from the file using the appropriate method (e.g. read() in Python, fread() in C).
Close the file when you are finished reading from it.
Here is an example of how this might look in Python:

# Open a file in write mode
with open('data.txt', 'w') as f:
  # Write some data to the file
  f.write('This is some data that we are storing in the file.\n')
  f.write('We can store any type of data, such as numbers: 1, 2, 3\n')
  f.write('Or even lists: [1, 2, 3]\n')

# Open the file in read mode
with open('data.txt', 'r') as f:
  # Read the contents of the file
  contents = f.read()
  print(contents)

Note: The choice of data structures and algorithms can have a significant impact on the performance, efficiency, and scalability of the storage system; data structure and a sorting algorithm can allow for fast insertion and retrieval of data,

JavaScript Regular/Normal vs Arrow Function: My Beef with Arrow Functions.

Ebenezer Enietan (Niza) — Thu, 08 Dec 2022 19:21:24 +0000

When I First encountered arrow functions, I was exited about the syntax difference. So I started putting them in everything; that was a huge mistake. I soon noticed abnormal unwanted behavior in the "this" keyword, so for a while I hated arrow functions but we have reconciled.

Both function declaration and expression can be written as Normal/Regular Function

// function declaration
function test(mama) {
   return ` ${mama} is the best`
}

// function expression
const test = function(app) {
   return `Hey ${app} is not working`
}

Arrow function or fat arrow function was introduced in ES6

const callNurse= (nurse) => {
   return  `${nurse} please come! I feel a piercing arrow`
}

The Differences

1. Implicit Return

In normal regular functions, you must use the return keyword to return any value. If you don’t return anything then the function will return undefined. Arrow functions can return a value without the return keyword; If the arrow function contains one expression, you can omit the curly braces, and then the expression will be implicitly returned.

2. Curly braces {}

Curly braces {} are not required if its only one line of statement

const uno = (name) => name + “ ye”;
uno(“niza”);
// niza ye

3. Parenthesis()

Parenthesis () not required if you pass only one argument and you can use only underscore _ if there is no other argument as it is one character shorter (_ and $ are valid identifiers in js )

let add = x => x + x;
let shootArrow = _ => console.log("shooting arrow");

4. Arguments binding

In regular functions, the arguments keywords can be used to list the arguments of which passed to the function. Arrow functions on the other hand do not have an argument binding.However, if you want to access arguments in an arrow function, you can use the rest parameter:The rest parameter syntax allows a function to accept an indefinite number of arguments as an array.

function normalFunc(x,y) {
   console.log(arguments)
}
normalFunc(1,2) // Arguments[1,2]

const arrowFunc = (x,y) => console.log(arguments)
arrowFunc(1,2) //ReferenceError: arguments is not defined

var arrowFunction = (...args) => {
   console.log(...args)
}arrowFunction(1,2)
// 1 2

5. this

In normal regular functions, "this" changes according to how the function is invoked. "this" may refer to the global object or undefined if you are using strict mode. It could be the object that owns the method the if the function is a method of an object. Other times it refers to the newly created instance when it is used as a constructor.

Arrow functions don’t have their own “this”, and they don’t redefine the value of this within the function. “this” inside an arrow function always refer to "this" from the outer context. This is my biggest beef with arrow functions

//normal function
const person = {
 run() {
     console.log(this);
 }
};
person.run();
// logs person object


//arrow function
const person = {
        run: () => {
              console.log(this);
        }
    };
person.run();

// logs window object

6. new

Regular functions are constructible, they can be called using the new keyword. However, arrow functions can never be used as constructor functions. Hence, they can never be invoked with the new keyword

function add (a, b) {
   console.log(a + b)
}
let sum = new add(2,3); // 5

let add = (a, b) => console.log(a + b);
const sum = new add(2,4);

// TypeError: add is not a constructor

7. No duplicate named parameters

In normal function, we can do this: row functions can never have duplicate named parameters, whether in strict or non-strict mode.

// allowed
function add(x, x) {}

// not allowed
'use strict';
function add(y, y) {}
// Uncaught SyntaxError: Duplicate parameter name not allowed in this context
const arrowFunc = (a,a) => {}
// Uncaught SyntaxError: Duplicate parameter name not allowed in this context

8. Function Hoisting

In regular function, the function gets hoisting at the top. But in arrow function, function get hoisted where you define. So, if you call the function before initialization you will get a ReferenceError

get referenceError.
normalFunc()
function normalFunc() {
   return "Shooting bullets"
}
// "Normal Function"

arrowFunc()
const arrowFunc = () => {
   return "Shooting Arrows"
}
// ReferenceError: Cannot access 'arrowFunc' before initialization

Terminal , Shell, CLI : Your first 20 commands;

Ebenezer Enietan (Niza) — Sat, 03 Dec 2022 20:02:39 +0000

A terminal is a program that runs a shell and allows us to enter commands. Examples of terminal emulators include: Command prompt, guake, gnome-terminal, terminator etc. Any wrapper program that runs a shell interpreter is a terminal.

The shell is a command-line interpreter. The shell is the program that actually processes commands and outputs results some examples of shells are: Bash, fish, zsh, ksh, sh, tsch, Power Shell, pwsh cmd, yori, 4dos, command.com.

A command-line interface(CLI) is any type of interface that is used to enter (textual) commands. One of these is the terminal, but some programs have their own command-line interfaces.

We connect with computers in a variety of ways, including utilizing a keyboard and mouse, touchscreen interfaces, and speech recognition systems. A graphical user interface is a most often utilized method of interacting with personal computers (GUI). We deliver instructions with a GUI by clicking a mouse and using menu-driven interactions. This way of delivering instructions to a computer in certain cases and for certain repetitive performs poorly, so we can take advantage of the Unix shell. The Unix shell is both a command-line interface (CLI) and a scripting language that can execute repetitive tasks automatically and quickly with the proper commands.

Here are a some commands and what they do; options are in parenthesis

1. $ whoami

It returns your username.

2. $ ls

list the contents of the current directory(ls –F, ls -help, man ls)

3. $ pwd
present working directory

4. $ cd
Change direct eg cd Desktop moves user to desktop directory

5. $ mkdir
mkdir [path] creates a new directory.
Eg. mkdir web

6. $ nano
A text editor eg to make a text list.txt use the command nano list.txt Depending on the type of work you do, you may need a more powerful text editor than Nano.

7. $touch
Used to create files touch list2.txt

8. $ rm
rm [path] removes (deletes) a file.
Eg. rm list2.txt (rm -r remove directory and all it contents)
The shell does not have a trash bin: once something is deleted, it’s really gone.

9. $ mv
mv [old] [new] moves or renames a file or directory.
Eg. mv list.txt buy.txt

10. $ cp
Copy file cp [old] [new] copies a file.
eg cp list.txt fish.txt

11. Wild cards

matches zero or more characters in a filename, so *.txt matches all files ending in .txt. Eg ls *.txt

? matches any single character in a filename, so ?.txt matches a.txt but not any.txt.
Eg ls list?.txt

12. $ wc
Word counts command: it counts the number of lines, words, and characters in files

eg wc list.txt

13. $ cat
it prints the contents of files one after another.
eg cat list.txt

14. $ sort

command to sort the contents of a file (sort -n for numbers)
Eg sort lists

15. $ echo
The echo command prints text
Eg echo hello

16. $ echo hello > list.txt
command > [file] redirects a command’s output to a file (overwriting any existing content).

17. $ echo hello >> list.txt
command >> [file] appends a command’s output to a file.

18. $ head
head displays the first 10 lines of its input.
Eg head -n 3 animals.csv > animals-subset.csv

19. $ tail
displays the last 10 lines of its input.
Eg tail -n 3 animals.csv > animals-subset.csv

20. $ [first] | [second]
pipeline: the output of the first command is used as the input to the second.

where can i learn more about shell?

learn more about shell