DEV Community: Jason Charney

Increments are Interesting

Jason Charney — Mon, 13 Feb 2023 21:39:00 +0000

The Increment operators in C, C++, Java, JavaScript, and other languages are interesting.

In short, i++ or ++i is equivalent to using i += 1 or i = i + 1...but there is a twist. The increment operator, depending on where you put it and more importantly if it is a pre-increment or a post-increment operator can execute before or after something else is done.

Let's start with something basic.

You've probably seen this example on the MDN website.

let x = 3;
const y = x++;

console.log(`x:${x}, y:${y}`);
// Expected output: "x:4, y:3"

let a = 3;
const b = ++a;

console.log(`a:${a}, b:${b}`);
// Expected output: "a:4, b:4"

As a post-increment, x increases to 4 after it is assigned to y. As a pre-increment, a increased to 4 before it is assigned to b.

Last week, I was writing a sorting algorithm for an assignment and noticed the code I was looking for had quite a bit of increment and decrement operators alone on their own line. So I was wondering how I could use them when calling an array at a specific position.

Let's assume we have an array with four elements. Even though the first index is at 0, let's have i and j assigned to 1.

let arr = [4, 8, 12, 16];

let i = 1;
let c = arr[i];   // arr[1]
let d = arr[++i]; // arr[2]
let e = arr[i];   // arr[2]
console.log(`c:${c}, d:${d}, e:${e}`);
// Expected output: "c:8, d:12, e:12"

let j = 1;
let f = arr[j];   // arr[1]
let g = arr[j++]; // arr[1]
let h = arr[j];   // arr[2]
console.log(`f:${f}, g:${g}, h:${h}`);
// Expected output: "f:8, g:8, h:12"

We can assume that in the above code that c and f are the "before", d and g are the "during", and e and h are the after.

As a pre-increment, the "during" is the same as the "after". As a post-increment, the "during" is the same as the "before".

What this means is that pre-increments are done before an element is called or used, and that post-increments are done after an element is called or used.

We would see the same behavior with decrement operators only with decreasing values rather than increasing values.

Let's see what happens when we use them in different types of loop structures.

Let's get the for loops out of the way. The outcome for these structures is quite predictable as the increment step and testing appear to happen after the contents inside the loop have been executed.

for(let a = 0; a < 5; ++a){
 console.log(`For Loop A: ${a}`);
}

/*
> "For Loop A: 0"
> "For Loop A: 1"
> "For Loop A: 2"
> "For Loop A: 3"
> "For Loop A: 4"
*/

for(let b = 0; b < 5; b++){
 console.log(`For Loop B: ${b}`);
}

/*
> "For Loop B: 0"
> "For Loop B: 1"
> "For Loop B: 2"
> "For Loop B: 3"
> "For Loop B: 4"
*/

Pretty boring, amirite? This is why in a lot of computer science books, there's more of an emphasis on while and do-while because a while loop tests before it executes an iteration (step) and a do-while loop tests after it executes an iteration.

In the table below, we will demonstrate sixteen examples. The first and second columns will show an example of the while loop. The third and fourth columns will show examples of a do-while loop. The first and third columns are the source code and the second and fourth columns are the output.

Rows A through D will show examples using pre-increments while rows E through H will show examples using post-increments. In Rows A and E, the increment will be done in the test (which may be before or after the code block); In rows B and F, the increment will be before the output statement; In Rows C and G, during the output; In Rows D and H, after the output statement. Let's see what patterns we can learn from these tests.

Row	Code	Output	Code	Output
A	let a = 0; while(++a < 5){ console.log(`While Loop A: ${a}`); }	> "While Loop A: 1" > "While Loop A: 2" > "While Loop A: 3" > "While Loop A: 4"	let a = 0; do{ console.log(`Do-While Loop A: ${a}`); }while(++a < 5);	> "Do-While Loop A: 0" > "Do-While Loop A: 1" > "Do-While Loop A: 2" > "Do-While Loop A: 3" > "Do-While Loop A: 4"
B	let b = 0; while(b < 5){ ++b; console.log(`While Loop B: ${b}`); }	> "While Loop B: 1" > "While Loop B: 2" > "While Loop B: 3" > "While Loop B: 4" > "While Loop B: 5"	let b = 0; do{ ++b; console.log(`Do-While Loop B: ${b}`); }while(b < 5);	> "Do-While Loop B: 1" > "Do-While Loop B: 2" > "Do-While Loop B: 3" > "Do-While Loop B: 4" > "Do-While Loop B: 5"
C	let c = 0; while(c < 5){ console.log(`While Loop C: ${++c}`); }	> "While Loop C: 1" > "While Loop C: 2" > "While Loop C: 3" > "While Loop C: 4" > "While Loop C: 5"	let c = 0; do{ console.log(`Do-While Loop C: ${++c}`); }while(c < 5);	> "Do-While Loop C: 1" > "Do-While Loop C: 2" > "Do-While Loop C: 3" > "Do-While Loop C: 4" > "Do-While Loop C: 5"
D	let d = 0; while(d < 5){ console.log(`While Loop D: ${d}`); ++d; }	> "While Loop D: 0" > "While Loop D: 1" > "While Loop D: 2" > "While Loop D: 3" > "While Loop D: 4"	let d = 0; do{ console.log(`Do-While Loop D: ${d}`); ++d; }while(d < 5);	> "Do-While Loop D: 0" > "Do-While Loop D: 1" > "Do-While Loop D: 2" > "Do-While Loop D: 3" > "Do-While Loop D: 4"
E	let e = 0; while(e++ < 5){ console.log(`While Loop E: ${e}`); }	> "While Loop E: 1" > "While Loop E: 2" > "While Loop E: 3" > "While Loop E: 4" > "While Loop E: 5"	let e = 0; do{ console.log(`Do-While Loop E: ${e}`); }while(e++ < 5);	> "Do-While Loop E: 0" > "Do-While Loop E: 1" > "Do-While Loop E: 2" > "Do-While Loop E: 3" > "Do-While Loop E: 4" > "Do-While Loop E: 5"
F	let f = 0; while(f < 5){ f++ console.log(`While Loop F: ${f}`); }	> "While Loop F: 1" > "While Loop F: 2" > "While Loop F: 3" > "While Loop F: 4" > "While Loop F: 5"	let f = 0; do{ f++ console.log(`Do-While Loop F: ${f}`); }while(f < 5);	> "Do-While Loop F: 1" > "Do-While Loop F: 2" > "Do-While Loop F: 3" > "Do-While Loop F: 4" > "Do-While Loop F: 5"
G	let g = 0; while(g < 5){ console.log(`While Loop G: ${g++}`); }	> "While Loop G: 0" > "While Loop G: 1" > "While Loop G: 2" > "While Loop G: 3" > "While Loop G: 4"	let g = 0; do{ console.log(`Do-While Loop G: ${g++}`); }while(g < 5);	> "Do-While Loop G: 0" > "Do-While Loop G: 1" > "Do-While Loop G: 2" > "Do-While Loop G: 3" > "Do-While Loop G: 4"
H	let h = 0; while(h < 5){ console.log(`While Loop H: ${h}`); h++; }	> "While Loop H: 0" > "While Loop H: 1" > "While Loop H: 2" > "While Loop H: 3" > "While Loop H: 4"	let h = 0; do{ console.log(`Do-While Loop H: ${h}`); h++; }while(h < 5);	> "Do-While Loop H: 0" > "Do-While Loop H: 1" > "Do-While Loop H: 2" > "Do-While Loop H: 3" > "Do-While Loop H: 4"

The output of While Loops B, C, E, and F are all the same. While Loops B, C, and F all have the same output as the Do-While Counterparts. The third line in Do-While Loop C is equivalent to combining lines 2 and 3 in Do-While Loop B. Do-While Loop F's output looks like B and C because of the increment happening before the output statement. While Loop C is probably the best implementation of this loop.

The output of While Loops D, G, and H are all the same and their outputs are the same as their Do-while counterparts.
The third line in While Loop G is equivalent to the third and fourth lines in While H.

Let's look at While Loop A. Here, pre-increment happens before testing, so no a = 0 output. By comparison, While Loop E includes e = 5 just like loops B, C, and F. It's probably not the best idea to do an increment in a test before execution.

The output of Do-While Loops A, D, G, and H are all the same. In Do-While Loops A and D, the increment happens after the output. The output of Do-While Loops G and H are equivalent, and we've described how a couple of paragraphs ago.

Do-While Loop A is probably the best version of this loop because pre-increment and testing happen at the end of execution in one combined statement.

The output of Do-While Loops B, C, and F are all the same. Do-While Loop C is probably the best implementation of this loop.

Let's look at Do-While Loop E. Here we have a post-increment which makes this loop run six times (the most times), which could be described as the behavior opposite of While Loop A which runs four times (the least times). Would this output be the same if we used a less-than-or-equal-to operator instead of a less-than operator? We could probably explore that another time.

The purpose of today's post was to find more efficient ways to write code by finding optimal patterns when using a loop.

I'm thinking in the future to make better use of do-while loops with counters, but with arrays, I would probably use something a lot more like While Loop G or Do-While Loop G.

Concatenation of Strings and Arrays in JavaScript

Jason Charney — Mon, 19 Dec 2022 20:01:25 +0000

In this part I will discuss using the .concat() method which is used by Strings and Arrays. Initially, I wanted this article to include discussion of the .slice() function, but things got a little long.

Instead, there will be a short dive into the .flat() method for Arrays near the end of this article.

We'll also take a look at rest and spread parameters.

What is Concatenation?

Concatenation, or concat(), is pretty straightforward. For strings, you use it to join two or more strings together to form a single string. For arrays, you use it to join two or more arrays to form a single array.

The syntax for both methods is quite similar.

str.concat(...strings);
arr.concat(...arrays);

In this case, the three leading dots represent rest parameters. Later in this article we will use spread parameters which are similar.

Rest Parameters vs Spread Parameters

In case that last paragraph wasn't clear, let's talk about how rest and spread parameters are used.

Rest parameters are used when you define a method. Say you have a list of parameters. The rest parameter groups those parameters into an array that use can use.

Spread parameters are used when you use a method. Say you have an array variable, but you want each item to fill in a variable slot. The spread parameter will take the elements out of the array and treat them individually.

We'll speak of this again later in this article.

Concatenating strings

let str;
const str0 = "";
const str1 = "Garnet";
const str2 = "Amethyst";
const str3 = "Pearl";
str = str0.concat(str1,str2,str3);
// Returns: "GarnetAmethystPearl"
// str: "GarnetAmethystPearl"

What a mess that is, isn't it?! See why I like to use a .join() more than using .concat() like this? We had to add another variable str0, because in order to concatenate, you need to have an existing string to concatenate with.

We could have also done this.

str = "".concat("Garnet","Amethyst","Pearl");
// Returns: "GarnetAmethystPearl"
// str: "GarnetAmethystPearl"

But we would still have these strings crashing into each other because concatenation joins things directly. You can resolve this by either adding a space to the end of the string, or by adding space elements.

str = "".concat("Garnet"," ","Amethyst"," ","Perl");
// Returns: "Garnet Amethyst Perl"
// str: "Garnet Amethyst Perl"

But there is some advantage, to putting all of these items in an array, and then joining them together with a single space like in our first example.

On the String class has the advantage of using the + and += operators to join strings together, but because there is no separator, they all just smash together.

str = "Garnet" + ", " + "Amethyst" + ", and" + "Pearl";
// Returns: "Garnet, Amethyst, and Pearl"
// str    : "Garnet, Amethyst, and Pearl"
str += "--AND STEVEN!"; 
// Returns: "Garnet, Amethyst, and Pearl--AND STEVEN!"
// str    : "Garnet, Amethyst, and Pearl--AND STEVEN!"

Notice, we don't have to start with an empty string (""). We should initialize a string with an empty string if we plan on adding stuff to the string with the addition-assignment operator.

We could have also write the example with the empty string on the left side of the .concat() function with "Garnet", but not have "Garnet" on the right side.

str = "Garnet".concat(" ","Amethyst"," ","Perl");
// Returns: "Garnet Amethyst Perl"
// str: "Garnet Amethyst Perl"

But see the advantage of using the operators instead of the .concat().

Concatenating Arrays

Sadly, the option to use operators is not available for Arrays. Concatenating arrays is only available with the .concat() method. Let's show what happens when you try to use the + operator between our objects, then show the right way to do array concatenation.

const nl_east    = ["ATL","NYM","PHI","MIA","WAS"];
const nl_central = ["STL","MIL","CHC","CIN","PIT"];
const nl_west    = ["LAD","SD","SF","ARI","COL"];
let nl;

nl = nl_east + nl_central + nl_west;
// Returns: "ATL,NYM,PHI,MIA,WASSTL,MIL,CHC,CIN,PITLAD,SD,SF,ARI,COL"
// nl: "ATL,NYM,PHI,MIA,WASSTL,MIL,CHC,CIN,PITLAD,SD,SF,ARI,COL"

Yikes! Everything was converted to strings, and the first and last entries of each string concatenated together with no separator between them.

Let's try it this time with .concat(). Notice, instead of starting with an empty string, I start with an empty array ([]).

nl = [].concat(nl_east,nl_central,nl_west);
// Returns: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]
// nl: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]

Like with strings, we could have put one of the elements on one side and done this operation, but there is something more aesthetically satisfying to put everything on one side.

nl = nl_east.concat(nl_central,nl_west);
// Returns: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]
// nl: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]

What if we could just concatenate these arrays together in another array? Would that work? Yes...and no.

nl = [nl_east,nl_central,nl_west];
/*
Returns:
[
  [ 'ATL', 'NYM', 'PHI', 'MIA', 'WAS' ],
  [ 'STL', 'MIL', 'CHC', 'CIN', 'PIT' ],
  [ 'LAD', 'SD', 'SF', 'ARI', 'COL' ]
]
nl:
[
  [ 'ATL', 'NYM', 'PHI', 'MIA', 'WAS' ],
  [ 'STL', 'MIL', 'CHC', 'CIN', 'PIT' ],
  [ 'LAD', 'SD', 'SF', 'ARI', 'COL' ]
]
*/

We get an array of arrays, or a "matrix". However, there is a way to concatenate arrays without using the .concat() method. We can use a spread operator (...). The spread operator will extract the elements of the array. it would be like inserting the elements (in this case strings) into an array.

nl = [...nl_east,...nl_central,...nl_west];
// Returns: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]
// nl: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]

Think of the spread operator as like cracking a peanut out of its shell. In this case, with our [...nl_east,...nl_central,...nl_west] example, we take the "peanuts" out of the nl_east, nl_central, and nl_west shells, then put them in an even bigger shell.

Of course, a matrix is still OK. We could flatten the matrix with the .flat() function.

nl = [nl_east,nl_central,nl_west].flat();
// Returns: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]
// nl: ['ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD', 'SF',  'ARI', 'COL' ]

Note that the .flat() function will only flatten an embedded array by one level. If you have arrays in arrays in arrays, you will still have an array or arrays if you use it. (The JavaScript guys should have added an option such that if you set the depth to zero, it would flatten all arrays, but that's for another article.)

A little bit more about `.flat()` Array

Let's make an array of arrays of arrays with all the Major League Baseball teams this time.

let mlb = [
  [
    [ 'NYY', 'TOR', 'TB', 'BAL', 'BOS' ],
    [ 'CLE', 'CWS', 'MIN', 'DET', 'KC' ],
    [ 'HOU', 'SEA', 'LAA', 'TEX', 'OAK' ]
  ],
  [
    [ 'ATL', 'NYM', 'PHI', 'MIA', 'WAS' ],
    [ 'STL', 'MIL', 'CHC', 'CIN', 'PIT' ],
    [ 'LAD', 'SD', 'SF', 'ARI', 'COL' ]
  ]
]

If we use mlb.flat(), the teams that were grouped by their league on the first level and grouped by their division on the second level are now all grouped by their division on the first level.

mlb.flat()
/*
[
  [ 'NYY', 'TOR', 'TB', 'BAL', 'BOS' ],
  [ 'CLE', 'CWS', 'MIN', 'DET', 'KC' ],
  [ 'HOU', 'SEA', 'LAA', 'TEX', 'OAK' ],
  [ 'ATL', 'NYM', 'PHI', 'MIA', 'WAS' ],
  [ 'STL', 'MIL', 'CHC', 'CIN', 'PIT' ],
  [ 'LAD', 'SD', 'SF', 'ARI', 'COL' ]
]
*/

If we increase the depth to two, now all the teams are in the same array.

mlb.flat(2)
/*
['NYY', 'TOR', 'TB',  'BAL', 'BOS', 'CLE', 'CWS', 'MIN', 'DET', 'KC', 'HOU', 'SEA', 'LAA', 'TEX', 'OAK', 'ATL', 'NYM', 'PHI', 'MIA', 'WAS', 'STL', 'MIL', 'CHC', 'CIN', 'PIT', 'LAD', 'SD',  'SF',  'ARI', 'COL']
8?

Using mlb.flat(0) has the same effect as just stating mlb and using mlb.flat(3) has the same effect as mlb.flat(2). It probably would have made more sense that once we got to mlb.flat(3), it would have been like using .join() to convert it all to a string. But it doesn't work like that.

Concatenating Both

So what happens if we try to concatenate strings and arrays?

It's a bit weird, but it is possible.

If you add a string to an array, that string will be added to the array.
If you add an array to a string, the array will be converted to a string, but remember no spaces are added to separate the string from the array entries.

let gems = ["Garnet","Amethyst","Pearl];
let steven = "Steven";
gems.concat(steven);
// Returns: [ 'Garnet', 'Amethyst', 'Pearl', 'Steven' ]
// gems : ["Garnet","Amethyst","Pearl]
steven.concat(gems);
// 'StevenGarnet,Amethyst,Pearl'
// steven : "Steven"

In future examples will try to demonstrate this with other data types like numbers, booleans, objects, and more.

The next part of this series will discuss the .slice() method.

Split and Join: The Dichotomy of Strings and Arrays

Jason Charney — Mon, 19 Dec 2022 19:38:13 +0000

I was working another project this week and I wanted to talk about the .splice() function in JavaScript...but then I started down a rabbit hole of having to write about other things, because there's some other things you should probably understand before using .splice().

For starters, let's talk about the relationship between Strings and Arrays in JavaScript. This will likely be a short series of articles. It might have been written before by someone else, but I'd like to give my own interpretation.

Strings and Arrays are like Yin and Yang. You use .split() to split an string into an array. You use .join() to join arrays into strings.

If you can exercise this dichotomy of two fundamental JavaScript types, you can understand the relationship between strings and array.

String `split()`, Array `join()`

Whenever there is an array of strings requested, it is probably better to simply use .split() rather than tediously adding every quotation mark and comma.

In these examples, there will be two comments. One showing the return value, and one showing the value of arr, str, or other variables. This will be important to note throughout the examples

let arr;
// Returns 'undefined'
arr = "Whoever controls the splice controls the universe".split(" ");
// Returns: ["Whoever", "controls", "the", "splice", "controls the", "universe"]
// arr:     ["Whoever", "controls", "the", "splice", "controls the", "universe"]

Conversely, what happens when we take that array and put it back together?

let str;
// Returns 'undefined'
str = ["Whoever", "controls", "the", "splice", "controls the", "universe"].join(" ");
// Returns: "Whoever controls the splice controls the universe"
// str = "Whoever controls the splice controls the universe"

You may have noticed that when we declare a variable. If we do our declarations on the same line as the assignment, the undefined is returned, but arr and str have value.

let str = ["Whoever", "controls", "the", "splice", "controls the", "universe"].join(" ");
// Returns: undefined
// str = "Whoever controls the splice controls the universe"

For clarity, I will declare variables separate when we can in this sprint of short articles.

In the next article, I will talk about concatenation.

ArchWSL++ brings Arch Linux to WSL and more

Jason Charney — Tue, 11 Oct 2022 18:44:11 +0000

Consider this the post that supersedes my previous post! ArchWSL++ brings ArchLinux to Windows using Windows Subshell for Linux (WSL), but also installs all the stuff that makes WSL look spectacular.

ArchWSL++ builds on top of what ArchWSL offers by including visual "unixporn"-like features that frankly should be an option when you install WSL. Plus, I've made some suggestions as to some terminal toys that are fun little features that are sure to either impress your friends or make the jealous.

But there is no need for envy. This Github repo (which will likely be turned into pages on my Github site soon since it is more documentation than download) offers some step-by-step instructions to make your Windows Terminal awesome. The only thing better would be running a Linux Machine with these features, which sadly my coding boot camp wouldn't let me use my Linux box despite the fact that EVERYTHING can be done on Linux, except for running Slack in an app which probably why we can't use Linux despite it still being possible to use Slack in a web browser. (FIX YOUR S$#&, SALESFORCE!)

At any rate, I'm going to keep this post short today. Any future updates regarding ArchWSL++ will be pushed to the repo on my Github.

Have fun with this!

How to install Arch Linux for WSL

Jason Charney — Thu, 06 Oct 2022 21:06:10 +0000

UPDATE! 10/11/2022 This post has been deprecated. See this post which supersedes it.

I am currently going through another coding camp right now.

Although this environment is not part of the course, it is of benefit to anyone looking for a smarter, more dynamic environment for developing on Windows using Linux.

How I set up Arch Linux for WSL

Windows Subsystem for Linux (WSL) is a way to use Linux on Windows without re-partitioning your hard drive or using a Virtual Machine like Virtual Box.

You need to install something called Hyper-V if you want to use Windows Subsystem for Linux (WSL). It can NOT be installed with Window 10 Home, but should work with Windows 11 Home. This will require a reboot.

Right click on the Windows menu and select "Powershell (Administrative)". If you are using Windows 11, open "Windows Terminal (Administrative)". We will enable Hyper-V in the command line rather than going through a bunch of other Windows like I had to do.

Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V -All

You probably should enable Hyper-V with the Deployment Image Servicing and Management tool (DISM) to help configure windows and Windows images. This will allow DISM to enable Windows features while the operating system is running.

DISM /Online /Enable-Feature /All /FeatureName:Microsoft-Hyper-V

When the installation is completed, reboot and come back here.

From the Microsoft Store App, you should install the Windows Terminal application and also Visual Studio Code. If you have Windows 11, you should already have Windows Terminal.

Get a Windows Installer

You should install either Chocolatey or Scoop so you can download some stuff in the command line, especially the NerdFonts that are required for Powerline, Powerlevel10k, and VS Code. These fonts have extra characters that can be used in the Windows Terminal.

I recommend Scoop (scoop) over Chocolatey (choco) because it is better organized. Packages are grouped into "Buckets".

Installing Scoop

Set-ExecutionPolicy ByPass -Scope Process -Force
$env:SCOOP='C:\Applications\Scoop'
$env:SCOOP_GLOBAL='C:\GlobalScoopApps'
[Environment]::SetEnvironmentVariable('SCOOP_GLOBAL', $env:SCOOP_GLOBAL, 'Machine')
iex "& {$(irm get.scoop.sh)} -RunAsAdmin"

Note: we can't use irm get.scoop.sh | iex, not even in an Administrative PowerShell! (This is why PowerShell sucks!)

If iex "& {$(irm get.scoop.sh)} -RunAsAdmin" doesn't work, try running irm get.scoop.sh -outfile 'install.ps1' ; .\install.ps1 -RunAsAdmin. This will create install.ps1 locally, which you will need to del install.ps1 later.

We need to set the execution policy to Bypass. We could have also used Set-ExecutionPolicy RemoteSigned -Scope CurrentUser which would have set the execution policy to RemoteSigned. You can see what execution policy is used by running Get-ExecutionPolicy.

We should get scoop to work. Let's update it.

scoop update

Get the NerdFonts

Because the entire set of NerdFonts is about a couple of gigabytes, you should just get the essential fonts.

I recommend installing these fonts from NerdFonts.

Meslo
FiraCode
FiraMono
Hack

We first need to add the nerd-fonts bucket.

scoop bucket add nerd-fonts

Next install the font packages

scoop install Meslo-NF Meslo-NF-Mono Hack-NF Hack-NF-Mono FiraCode-NF FiraCode-NF-Mono FiraMono-NF FiraMono-NF-Mono

You should be able to set your Windows terminal to use one of the fonts we installed by going to the settings. A lot of folks are recommending using Meslo.

Installing ArchWSL

We need to get ArchWSL from the extras bucket. Before we run WSL for the first time, we need to set it's version to version 2. This will use WSL2, which is recommended. We can view what version our Linux distribution is using later with wsl -l -v.

wsl --set-version 2
scoop bucket add extras
scoop install archwsl

You might have seen a message at the end saying "Even when you are logging in as 'root', some operations (like service command) require Windows administrator privileges". This is nothing to worry about. We're going to do something in a little bit so we don't have to log in as root directly.

Note: To view what Linux distributions are available, we can use wsl -l. To view version information, we can use wsl -v. Combining -l with -v, we can see what version of WSL we are using and what Linux distribution is being used with wsl -l -v.

We are now ready to take care of some basic tasks to get Arch Linux up and running.

Start by running the Arch.exe program.

Arch.exe

First lets set our root password with passwd, you could use your windows password, but a different password would be more secure.

NOTE: Bash is set up to show the current username of the user that is logged in, and the machine that you are logged into. This is called the prompt. Later we'll do some stuff to make it look pretty. I would recommend giving your computer a name instead of "Dell-XPS_13-bunch_of_numbers". You can do that in your Windows setting. For now well, call our PC "Crystal". This will show up if we run the command uname -n.
Our prompt in Bash will also use # if root (the administrator) is logged in and $ if a regular user is logged in.

[root@crystal]# passwd

Once you have set up your root password, let's create our regular user and give them permission to use the sudo command that temporarily gives them the power to run root command with the sudo prefix.

[root@crystal]# echo "%wheel ALL=(ALL) ALL" > /etc/sudoers.d/wheel      # This creates the sudoers file
[root@crystal]# useradd -m -G wheel -s /bin/bash jrcharney          # Create a new users. I will set mine for jrcharney
[root@crystal]# passwd jrcharney                        # Set the password for the new user
[root@crystal]# exit                                # Return to powershell

We need to return to the Powershell for a moment to set the default user.

Arch.exe config --default-user jrcharney                    # Note: Use your username not mine!

Note: If the above command doesn't work, try restarting the LxssManager in an Administrative Powershell/Windows Terminal.
Do this by running these two command: net stop lxssmanager then net start lxssmanager
Contrary to what the ArchWSL Setup documentation says, you can't use && in Powershell. But that's not going to matter once we get this running.
If that doesn't work, try restarting the computer, but that should only be a last resort.

Once we have our default user, we can launch Arch again. Thanks to how ArchWSL is set up, Arch will be a option in our dropdown menu on the Windows Terminal, but we can't set it as the default option. That will still need to be PowerShell because Microsoft.

But that's no big deal, because the next time we start our Linux terminal, you should see something like this as your user prompt.

[jrcharney@crystal]$

Congratulations! You now have LINUX installed on Window! This next part will add all those rad toys to it to make it look awesome and a lot less scary.

Set up Arch Linux

If this were actually Arch Linux, we could have used a script called arch_install to knock out some of this stuff. Since we don't have it, we got to do it manually.

Here's just the quick summary of everything I ran to get mine set up. The first few packages we install will be the ArchLinux keyring, the base development tools, Git, another package manager called yay that will let us use the ArchLinux User Repo (AUR), and short list of other cool stuff.

Note: I'm not going to write the prompt anymore. Almost everything will be done as your default user, even the sudo commands.

sudo pacman-key --init
sudo pacman-key --populate
sudo pacman -Syu
sudo pacman -S archlinux-keyring                                            # Note: ArchWSL says this is optional, but THIS PACKAGE IS MANDITORY! It should be the first one installed.
sudo pacman -S --needed base-devel git                                      # When you install the `base-devel` package for ArchWSL, `fakeroot` and `fakeroot-tcp` are in conflict. When asked if you want to replace `fakeroot-tcp` with `fakeroot` SAY NO!
sudo git clone https://aur.archlinux.org/yay.git                            # This will install `yay` which will allow you access to the ArchLinux User Repository.
cd yay                                                                      # Go to the yay directory  (TODO: Could I have put this in a Downloads directory?)
makepkg -si                                                                 # Make the `yay` package, this will also install the Go Language (`golang`) that `yay` needs to do stuff.
sudo pacman -S openssh                                                      # Install OpenSSH so we can use SSH.
sudo pacman -S github-cli                                                   # Install this so we can use `gh` to do github command. (TODO: Is there something similar for gitlab?)
sudo pacman -S lolcat                                                       # Install `lolcat` (colorful cat), this will also install the Ruby programming language that it depends on.
sudo pacman -S bat                                                          # `bat` is like `cat`, but it looks better.
sudo pacman -S bat-extras fzf clang llvm rust                               # Some important tools I'll talk about them later.
sudo pacman -S python-pip                                                   # Python needs pip to install some packages
sudo pacman -S lm_sensors psutils python-psutil neofetch bashtop htop       # Install these to show system information and to manage processes in a more user-friendly way
sudo pacman -S figlet cowsay fortune-mod cmatrix nyancat                    # Command line toys, some of them are important that they install some depedencies you'll want to have around.
sudo pacman -S ponysay                                                      # It's like cowsay, only 20% cooler.
yay -S bash-pipes                                                           # One more toy (`pipes.sh`), because the Internet is a Series of Tubes. (Note You can't use `sudo` with `yay` upfront. Yay will ask you for your sudo password later.)
sudo pacman -S imagemagick                                                  # Manipulate images from the command line. You probably won't use it a whole lot, but there's some cool stuff that is important
mkdir bin                                                                   # Add this directory. It should be added to your `$PATH`. You can use this directory to launch scripts that you write to do tasks
mkdir Projects Downloads Documents Sandbox Music Pictures Videos            # Just some placeholder directories. I should really make them softlinks to their Windows counterpart later.
curl wttr.in                                                                # Check to see if we have curl installed by checking the weather!
sudo pacman -S zsh                                                          # Install Zsh
zsh --version                                                               # Show the version of Zsh. (We're still in Bash, but that will change shortly.)
chsh -l                                                                     # Show a list of shells we can change to.  (You can also see this in `/etc/shells`)

OK, we should be ready to do everything in Zsh from now on.

A few things to note

You'll be asked some questions when you launch Zsh the first time when you run Oh-My-Zsh. I forget what I said, most of these aesthetic. There's probably a tutorial about it on YouTube.
You may be asked some questions to get Powerlevel10K working (at least for Oh-My-Zsh), if not, run p10k.
If things don't have color when you run pacman -Ss, go into the /etc/pacman.conf file and uncomment the line that says Color. Visually, this helps out tremendously.
We could have changed the shell to Zsh using chsh -s $(which zsh), but there was a problem getting that done. Fortunately we can do this with Oh-My-Zsh

sh -c "$(curl -fsSL http://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"     # Install Oh-My-Zsh.  (I should have used `yay -S oh-my-zsh-git` but this works just as well.)  (If it asks if you want to change the default shell to Zsh, say yes!)
yay -S --noconfirm zsh-theme-powerlevel10k-git                                          # Install the powerlevel10k them for zsh.
echo 'source /usr/share/zsh-theme-powerlevel10k/powerlevel10k.zsh-theme' >> ~/.zshrc    # Use the Powerlevel10K theme in Zsh. (You could use it in Bash too, but I'm not going to do that.)
exec zsh                                                                                # Restart zsh
p10k configure                                                                          # Configure the Powerlevel10k prompt.
sudo pacman -S tmux                                                                     # Install the terminal multiplexer. (We'll have some basic stuff set up in `~/.tmux.conf`)
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm                       # Install the TMUX plugin manager.
sudo pacman -S powerline                                                                # Install powerline. The command to enable it for tmux should be in `~/.tmux.conf`.
sudo pacman -S lsd                                                                      # Use lsd (not that LSD! This one make the ls command look cool.) (I added commands to ~/.bash_aliases to use it.)
sudo pacman -S jq                                                                       # Command-line JSON processor. This will be useful later. (There's also `hq` and `yq`, but I haven't tried those yet.)
sudo pacman -S neovim                                                                   # Neovim is something I'm adding. It's basically a text editor based on Vim, but all the plugins are written in Lua. This should also install Lua.
sudo pacman -S python-neovim                                                            # Python 3 plugin support for Neovim
sudo pacman -S zsh-autosuggestions                                                      # Enable auto suggestions in Zsh
sudo pacman -S zsh-syntax-highlighting                                                  # Enable syntax highlighting. You will need to add a line to to bottom of your `~/.zshrc` file.

To Activate zsh-syntax-highlighting, add the following line to the end of ~/.zshrc

source /usr/share/zsh/plugins/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh

My Github repo should contain

~/.bash_aliases
~/.tmux.conf
~/.bashrc
~/.zshrc
~/.p10k.zsh

You should also run VS Code from this environment for the first time such that both applications become familiar with each other.

code .          # That is "code" space "period"

This will install what WSL and VS Code needs to work with each other.

TODO: How do I set WSL/Arch as the default terminal for VS Code?

Anything else, I'll probably tack on here later. I do have some dotfiles you can download to run some other tasks.

Congratulations! You're ready to code like a pro!

Taskwarrior (optional)

There's one thing I would suggest doing if you are doing software development: Install taskwarrior. This is useful because you can write down tasks for things you can do while working on project. Personally, I'm more of a Trello person because Kanban is awesome and can be used for more than just computer development. I used it to help me list all the things I need to do when I moved into my apartment a few months ago. It's that versatile.

You could also use something like Notion, which as a Markdown editor, but in terms of Markdown editors, I prefer Typora ($15) because it supports Mermaid where you can generate UML diagrams and other charts and uses MathJax for LaTeX support. You can also embed HTML and SVG and generate a preview of what the code looks like.

To install Taskwarrior, install the task package.

sudo pacman -S task

We can also install a couple of terminal interface programs such as taskwarrior-tui and vit. I will add that.

sudo pacman -S taskwarrior vit

There is also a command-line time tracking app called timewarrior (timew) that integrate with task.

sudo pacman -S timew

Because we installed powerlevel10k earlier, if we add a task, an item should appear showing how many tasks you have on the right side. If it doesn't show up, you may need to restart ArchWSL or check ~/.p10k.zsh to make sure that the segment is enabled.
In fact, Powerlevel10k has many segments that can be useful. You should enable the ones you know that you will need as enabling all of them will be taxing to your system resources.

The first time you run task you will be told that a configuration file could not be found and asked if you would like to create a sample one. Say yes to it.
Similarly, if you run timew the first time, it will also ask of you would like to create a new database file. Also say yest to that.

I wanted to install Taskell (taskell), which is a command-line Kanban board written in Haskell, but for some reason, the taskell package would not download. Which is unfortunate considering it could be integrated with Trello and Github and it used Markdown. It is quite unfortunate and will need to be brough up at a later date.

So, this is the part where the Coding Boot Camp picks up. Good luck!

Web Developers are NOT Social Media Managers!

Jason Charney — Thu, 02 Dec 2021 17:08:26 +0000

Hello, are you looking to hire someone to manage your Facebook, Twitter, Instagram, SnapChat, Tumblr, Wordpress Blog, Squarespace Site, Pinterest Board, Reddit Subreddit, Twitch, YouTube, or TikTok?

Then I am NOT that guy.

Social media is a great way to get the word out about your business. These profiles are often easy to set up and require the user to manage their content.

But is this web development? No.

Almost all of it is designed to be usable to the most tech-illiterate person.

Can you hire a web developer to set these things up? Yes.

Should you use a web developer to continually manage your social media without providing any content? No.

I bring this up because in a lot of these job listings looking for a Web Developer, the list all these languages and technology skills and somehow sneak in something like "Manage Wordpress" in the process and most of those other skills aren't used.

And it sucks having to manage a website where all the coding is done already.

So when you post a job listing, familiarize yourself with the skills that are needed. HTML, CSS, and JavaScript aren't that hard. If you need somebody to use these things to build a website for you, consider a web developer.

If you are more interested in creating content, consider a social media manager.

But don't normalize merging the two occupations together simply because they both involve the internet as one is a gateway towards being a software developer and the other towards being a copywriter.

Be clear in what you want. Don't try to mash ten different jobs together that should be done by several people and making it sound like you are looking for just one person to do everything.

Also, use a salary calculator. This isn't a $20/hour job or something that is "paid in experience". We're not doing this for free or for favors.

Another problem is the reliance of applicant tracking systems (ATS). These programs are supposed to making finding applicants easier, but they actually make it much harder.

Most ATS's rely on Keyword searches, which if you add more keywords the ATS will match more applicants with those keywords.

However, if you've ever used a search engine and added more keywords to your search, you don't get more search results, you get fewer. This is because, a search engine will try to match every word you entered first then try to match most of the word you entered.

You applicant search needs to be limited by a few things:

The location of where you want to find applicants (generally near your company).
The job title you are looking for or at least two to four skills that job requires.
Avoiding small common words like articles of speech ("a", "an", "the"), prepositions ("of", "for", "with", "by", "etc".), conjunctions ("and", "or", "but", etc.), and abbreviations (e.g. Using "St." instead of "Saint"). Chances are, the ATS might now have the logic programmed into it to ignore common words or match words that are part of names, places, skills, or job titles.

The problem many employers have is that they plug in all these keywords they want to match, but they are wonder why they can't find anyone of.

I've also noticed some employers have a hard time following instructions when it comes to filling out form fields. They put the locations in the job title. They input the same job offer several different times in different ways. If you are doing this, you aren't posting a job offer, you are spamming the search results. Job seekers will skip offer your job offer.

There's no way job seekers should be getting "hundreds of resumes per day" when I don't even get "hundreds of job offers" per day. I mean, come on! I'm looking for work in the Saint Louis Area. Why the heck am I still getting job offers for places I can't afford to move to from people whose names' I can't spell and who don't understand how distance works.

That's been my whole problem with finding work.

In short, learn how to write job offers, stop relying on applicant tracking systems to read resumes for you, and read the resumes!

Multiple Resistors in Parallel

Jason Charney — Thu, 21 Oct 2021 01:51:11 +0000

In my previous post, I shared how to solve an parallel resistor equation with two resistors in parallel.

\begin{aligned} \frac{1}{R_{\Sigma 2}} &= \frac{1}{R_1} + \frac{1}{R_2} &\iff R_{\Sigma 2} &= \frac{R_1 R_2}{R_1 + R_2} \end{aligned}

What if we had more than two resistors in parallel?

First, let's make a quick note about finding the resistance of circuits in series.

The total resistance of resistors in a series is simply the sum of their resistances.

\begin{aligned} R_{\Sigma n} = \sum_{i=1}^{n} = R_1 + R_2 + R_3 + \cdots + R_n \end{aligned}

So as long a the resistors are part of a path, they can be seen as one big resistor.

I could also probably go over Ohm's Law ( $R = V / I$ or $V = I R$ where $V$ is voltage in volts, $I$ is the electrical current in amperes, and $R$ is the resistance in ohms), but I don't want to do that. Maybe in another article.

This article is about parallel resistors.

Suppose we have three resistors in parallel.

\begin{aligned} \frac{1}{R_{\Sigma 3}} &= \frac{1}{R_1} + \frac{1}{R_2} + \frac{1}{R_3} \end{aligned}

We can use the formula for two resistors in parallel, but we would need to add a third resistor.

\begin{aligned} \frac{1}{R_{\Sigma 3}} &= \frac{1}{R_1} + \frac{1}{R_2} + \frac{1}{R_3} && \square \cr \frac{1}{R_{\Sigma 3}} &= \frac{1}{R_{\Sigma 2}} + \frac{1}{R_3} &&\because R_{\Sigma 2} = \frac{R_1 R_2}{R_1 + R_2} \cr \frac{1}{R_{\Sigma 3}} &= \frac{R_1 + R_2}{R_1 R_2} + \frac{1}{R_3} \cr \frac{1}{R_{\Sigma 3}} &= \frac{R_3 (R_1 + R_2)}{R_1 R_2 R_3} + \frac{R_1 R_2}{R_1 R_2 R_3} \cr \frac{1}{R_{\Sigma 3}} &= \frac{R_1 R_2 + R_1 R_3 + R_2 R_3}{R_1 R_2 R_3} && \square \cr R_{\Sigma 3} &= \frac{R_1 R_2 R_3}{R_1 R_2 + R_1 R_3 + R_2 R_3} && \blacksquare \end{aligned}

We now have a formula we can use to find the resistance of three resistors in parallel.

What if we have four resistors in parallel? We can use the formula from our three parallel resistor example and use it to find a formula for four parallel resistors.

\begin{aligned} \frac{1}{R_{\Sigma 4}} &= \frac{1}{R_1} + \frac{1}{R_2} + \frac{1}{R_3} + \frac{1}{R_4} && \square \cr \frac{1}{R_{\Sigma 4}} &= \frac{1}{R_{\Sigma 3}} + \frac{1}{R_4} &&\because R_{\Sigma 3} = \frac{R_1 R_2 R_3}{R_1 R_2 + R_1 R_3 + R_2 R_3} \cr \frac{1}{R_{\Sigma 4}} &= \frac{R_1 R_2 + R_1 R_3 + R_2 R_3}{R_1 R_2 R_3} + \frac{1}{R_4} \cr \frac{1}{R_{\Sigma 4}} &= \frac{R_4 (R_1 R_2 + R_1 R_3 + R_2 R_3)}{R_1 R_2 R_3 R_4} + \frac{R_1 R_2 R_3}{R_1 R_2 R_3 R_4} \cr \frac{1}{R_{\Sigma 4}} &= \frac{R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4}{R_1 R_2 R_3 R_4} && \square \cr R_{\Sigma 4} &= \frac{R_1 R_2 R_3 R_4}{R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4} && \blacksquare \end{aligned}

Right now, you are probably think to yourself "Ugh! That's a lot of things I can't track" or "My head hurts from looking at this!"

This is why when formulas like this get this complicated I like to shift towards Sigma ( $Σ\Sigma$ ) and Pi ( $Π\Pi$ ) notations for for series of sums and products.

The basic concepts of these notations is to avoid having to write things over and over. Let's say we wanted to find the sum of numbers 1 through 4.

\begin{aligned} \sum_{i=1}^4 i = 1 + 2 + 3 + 4 = 10 \end{aligned}

Factorial ( $n!$ ) is just a prettier way to write the product of a series of numbers starting at 1.

\begin{aligned} 4! = \prod_{i=1}^4 i = 1 \cdot 2 \cdot 3 \cdot 4 = 24 \end{aligned}

But we can use $Σ\Sigma$ and $Π\Pi$ at different starting and ending points.

\begin{aligned} \sum_{i=2}^6 3i &= 6 + 9 + 12 + 15 + 18 = 60 \cr \prod_{i=3}^4 2+i &= 5 \cdot 6 \cdot 7 \cdot 9 = 1890 \cr \end{aligned}

Take a note of the formulas we have created thus far.

\begin{aligned} \frac{1}{R_{\Sigma 2}} &= \frac{1}{R_1} + \frac{1}{R_2} &\iff R_{\Sigma 2} &= \frac{R_1 R_2}{R_1 + R_2} \cr \frac{1}{R_{\Sigma 3}} &= \frac{1}{R_1} + \frac{1}{R_2} + \frac{1}{R_3} &\iff R_{\Sigma 3} &= \frac{R_1 R_2 R_3}{R_1 R_2 + R_1 R_3 + R_2 R_3} \cr \frac{1}{R_{\Sigma 4}} &= \frac{1}{R_1} + \frac{1}{R_2} + \frac{1}{R_3} + \frac{1}{R_4} &\iff R_{\Sigma 4} &= \frac{R_1 R_2 R_3 R_4}{R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4} \end{aligned}

Did you notice in the formulas on the right side, the numerators are the product of all the resistors?

If we could create a generalized formula, we could probably write the numerator in $Π\Pi$ notation.

\begin{aligned} u &= \prod_{i = 1}^n R_i = R_1 \cdot R_2 \cdot R_3 \cdot \cdots \cdot R_n && \square \end{aligned}

Pretty easy to see, right?

The denominators will require a bit more understanding. Each item in the denominator is the numerator divided by one term to cancel out one of the factors in a term.

\begin{aligned} v_j &= \frac{u}{R_j} \cr &= \frac{\prod_{i = 1}^n R_i}{R_j} \cr &= \frac{R_1 \cdot R_2 \cdot \cdots \cdot \cancel{R_j} \cdot \cdots \cdot R_{n-1} \cdot R_n}{\cancel{R_j}} && \text{where } 1 \le j \le n \end{aligned}

But writing this is problematic. Nobody wants to write all that stuff I just wrote when they can use a $Π\Pi$ notation to indicate that when we multiply by all our factors, we can skip $R_j$ . That's where this neat little hack comes in.

\begin{aligned} v_j &= \prod_{j \ne i} R_j \end{aligned}

Basically we say here "skip $j$ if it is equal to $i$ because $j$ should not equal $i$ ".

This is important because keep in mind, our denominator is the sum of products. Microsoft Excel geeks might now about the SUMPRODUCT function which acts as a filter add only matching items. With $∏j≠i\prod_{j \ne i}$ , we basically added a filter to exclude multiplying $R_j$ when $j = i$ .

There is a reason I put that subscripted $j$ next to $v$ . Its because we need the denominator ( $v$ ) to be the sum of each $v_j$ of which each $v_j$ is the product of all the resistors ( $u$ ) except when $j = i$ .

\begin{aligned} v &= \sum_{i = 1}^n v_i \cr &= v_1 + v_2 + \cdots + v_n &= \prod_{j \ne 1} R_j + \prod_{j \ne 2} R_j + \cdots + \prod_{j \ne n} R_j \cr v &= \sum_{i = 1}^n \prod_{j \ne 1} R_j && \square \end{aligned}

Confused? Think of this as having two for loops. In the following code sample, our initial sum is zero and our initial product is one. Starting with a sum of one would throw our answer off by one, and starting with a product of zero would mean all the products are zero. We can't have that. I've opted to shift our product index by one because arrays in JavaScript start a zero, but our math examples start at one.

let r = {1.5, 1.5, 4, 4};  // each resister with values in ohms

function denominator(r){
    let sum = 0;
    for(let i = 1; i <= n; i++){     // sigma sum
        let product = 1;
        for(let j = 1; j <= n; j++){  // pi product
            if(i === j) continue;    // if i equals j, skip this step
            product *= r[j-1];
        }
        sum += product;
    }
    return sum;
}

console.log(denominator(r));   // => 66

There's probably a more modern way to do this with JavaScript with the Array class's filter() or reduce() functions, but we still have to include our numerator in the formula!

For those wonder, here's what the code would be for the numerator.

function numerator(r) {
    let product = 1;
    for(i = 1; i <= n; i++){
        product *= r[i-1];
    }
    return product;
}

console.log(numerator(r));   // => 36

Let's combine both of our formulas now that we have two formulas to find each half of this fraction.

\begin{aligned} R_{\Sigma n} &= \frac{\prod_{i = 1}^n R_i}{\sum_{i = 1}^n \prod_{j \ne 1} R_j} &&\blacksquare \end{aligned}

One more piece of code.

function parallel(r){
    return numerator(r)/denominator(r);
}

console.log(numerator(r));   // => 0.54545454545

But I didn't spend about a hour writing thsi just to show you this.

Remember last post where we wanted to find the rates of change in a resistor? There's a reason I used $u$ and $v$ in this example, because we're not done yet! We want to find the derivative of $RΣnR_{\Sigma n}$ .

Get the ibuprofen handy, because I'm going to make your head hurt.

Because $RΣnR_{\Sigma n}$ is the quotient of two values, so will our $RΣn′R_{\Sigma n}'$ . Which means, we will need to break out the the quotient rule.

\begin{aligned} R_{\Sigma n}'(t) &= \left(\frac{u}{v}\right)' = \frac{u' \cdot v - u \cdot v'}{[v]^2} \end{aligned}

But I'm getting ahead of myself. I mean, how do we derive a $Σ\Sigma$ series, or a $Π\Pi$ series, or a $ΣΠ\Sigma\Pi$ series!?

We should probably start by taking a look at how we derived a circuit with two parallel resistors in it, from the previous post.

\begin{aligned} R_{\Sigma 2}(t) &= \frac{R_1(t) R_2(t)}{R_1(t) + R_2(t)} &\implies R_{\Sigma 2}'(t) &= \frac{R_1'(t) \cdot [R_2(t)]^2 + [R_1(t)]^2 \cdot R_2'(t)}{[R_1(t) + R_2(t)]^2} \end{aligned}

You know what, let's drop the $(t)$ 's. I know they are important to remind ourselves that we are working with functions with respect to time, and there are many ways to write your notation. But Team Lagrange for the win.

\begin{aligned} R_{\Sigma 2} &= \frac{R_1 R_2}{R_1 + R_2} &\implies R_{\Sigma 2}' &= \frac{R_1' \cdot [R_2]^2 + [R_1]^2 \cdot R_2'}{[R_1 + R_2]^2} \end{aligned}

OK, so that was our formula for two resistors in parallel. What about three? The numerator is easy to figure out. The product rule indicates that one of the values in each term is the first derivative. The denominator will require the sum rule and the product rule.

For brevity, I decided not to include some of my work because there was a lot of F.O.I.L. and cancelling. You can expect the same when I work on four factors in a bit. The point here is to find patterns.

\begin{aligned} R_{\Sigma 3} &= \frac{R_1 R_2 R_3}{R_1 R_2 + R_1 R_3 + R_2 R_3} \cr R_{\Sigma 3} &= \frac{u}{v} \cr R_{\Sigma 3}' &= \frac{u' \cdot v - u \cdot v'}{[v]^2}\cr \cr u &= R_1 R_2 R_3 \cr u' &= (R_1 R_2 R_3)' \cr u' &= R_1' R_2 R_3 + R_1 R_2' R_3 + R_1 R_2 R_3' && \square \cr \cr v &= R_1 R_2 + R_1 R_3 + R_2 R_3 \cr v' &= (R_1 R_2 + R_1 R_3 + R_2 R_3)' \cr v' &= (R_1 R_2)' + (R_1 R_3)' + (R_2 R_3)' \cr v' &= R_1' R_2 + R_1 R_2' + R_1' R_3 + R_1 R_3' + R_2' R_3 + R_2 R_3' && \square \cr \cr v^2 &= [R_1 R_2 + R_1 R_3 + R_2 R_3]^2 &&\square \cr \cr u' \cdot v - u \cdot v' &= R_1' [R_2]^2 [R_3]^2 + [R_1]^2 R_2' [R_3]^2 + [R_1]^2 [R_2]^2 R_3' && \square \cr R_{\Sigma 3}' &= \frac{R_1' [R_2]^2 [R_3]^2 + [R_1]^2 R_2' [R_3]^2 + [R_1]^2 [R_2]^2 R_3'}{[R_1 R_2 + R_1 R_3 + R_2 R_3]^2} && \blacksquare \end{aligned}

That took me over an hour to write, not including the stuff I cut out for clarity.

So what can we learn from this? Firstly, we don't need to expand the denominator. Just don't. It's a lot of busy work. In fact, I won't be expanding the denominator in or four parallel resistor example or in the $n$ th example. So lets assume that in any first derivative, of $RΣnR_{\Sigma n}$ , the denominator is as follows

\begin{aligned} [v_{\Sigma n}]^2 &= \left[\sum_{i = 1}^n \prod_{j \ne 1} R_j\right]^2 && \square \end{aligned}

Our attention is primarily on the numerator.

We can see that the terms in the numerator for $RΣ2R_{\Sigma 2}$ are multiplied by $R_{3}]^2$ . If we group our numerator terms together, we see that each numerator term is a denominator term multiplied by the derivative of a resistor. We will need to prove this in our four parallel resistor example to validate our generalization.

\begin{aligned} \frac{1}{R_{\Sigma 4}} &= \frac{1}{R_1} + \frac{1}{R_2} + \frac{1}{R_3} + \frac{1}{R_4} \cr R_{\Sigma 4} &= \frac{R_1 R_2 R_3 R_4}{R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4} \cr \cr R_{\Sigma 4}' &= \frac{(R_1 R_2 R_3 R_4)'}{(R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4)'} \cr \cr u &= R_1 R_2 R_3 R_4 \cr u' &= (R_1 R_2 R_3 R_4)' \cr &= R_1' R_2 R_3 R_4 R_1 R_2' R_3 R_4 R_1 R_2 R_3' R_4 R_1 R_2 R_3 R_4' &&\square\cr \cr v &= R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4 \cr v' &= (R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4)' \cr &= (R_1 R_2 R_3)' + (R_1 R_2 R_4)' + (R_1 R_3 R_4)' + (R_2 R_3 R_4)' \cr &= R_1' R_2 R_3 + R_1 R_2' R_3 + R_1 R_2 R_3' \cr &+ R_1' R_2 R_4 + R_1 R_2' R_4 + R_1 R_2 R_4' \cr &+ R_1' R_3 R_4 + R_1 R_3' R_4 + R_1 R_3 R_4' \cr &+ R_2' R_3 R_4 + R_2 R_3' R_4 + R_2 R_3 R_4' \cr \cr v^2 &= [R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4]^2 \cr u'v - uv' &= R_1' [R_2]^2 [R_3]^2 [R_4]^2 \cr &+ [R_1]^2 R_2' [R_3]^2 [R_4]^2 \cr &+ [R_1]^2 [R_2]^2 R_3' [R_4]^2 \cr &+ [R_1]^2 [R_2]^2 [R_3]^2 R_4' \cr \cr R_{\Sigma 4}' &= \frac{ R_1' [R_2]^2 [R_3]^2 [R_4]^2 + [R_1]^2 R_2' [R_3]^2 [R_4]^2 + [R_1]^2 [R_2]^2 R_3' [R_4]^2 + [R_1]^2 [R_2]^2 [R_3]^2 R_4' }{[R_1 R_2 R_3 + R_1 R_2 R_4 + R_1 R_3 R_4 + R_2 R_3 R_4]^2} && \blacksquare \end{aligned}

See how complex this is. Fortunately, we can see our pattern.

With every new factor, for each product term, at least one of the factors is derived while the others are squared. With this information, we can generalize the numerator. Let's start with how to describe each term

\begin{aligned} [u_i]' &= R_i' \prod_{j\ne i} [R_j]^2 \end{aligned}

Each subterm is the product of the derivative multiplied by the squares of the other factors except when $j = i$

We can also describe the sum of these subterms. This will describe our numerator.

\begin{aligned} u_{\Sigma n}' &= \sum_{i=1}^n \left( R_i' \prod_{j\ne i} [R_j]^2 \right) &&\square \end{aligned}

We have reached the end of a long journey. All there is now is to pair our numerator with the denominator.

\begin{aligned} R_{\Sigma n}' &= \frac{\sum_{i=1}^n \left( R_i' \prod_{j\ne i} [R_j]^2 \right)}{ \left[ \sum_{i = 1}^n \prod_{j \ne 1} R_j \right]^2 } && \blacksquare \end{aligned}

Let's compare this derivative with the formula

\begin{aligned} \frac{1}{R_{\Sigma n}(t)} &= \sum_{i=1}^n \frac{1}{R_i(t)} &\iff R_{\Sigma n}(t) &= \frac{\prod_{i=1}^n R_i(t)}{\sum_{i = 1}^n \prod_{j \ne 1} R_j(t)} \cr &&\implies R_{\Sigma n}'(t) &= \frac{\sum_{i=1}^n \left( R_i'(t) \prod_{j\ne i} [R_j(t)]^2 \right)}{ \left[ \sum_{i = 1}^n \prod_{j \ne 1} R_j(t) \right]^2 } &&\blacksquare \end{aligned}

I wanted to interpret the derived formula into code, but I just don't have the energy left after having figure out all the terms for four resistors in parallel. Maybe in a future post. Stay tuned.

Resistors in Parallel

Jason Charney — Wed, 20 Oct 2021 17:03:04 +0000

Hello, this is my first post here. One of the things I like to do in my spare time is generalize mathematical formulas.

On the subreddit r/calculus, this question was posted.

The question essentially asks what is the change in resistance with respect to time.

The formula for two resistors in parallel is the following.

\frac{1}{R_{\Sigma 2}} = \frac{1}{R_1} + \frac{1}{R_2}

Note: I used the $RΣ2R_{\Sigma 2}$ to indicate the Sum of Two Resistors. ( $Σ\Sigma$ often used for "Sum". I will use this notation in future posts.

What trips up a lot of students with this problem is that they feel overwhelmed by how they should calculate the problem.

To fix that, they should adjust the formula before plug in the numbers.

\begin{aligned} \frac{1}{R_{\Sigma 2}} &= \frac{1}{R_1} + \frac{1}{R_2} && \square \cr \frac{1}{R_{\Sigma 2}} &= \frac{R_2}{R_1 R_2} + \frac{R_1}{R_1 R_2} \cr \frac{1}{R_{\Sigma 2}} &= \frac{R_1}{R_1 R_2} + \frac{R_2}{R_1 R_2} \cr \frac{1}{R_{\Sigma 2}} &= \frac{R_1 + R_2}{R_1 R_2} && \square \cr R_{\Sigma 2} &= \frac{R_1 R_2}{R_1 + R_2} && \blacksquare \end{aligned}

Since this is a problem with respect to time, we need to think of this problem like this.

\frac{1}{R_{\Sigma 2}(t)} = \frac{1}{R_1(t)} + \frac{1}{R_2(t)}

Or, since we adjusted our formula, this.

R_{\Sigma 2}(t) = \frac{R_1(t) \cdot R_2(t)}{R_1(t) + R_2(t)}

We need to find the derivative of this problem.

R'_{\Sigma 2}(t) = \left( \frac{R_1(t) \cdot R_2(t)}{R_1(t) + R_2(t)} \right)'

Let's make some substitutions. Let us set the numerator to $u (t)$ and the denominator to $v (t)$ .

R'_{\Sigma 2}(t) = \left(\frac{u(t)}{v(t)}\right)' = \left( \frac{R_1(t) \cdot R_2(t)}{R_1(t) + R_2(t)} \right)'

We can apply the quotient rule to our equation.

R'_{\Sigma 2}(t) = \left(\frac{u(t)}{v(t)}\right)' = \frac{u'(t) \cdot v(t) - u(t) \cdot v'(t)}{[v(t)]^2}

Let us find the derivatives of $u (t)$ and $v (t)$ . We will apply the product rule to $u^{'} (t)$ and the Sum Rule to $v^{'} (t)$ .

\begin{aligned} u(t) &= R_1(t) \cdot R_2(t) &\implies u'(t) &= R_1'(t) \cdot R_2(t) + R_1(t) \cdot R_2'(t) && \square \cr v(t) &= R_1(t) + R_2(t) &\implies v'(t) &= R_1'(t) + R_2'(t) && \square \end{aligned}

Since the denominator of the quotient rule is $v(t)]^2$ , we should find the square of $v (t)$ .

\begin{aligned} [v(t)]^2 &= [R_1(t) + R_2(t)]^2 \cr &= [R_1(t)]^2 + 2 \cdot R_1(t) \cdot R_2(t) + [R_2(t)]^2 && \square \end{aligned}

Let's return to the numerator, $\cdot v(t) - u(t) \cdot v'(t)$ . We should find $\cdot v(t)$ and $\cdot v'(t)$ . This is quite long, so let's wrap this around each term.

\begin{aligned} u'(t) \cdot v(t) &= (R_1'(t) \cdot R_2(t) + R_1(t) \cdot R_2'(t)) \cdot (R_1(t) + R_2(t)) \cr &= R_1'(t) \cdot R_2(t) \cdot R_1(t) \cr &+ R_1'(t) \cdot R_2(t) \cdot R_2(t) \cr &+ R_1(t) \cdot R_2'(t) \cdot R_1(t) \cr &+ R_1(t) \cdot R_2'(t) \cdot R_2(t) \cr \cr u(t) \cdot v'(t) &= (R_1(t) \cdot R_2(t)) \cdot (R_1'(t) + R_2'(t)) \cr &= R_1(t) \cdot R_2(t) \cdot R_1'(t) \cr &+ R_1(t) \cdot R_2(t) \cdot R_2'(t) \end{aligned}

Recall that there is a minus sign in front of $\cdot v'(t)$ . We will need to negate the sign on the two terms distributed. We will also group similar terms in the $\cdot v(t)$ equation. We will remove the terms that cancel each other out, and add what remains to get our numerator.

\begin{aligned} u'(t) \cdot v(t) - u(t) \cdot v'(t) &= (R_1'(t) \cdot R_2(t) + R_1(t) \cdot R_2'(t)) \cdot (R_1(t) + R_2(t)) \cr &= \cancel{R_1'(t) \cdot R_2(t) \cdot R_1(t)} \cr &+ R_1'(t) \cdot [R_2(t)]^2 \cr &+ [R_1(t)]^2 \cdot R_2'(t) \cr &+ \bcancel{R_1(t) \cdot R_2'(t) \cdot R_2(t)} \cr &- \cancel{R_1(t) \cdot R_2(t) \cdot R_1'(t)} \cr &- \bcancel{R_1(t) \cdot R_2(t) \cdot R_2'(t)} \cr &= R_1'(t) \cdot [R_2(t)]^2 + [R_1(t)]^2 \cdot R_2'(t) && \square \end{aligned}

Let's put our equations together.

\begin{aligned} R_{\Sigma 2}'(t) &= \frac{R_1'(t) \cdot [R_2(t)]^2 + [R_1(t)]^2 \cdot R_2'(t)}{[R_1(t)]^2 + 2 \cdot R_1(t) \cdot R_2(t) + [R_2(t)]^2} && \square \end{aligned}

You know what, let's factor the denominator. It seems pointless to expand it.

\begin{aligned} R_{\Sigma 2}'(t) &= \frac{R_1'(t) \cdot [R_2(t)]^2 + [R_1(t)]^2 \cdot R_2'(t)}{[R_1(t) + R_2(t)]^2} && \blacksquare \end{aligned}

Perfect!

Take note that in the numerator there is no negative sign like is typical in a quotient rule. Because we cancelled out some terms, we can simply add everything in the numerator.

We can now solve the problem with that equation.

Let's consider $R1′(t)=1Ω/sR_1'(t) = 1\Omega/\text{s}$ and $R2′(t)=1.5Ω/sR_2'(t) = 1.5\Omega/\text{s}$ . (These are our derived values because these values are in ohms per second, so resistance with respect to time.)

If $R1(t)=50ΩR_1(t) = 50\Omega$ and $R2(t)=75ΩR_2(t) = 75\Omega$ , what is the rate of change of $R (t)$ ?

\begin{aligned} R_{\Sigma 2}'(t) &= \frac{R_1'(t) \cdot [R_2(t)]^2 + [R_1(t)]^2 \cdot R_2'(t)}{[R_1(t) + R_2(t)]^2} \cr R_{\Sigma 2}'(t) &= \frac{1 \cdot [R_2(t)]^2 + [R_1(t)]^2 \cdot 1.5}{[R_1(t) + R_2(t)]^2} && R_1'(t) = 1\Omega/\text{s}, R_2'(t) = 1.5\Omega/\text{s} \cr R_{\Sigma 2}'(t) &= \frac{1 \cdot [75]^2 + [50]^2 \cdot 1.5}{[50 + 75]^2} && R_1(t) = 50\Omega, R_2(t) = 75\Omega\cr R_{\Sigma 2}'(t) &= \frac{1 \cdot 5625 + 2500 \cdot 1.5}{[125]^2}\cr R_{\Sigma 2}'(t) &= \frac{5625 + 3750}{15625}\cr R_{\Sigma 2}'(t) &= \frac{9375}{15625}\cr R_{\Sigma 2}'(t) &= 0.6\Omega/\text{s} && \blacksquare \end{aligned}

Our solution is 0.6 ohms per second. 😎

This was a wonderful problem to solve.

In my next post, I want to show how we could generalize the formula we used. What if we had more than two resistors in parallel.

I look forward to using this blog to share math problems as well as code examples. Thanks for reading!