Box</th>	Index</th>	Item</th></tr></thead>
1</td>	0</td>	`Apple</code></td></tr>`
2</td>	1</td>	`Banana</code></td></tr>`
3</td>	2</td>	Orange</code></td></tr> </tbody></table> This way is best used when you know what values you want to start with. An example of this may be when you want a list with the names of all the countries in the world. You could also make a list the first way and add values later, as I’ll show below.</p> Manipulating list values</a></h2> Adding values</u>:</li> </ul> Let's say you like to keep things clean and simple, and want to use the first way to make an list of countries. How would you add the country names to the list?</p> Here's how: listName.add(newValue);</code></p> For example:</p> List</span><</span>String</span>></span> countries</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span> </span> countries</span>.</span>add</span>(</span>"</span>Atlantis</span>"</span>)</span>;</span></span> countries</span>.</span>add</span>(</span>"</span>Bangladesh</span>"</span>)</span>;</span></span> //</span> and so on...</span></span> countries</span>.</span>add</span>(</span>"</span>Wonderland</span>"</span>)</span>;</span></span></code></pre> Modifying values</u>:</li> </ul> To re-assign</em> values, you’ll need to use the set</code> method:</p> countries</span>.</span>set</span>(</span>1</span>,</span> "</span>Neverland</span>"</span>)</span>;</span></span></code></pre> This will change the value of the 2nd box (at index 1) from Bangladesh</code> to Neverland</code>.</p> Removing values</u>:</li> </ul> To remove the value at a specific index:</p> countries</span>.</span>remove</span>(</span>1</span>)</span>;</span></span></code></pre> To remove the first occurrence of the specified value:</p> countries</span>.</span>remove</span>(</span>"</span>Neverland</span>"</span>)</span>;</span></span></code></pre> To remove all occurrences of the specified value:</p> countries</span>.</span>removeAll</span>(</span>"</span>Neverland</span>"</span>)</span>;</span></span></code></pre>Calling list elements</a></h2> Just like how people can be called by their names, these elements</em> can be called by their indices</em>. Elements is a technical term for the values in the "boxes" and Index is a technical term for the "position" of the boxes, and the first box is at index 0. So, the n^th^ box will always be at index (n-1)</code>, as long as n is at least 1.</p> To access the nth list element in Java, simply call it by its index using the get</code> method, like fruits.get(1)</code>.</p> An example of it in action:</p> System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>.</span>get</span>(</span>1</span>)</span>)</span>;</span></span></code></pre> This would print Banana</code> to the console. Banana is the 2nd</code> element, so its index is 2 - 1 = 1</code>.</p> Length of a list</a></h2> After all that creating, assigning and calling lists and their elements, you might not remember what the length of each one is. Well, fear not, because Java has you covered. Lists have a handy little getter method that you can use to know the length of a list. To access it, simply use listName.size()</code>.</p> For example:</p> System</span>.</span>out</span>.</span>println</span>(</span>countries</span>.</span>size</span>(</span>)</span>)</span>;</span></span> //</span> output: 195</span></span> </span> System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>.</span>size</span>(</span>)</span>)</span>;</span></span> //</span> output: 3</span></span></code></pre>Sorting lists</a></h2> In case you assigned the names of the countries randomly and now want them sorted in alphabetical order, you can use the Collections.sort()</code> method from the java.util.Collections</code> class.</p> Here's how to use it:</p> import</span> java</span>.</span>util</span>.</span>Collections</span>;</span></span> </span> //</span> create the unsorted list of countries here</span></span> </span> Collections</span>.</span>sort</span>(</span>countries</span>)</span>;</span></span> </span> //</span> the list "countries" is now sorted</span></span></code></pre> This will also sort numbers in numerical order, and other types in their natural order. It will also sort custom data types implementing the Comparable</code> interface as defined in their compareTo</code> method.</p> Looping over lists</a></h2> The process of looping through collections like lists, lists, sets, etc. is also known as iterating</em>. When we iterate</em> over an list, we're simply checking the value in each box of the list one by one and usually performing the same actions with each value, unless specified otherwise by some logic control (if-else</code> and such).</p> There are a few ways to iterate over lists:</p> Traditional for</code> loop:</li> </ul> String</span> country</span>;</span></span> for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> countries</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span> if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span> country </span>=</span> countries</span>.</span>get</span>(</span>i</span>)</span>;</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span> else</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span></span> "</span>The answer to life, the universe </span>"</span></span> +</span> "</span>and everything...</span>"</span></span> )</span>;</span></span> }</span></span> }</span></span></code></pre> for-each</code> loop:</li> </ul> for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span></span></code></pre> while</code> loop:</li> </ul> int</span> i</span> =</span> 0</span>;</span></span> String</span> country</span>;</span></span> while</span> (</span>i </span><</span> countries</span>.</span>length</span>)</span> {</span></span> if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span> country </span>=</span> countries</span>.</span>get</span>(</span>i</span>)</span>;</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span> else</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span></span> "</span>The answer to life, the universe </span>"</span></span> +</span> "</span>and everything...</span>"</span></span> )</span>;</span></span> }</span></span> i</span>++</span>;</span></span> }</span></span></code></pre> As you can see, while the for-each</code> loop makes life easier for simple iterations, you have slightly less control over things as it doesn't give you the index easily. We can, however, mitigate that problem by using a variable to track the index, like in the while</code> loop:</p> int</span> i</span> =</span> 0</span>;</span></span> for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span> if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span> else</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span></span> "</span>The answer to life, the universe </span>"</span></span> +</span> "</span>and everything...</span>"</span></span> )</span>;</span></span> }</span></span> i</span>++</span>;</span></span> }</span></span></code></pre> Or you could just use the while loop.</p> However, this kind of for-each</code> loop does have an advantage. The variable country</code> is created and used within the scope of this loop alone, so you can create a variable with the same name outside the scope and use it without conflicts. It can be done in the other loops too, but is much cleaner, easily readable and more efficient this way. Do note that the variable to track index, i</code>, is declared outside the scope of the for-each</code> loop, so make sure to be careful about that later. Next time you want to use it in that scope, you should reset it to 0</code> before you perform any operations with it, unless you actually want to retain the value it has after going through the loop.</p> It's often important to choose the correct loop for the task at hand. Take a deep breath, relax and think about which loop might put you at an advantage.</p> A better way to iterate</a></h2> If you tried to modify list elements inside loops and had your program crash with a ConcurrentModificationException</code>, no need to panic. It’s just Java being cautious so that nothing weird happens in the program. To get around this, we need to use list iterators and the methods that come with them which we can use to manipulate the list safely.</p> “With great power comes great responsibility.” - Uncle Ben</em></p> Here’s a little text filtering program to demonstrate ListIterator</code>s in action:</p> import</span> java</span>.</span>util</span>.</span>ArrayList</span>;</span></span> import</span> java</span>.</span>util</span>.</span>List</span>;</span></span> import</span> java</span>.</span>util</span>.</span>ListIterator</span>;</span></span> </span> public</span> class</span> FilterLines</span> {</span></span> public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span> //</span> create variables</span></span> List</span><</span>String</span>></span> lines</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span> ListIterator</span><</span>String</span>></span> linesIterator</span>;</span> //</span> declare the iterator</span></span> String</span> currentLine</span>;</span></span> </span> //</span> add lines to the list of lines to filter</span></span> lines</span>.</span>add</span>(</span>"</span>There was a line with the word bad here.</span>"</span>)</span>;</span></span> lines</span>.</span>add</span>(</span>"</span>There was another bad line here.</span>"</span>)</span>;</span></span> lines</span>.</span>add</span>(</span>"</span>This line will stay as is.</span>"</span>)</span></span> lines</span>.</span>add</span>(</span>"</span>Here's a good line.</span>"</span>)</span>;</span></span> lines</span>.</span>add</span>(</span>"</span>Have a good day!</span>"</span>)</span>;</span></span> </span> //</span> code to filter the lines</span></span> linesIterator </span>=</span> lines</span>.</span>listIterator</span>(</span>)</span>;</span> //</span> assign the iterator</span></span> while</span> (</span>linesIterator</span>.</span>hasNext</span>(</span>)</span>)</span> {</span></span> currentLine </span>=</span> linesIterator</span>.</span>next</span>(</span>)</span>;</span></span> if</span> (</span>currentLine</span>.</span>contains</span>(</span>"</span>bad</span>"</span>)</span>)</span> {</span></span> linesIterator</span>.</span>remove</span>(</span>)</span>;</span></span> }</span> else</span> if</span> (</span>currentLine</span>.</span>contains</span>(</span>"</span>good</span>"</span>)</span>)</span> {</span></span> linesIterator</span>.</span>set</span>(</span>currentLine</span>.</span>toUpperCase</span>(</span>)</span>)</span>;</span></span> }</span></span> }</span></span> </span> //</span> print out the lines</span></span> for</span> (</span>String</span> line</span> :</span> lines</span>)</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span>line</span>)</span>;</span></span> }</span></span> }</span></span> }</span></span></code></pre> PS</strong>: It's important to assign the list iterator right before iteration as on line 20</code>. It can be declared beforehand, though, as on line 9</code>. This is because the listName.listIterator()</code> method gets the current</strong> state of the list and creates a ListIterator</code> object out of it. Changes you make directly to the list will not update the iterator and may result in unexpected behaviour.</p> Running the above program produces the following output:</p> This line will stay as is.</span></span> HERE'S A GOOD LINE.</span></span> HAVE A GOOD DAY!</span></span></code></pre> As you can see, the lines with “bad” were removed and the lines with “good” were converted to uppercase.</p> Check for identical lists</a></h2> Now that you've made some lists, you might want to check if two lists contain the same things. We could of course make a method to compare two given lists using loops and if-else</code> control, but that would be too much work. Thus, the equals</code> method will certainly come in handy and take some load off our shoulders.</p> Here's how it works:</p> //</span> make a list, countries</span></span> //</span> make a list, fruits</span></span> </span> boolean</span> isEqual</span> =</span> countries</span>.</span>equals</span>(</span>fruits</span>)</span>;</span></span> </span> System</span>.</span>out</span>.</span>println</span>(</span>isEqual</span>)</span>;</span></span> //</span> output: false</span></span> </span> //</span> output will be "true" if the given lists are equal</span></span></code></pre>Helpful resources</a></h2> Here are some resources I use to learn Java. I don't memorise anything, but rather just look them up when I need to. They're all great sites to learn Java (some have other languages too) and I hope you find them helpful.</p> Java 8 docs of the List interface</a></li> Java 8 docs of the ArrayList class</a></li> Java 8 docs of the LinkedList class</a></li> Java 8 docs of the ListIterator interface</a></li> SoloLearn</a></li> GeeksforGeeks</a></li> W3schools</a></li> tutorialspoint</a></li> Javatpoint</a></li> </ul> Conclusion</a></h2> That's all about lists for now. That should cover the basics of lists, but do let me know in the comments if I've missed something or made a mistake somewhere.</p> I hope it was helpful for you. Thanks for reading through. See you later.</p> My Experience with Online Learning cybardev — Mon, 22 Mar 2021 13:29:40 +0600 My Story</a></h2> I'm currently an undergraduate student studying at Saint Mary's University, Nova Scotia, Canada. As my major, I've chosen Computer Science (they call it computing science, but it's practically the same thing), as I had a keen interest in computers, science and technology from a very young age. Because of the ongoing pandemic, our school has decided to provide online classes with some optional in-person experiences. To save money on residence, food and other costs, I've decided to do online classes from Bangladesh until in-person classes fully begin. Here's my experience with online learning thus far.</p> The Woes</a></h2> Online classes can be hectic, especially if your school is on the other side of the globe. Ideally, you'd want to start your morning with classes, take some rest and start working on your assignments in the afternoon or evening. With online classes, I'm having to do the opposite - assignments in the morning, get exhausted from all the work, barely have any energy for classes in the evening/night. On Wednesday nights (or Thursday morning) at 3 AM, I have a 2 hr recitation class too, so that's not helping my health either.</p> The Joys</a></h2> That being said, I'm loving the different atmosphere of foreign universities. The teachers are mostly extremely helpful (not all though) and I'm glad to say my CS professor is the most joyful and inspiring character I've met out of all the professors there (Maths professor is the least, sadly). That teacher has humour, intellect, experience, a Ph.D. (of course he does) and is a complete joy to learn from. I'm glad I got him from the first year in my major course.</p> Make Friends</a></h2> I'm also enjoying the virtual company of my peers, although I'd love to meet them in person. As that's currently impossible, this is the best we can get. I'm thrilled to be able to share ideas and converse with so many people with similar interests and passions. I've also been able to build up a Discord server of 230+ students (many inactive accounts, but whatever. I tried). The owner of the server was kind enough to let me handle it when it was only about 20 people, and together, myself, the owner, and a senior at SMU were able to build it up to what it is today, with a little help from some of the members. Now we have different channels for different courses, reaction roles so that we can choose what course channels we can see and of course, many enthusiastic and active members.</p> Explore Opportunities</a></h2> I've even become part of a team of enthusiastic CS undergrads and we're hopefully set to make a little project of ours - a visual novel game - to practice our skills, learn new ones and get some hands-on experience in working with a team on a real project. A good idea if you're looking to build up your portfolio and have a good first impression on potential employers.</p> Time Management</a></h2> Make sure you use your time wisely though, as scheduling is very important. If you procrastinate, it becomes very difficult to cope up with the horde of assignments, quizzes, tests, recitations and everything else the University throws at you. Even though I managed to do a 2-month assignment in 2 days and still scored 28 out of 30 (don't be me. it was insanely exhausting). Be on top of your schedule and you'll be fine.</p> Mental Health</a></h2> Many universities, including mine, offer many free workshops and counselling sessions throughout the course of the degree. Make sure you take full advantage of these and always mail the advisors, counsellors and professors whenever you're in a pinch. They're really helpful and understanding and will patiently guide you through whatever you're having trouble with. Also, please do keep a check on your mental health. Many students face issues for a variety of reasons and there are often free counselling sessions available. Make your money worth it, and don't neglect yourself.</p> Your Story</a></h2> Something important some of us forget to do in school is building up a network of peers, seniors and professors, and make memories that enrich your life. While grades are pretty important still (because we study in an education system for the 1800s), these human resources are such that they can bring a lot more value to your life. University is the time to explore your interests, so make some friends, do personal projects, join or form clubs and enjoy your time.</p> THIS IS YOUR TIME TO SHINE. DO YOUR BEST. (^_^)</strong></p> Java Arrays cybardev — Mon, 08 Mar 2021 16:03:05 +0600 What are arrays?</a></h2> Think of arrays like a row of cardboard boxes. These boxes can be used to store different types of data - ints</code>, Strings</code>, even custom data types like Person</code>.</p> One important thing to note is that you can only have a constant number of these boxes for each array you make. While making the array, if you tell Java that this array will have 10 items, then that array will always be able to contain up to 10 items - no more, no less, no changes to this size. You can store less than 10 items in that array and leave the others at default value (to change them later), but this might have weird effects on your program and is better avoided.</p> Making new arrays</a></h2> There are two ways of creating arrays in Java:</p> The first way</strong> creates an array of Strings with a fixed number of the "boxes" (3 in the example below), and each box contains a default value given to it by Java. For String arrays like this one, that value is null</code>, which isn't actually a String, but you can read more on that here</a>.</li> </ul> String</span>[</span>]</span> fruits</span> =</span> new</span> String</span>[</span>3</span>]</span>;</span></span></code></pre> Here's a visual representation of the first array:</p> Box</th> Index</th> Item</th></tr></thead> 1</td> 0</td> null</code></td></tr> 2</td> 1</td> null</code></td></tr> 3</td> 2</td> null</code></td></tr> </tbody></table> This way of making arrays is best used when you know how many items the array should have, but you don't know what the values will be. An example of this may be in a program that asks the users for their grades throughout a course, and you know the maximum number of tests there are in that course.</p> The second way</strong> creates an array of 3 Strings too, but here, we're providing each box with an initial value, instead of keeping the default value.</li> </ul> String</span>[</span>]</span> fruits</span> =</span> {</span>"</span>Apple</span>"</span>,</span> "</span>Banana</span>"</span>,</span> "</span>Orange</span>"</span>}</span>;</span></span></code></pre> Here's a visual representation of the second array:</p> Box</th> Index</th> Item</th></tr></thead> 1</td> 0</td> Apple</code></td></tr> 2</td> 1</td> Banana</code></td></tr> 3</td> 2</td> Orange</code></td></tr> </tbody></table> This way is best used when you know what values you want to start with. An example of this may be when you want an array with the names of all the countries in the world. It would be rather painful if you first made an array of nearly 200 Strings with default value and then added each country name individually.</p> Assigning values to arrays</a></h2> Let's say you're very hard working and like to take challenges, and want to use the first way to make an array of countries. How would you set the values to be country names instead of null</code>?</p> Here's how: arrayName[index] = newValue;</code></p> For example:</p> String</span>[</span>]</span> countries</span> =</span> new</span> String</span>[</span>195</span>]</span>;</span></span> </span> countries</span>[</span>0</span>]</span> =</span> "</span>Atlantis</span>"</span>;</span></span> countries</span>[</span>1</span>]</span> =</span> "</span>Bangladesh</span>"</span>;</span></span> //</span> and so on...</span></span> countries</span>[</span>194</span>]</span> =</span> "</span>Wonderland</span>"</span>;</span></span></code></pre> You can also use this to re-assign</em> values:</p> countries</span>[</span>1</span>]</span> =</span> "</span>Neverland</span>"</span>;</span></span></code></pre> This will change the value of the 2nd box (at index 1) from Bangladesh</code> to Neverland</code>.</p> Calling array elements</a></h2> Just like how people can be called by their names, these elements</em> can be called by their indices</em>. Elements is a technical term for the values in the "boxes" and Index is a technical term for the "position" of the boxes, and the first box is at index 0. So, the (n)th box will always be at index (n-1), as long as n is at least 1.</p> To access the nth array element in Java, simply call it by its index, like fruits[1]</code>.</p> An example of it in action:</p> System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>[</span>1</span>]</span>)</span>;</span></span></code></pre> This would print Banana</code> to the console. Banana is the 2nd</code> element, so its index is 2-1 = 1</code>.</p> Length of an Array</a></h2> After all that creating, assigning and calling arrays and their elements, you might not remember what the length of each one is. Well, fear not, because Java has you covered. Arrays have a really nice property that you can use to know the length of an array. When each array is created, it's assigned an instance variable with the name length</code> that stores how many items there can be in the array. To access it, simply use arrayName.length</code>.</p> For example:</p> System</span>.</span>out</span>.</span>println</span>(</span>countries</span>.</span>length</span>)</span>;</span></span> //</span> output: 195</span></span> </span> System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>.</span>length</span>)</span>;</span></span> //</span> output: 3</span></span></code></pre>Sorting Arrays</a></h2> In case you assigned the names of the countries randomly and now want them sorted in alphabetical order, you can use the Arrays.sort()</code> method from the java.util.Arrays</code> class.</p> Here's how to use it:</p> import</span> java</span>.</span>util</span>.</span>Arrays</span>;</span></span> </span> //</span> create the unsorted array of countries here</span></span> </span> Arrays</span>.</span>sort</span>(</span>countries</span>)</span>;</span></span> </span> //</span> the array "countries" is now sorted</span></span></code></pre>Looping over arrays</a></h2> The process of looping through collections like arrays, lists, sets, etc. is also known as iterating</em>. When we iterate</em> over an array, we're simply checking the value in each box of the array one by one and usually performing the same actions with each value, unless specified otherwise by some logic control (if-else</code> and such).</p> There are a few ways to iterate over arrays:</p> Traditional for</code> loop:</li> </ul> String</span> country</span>;</span></span> for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> countries</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span> if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span> country </span>=</span> countries</span>[</span>i</span>]</span>;</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span> else</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span></span> "</span>The answer to life, the universe </span>"</span></span> +</span> "</span>and everything...</span>"</span></span> )</span>;</span></span> }</span></span> }</span></span></code></pre> for-each</code> loop:</li> </ul> for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span></span></code></pre> while</code> loop:</li> </ul> int</span> i</span> =</span> 0</span>;</span></span> String</span> country</span>;</span></span> while</span> (</span>i </span><</span> countries</span>.</span>length</span>)</span> {</span></span> if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span> country </span>=</span> countries</span>[</span>i</span>]</span>;</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span> else</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span></span> "</span>The answer to life, the universe </span>"</span></span> +</span> "</span>and everything...</span>"</span></span> )</span>;</span></span> }</span></span> i</span>++</span>;</span></span> }</span></span></code></pre> As you can see, while the for-each</code> loop makes life easier for simple iterations, you have slightly less control over things as it doesn't give you the index easily. We can, however, mitigate that problem by using a variable to track the index, like in the while</code> loop:</p> int</span> i</span> =</span> 0</span>;</span></span> for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span> if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span> }</span> else</span> {</span></span> System</span>.</span>out</span>.</span>println</span>(</span></span> "</span>The answer to life, the universe </span>"</span></span> +</span> "</span>and everything...</span>"</span></span> )</span>;</span></span> }</span></span> i</span>++</span>;</span></span> }</span></span></code></pre> Or you could just use the while loop.</p> However, this kind of for-each</code> loop does have an advantage. The variable country</code> is created and used within the scope of this loop alone, so you can create a variable with the same name outside the scope and use it without conflicts. It can be done in the other loops too, but is much cleaner, easily readable and more efficient this way. Do note that the variable to track index, i</code>, is declared outside the scope of the for-each</code> loop, so make sure to be careful about that later. Next time you want to use it in that scope, you should reset it to 0</code> before you perform any operations with it, unless you actually want to retain the value it has after going through the loop.</p> It's often important to choose the correct loop for the task at hand. Take a deep breath, relax and think about which loop might put you at an advantage.</p> Check for identical arrays</a></h2> Now that you've made some arrays, you might want to check if two arrays contain the same things. We could of course make a method to compare two given arrays using loops and if-else</code> control, but that would be too much work. Thus, the Arrays.equals()</code> method will certainly come in handy and take some load off our shoulders.</p> Here's how it works:</p> import</span> java</span>.</span>util</span>.</span>Arrays</span>;</span></span> </span> //</span> make an array, countries</span></span> //</span> make an array, fruits</span></span> </span> boolean</span> isEqual</span> =</span> Arrays</span>.</span>equals</span>(</span>countries</span>,</span> fruits</span>)</span>;</span></span> </span> System</span>.</span>out</span>.</span>println</span>(</span>isEqual</span>)</span>;</span></span> //</span> output: false</span></span> </span> //</span> output will be "true" if the given arrays are equal</span></span></code></pre>Helpful resources</a></h2> Here are some resources I use to learn Java. I don't memorize anything, but rather just look them up when I need to. They're all great sites to learn Java (and other languages) and I hope you find them helpful.</p> SoloLearn</a></li> GeeksforGeeks</a></li> W3schools</a></li> tutorialspoint</a></li> Javatpoint</a></li> </ul> Conclusion</a></h2> That's all about arrays for now. That should cover the basics of one-dimensional arrays, but do let me know in the comments if I've missed something or made a mistake somewhere.</p> I hope it was helpful for you. Thanks for reading through. See you later.</p> Prefix (++i) vs Postfix (i++) Operators in Code cybardev — Sun, 24 Jan 2021 21:40:48 +0600 The dilemma: ++i</code> vs i++</code></a></h2> In C-style languages (C, C++, Java, etc.), the operators ++</code> and --</code> are used to add or subtract 1</code> from a variable. ++</code> is called the “increment” operator, and --</code> is called the “decrement” operator. If the operator is put before the variable, as in ++i</code>, it’s called a “prefix” operator. If the operator is put after the variable, as in i--</code>, it’s called a “postfix operator” or “suffix operator”. Here’s a table to help visualize all that:</p> Operator</th> Name</th></tr></thead> i++</code></td> Postfix increment operator</td></tr> i--</code></td> Postfix decrement operator</td></tr> ++i</code></td> Prefix increment operator</td></tr> --i</code></td> Prefix increment operator</td></tr> </tbody></table> The prefix and postfix operators do the same thing but have different operator precedence compared to the assignment operator. This can lead to your code having unexpected behavior when an increment/decrement operator is used in conjunction with the assignment operator. To demonstrate, I’ll show you some examples below.</p> Standalone use</a></h3> increasing the value of a variable using ++</code></li> </ul> #</span>include</span> <</span>stdio.h</span>></span></span> int</span> main</span>(</span>)</span> {</span></span> int</span> x </span>=</span> 0</span>;</span></span> x</span>++</span>;</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span> }</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span> int</span> main</span>(</span>)</span> {</span></span> int</span> x </span>=</span> 0</span>;</span></span> ++</span>x</span>;</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span> }</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span> int</span> main</span>(</span>)</span> {</span></span> int</span> x </span>=</span> 0</span>;</span></span> x </span>=</span> x </span>+</span> 1</span>;</span> //</span> or x += 1;</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span> }</span></span></code></pre> The above codes all have the exact same effect: increase the value of x</code> by 1</code> and print it. The decrement operator --</code> would have a similar effect. This behavior can be used in while loops to add to a count</code> variable on each iteration.</p> Use with assignment</a></h3> prefix operator</li> </ul> #</span>include</span> <</span>stdio.h</span>></span></span> int</span> main</span>(</span>)</span> {</span></span> int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span> y </span>=</span> ++</span>x</span>;</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 1</span></span> }</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span> int</span> main</span>(</span>)</span> {</span></span> int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span> x </span>=</span> x </span>+</span> 1</span>;</span> //</span> or x += 1;</span></span> y </span>=</span> x</span>;</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 1</span></span> }</span></span></code></pre> As we can see here, the prefix operator first increases the value of x</code> and returns the new value which is then assigned to y</code> via the assignment operator.</p> postfix operator</li> </ul> #</span>include</span> <</span>stdio.h</span>></span></span> int</span> main</span>(</span>)</span> {</span></span> int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span> y </span>=</span> x</span>++</span>;</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 0</span></span> }</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span> int</span> main</span>(</span>)</span> {</span></span> int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span> y </span>=</span> x</span>;</span></span> x </span>=</span> x </span>+</span> 1</span>;</span> //</span> or x += 1;</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span> printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 0</span></span> }</span></span></code></pre> Here, the postfix operator first returns the current value which is then assigned to y</code> via the assignment operator and then increases the value of x</code>. This works a bit differently than what it looks like. More on that below</a>.</p> Use in loops</a></h3> You’ll be glad to know that in for loops, i++</code> and ++i</code> have essentially identical effects. This is because the order of operations in a for loop flows like this:</p> for</span> (</span>int</span> i </span>=</span> 0</span>;</span> i </span><</span> 5</span>;</span> ++</span>i</span>)</span> {</span></span> //</span> loop body</span></span> }</span></span></code></pre> initialize loop variable i = 0</code> (this is executed once and only</strong> once</em> before anything else is done with the loop)</li> check condition i < 5</code></li> execute loop body</li> add 1</code> to i</code> in ++i</code> or i++</code></li> repeat from step 2</code></li> </ol> A little tip</a></h3> However, due to the nature of the operators and their precedence explained at the start of this post, ++i</code> is considered a slightly better programming practice. This is because i++</code> actually does this:</p> save the original value of i</code> to a temporary variable</li> add 1</code> to i</code> (the same as ++i</code>)</li> return the original value of i</code> stored in the temporary variable (++i</code> would return the new value since it doesn’t store the original value in any temporary variable)</li> </ul> So, in cases like in the for loop where it doesn’t make a difference in behavior, it just takes up some extra memory and is better avoided. Although, modern compilers are smart enough to catch this and optimize the code to mean the same.</p> Welcome to my blog cybardev — Tue, 19 Jan 2021 14:38:01 +0600 What's this about?</a></h2> Usually it's just going to be me and my thoughts. Won't be regular, but I do want to use this as a diary of sorts so might make frequent but short posts every now and then. I will mostly post about computers and technology since that is my field of interest. Sometimes I might also post about science and pop culture.</p> Who are you?</a></h2> An undergrad computer science student from Bangladesh who loves Linux and all things science and tech.</p> What do we have to do with all this?</a></h2> You could visit the site from time to time and read up some of my posts. Who knows, you might find something of interest. I might also put affiliate links in some tech posts. If you purchase anything from the site following those links (not necessarily the linked product), I will receive a small comission with no extra cost to you. It'd be a nice way to show your kind support.</p> Thanks~</strong></p>

Cy | Space

Losing Touch

cybardev — Mon, 11 May 2026 20:00:00 +0000

Ever felt yourself changing at a fundamental level, and slowly becoming a different person? Slowly... being unable to recognize yourself, becoming a stranger to your own mind?</p>

I hear adolescence is like that. But, maybe because I was so sheltered, it's only taking effect now.</p>

I don't code anymore... at least, not as much as I used to. I don't feel motivated to. It feels like I lost a core part of myself. Coding was the fibre of my being. Without code, who am I? It's something I'm having to come to terms with these days.</p>

It's good to diversify, not just in investing, but also in interests. Though, it didn't feel like it was in my control. Events in my life naturally led me to feel connected with coding; I couldn't just artificially grow feelings for new hobbies; at least not to the level of my affinity with coding.</p>

What is in my control, though, is "to love it enough to let it go". Nothing in life lasts forever; it's sad to see it pass me by, but I'm glad I ever did cross paths with it. Best I can do is keep experiencing life as it comes to me, and exploring my abilities however opportunity presents.</p>

Ofc, I will keep coding, when it comes to me naturally. But gone are the days of losing myself in projects, building, solving problems in my life with code. As life went on, my problems diminished (Alhamdulillah), but that did lead to some level of monotone. I do have some ideas of what I want to do next tho. Hopefully I'll find new love in something, or someone...</p>

Mini Homelab Self-hosting Setup

cybardev — Sat, 21 Mar 2026 16:00:00 +0000

Over December 2025 I set up a homelab with most of the cloud services I often use, on an old netbook that's weaker than a modern Raspberry Pi board. Since then it has evolved a bit too. This post is to document how I did it, why I did it, and what's in store for the setup going forward. Here, I'll share my experiences and decisions. If you're interested in setting up your own homelab, I hope this will serve as a useful guide and inspiration. Follow along with the code: github.com/cybardev/homelab</a></p>

</p>

Why</a></h2>
Privacy is an obvious point, and a common reason why people do this. For me it was a bit of that, but more so about keeping things more in my control. With tons of rugpulls all across the media and gaming industry, I just didn't want to wake up one day and find out my data is at risk of being deleted or held ransom and having to desperately scramble to move everything elsewhere in a race against time. It's just more comforting to know my stuff is physically around me, and/or even if it's (replicated) elsewhere, I'd have a copy of it. Also ended up being a nice learning experience, with lessons in container orchestration, resource management, niche Linux, and computer networking — all valuable skills, from what I've been informed.</p>
What</a></h2>
Here's the services I host/ed on my homelab. I say "host/ed" because some of them may not be there anymore because I either wanted to dedicate resources to something else, or switched to one or more alternatives (in any case, they're all listed, so you may find services with overlapping purpose).</p>

SearXNG</a></li>
Forgejo</a></li>
Nextcloud</a></li>
Vaultwarden</a></li>
Cloudflare Tunnel</a></li>
Cy | bot</a></li>
Cloudreve</a></li>
Radicale</a></li>
Cobalt</a></li>
Ente</a></li>
Tailscale</a></li>
4get</a></li>
Glances</a></li> </ul>
PS</strong>: Some of these depend on services like a database or cache. I mostly stuck to PostgreSQL</a> and Valkey</a> (a Redis fork).</p>
How</a></h2>
I will go over my thought process for how I selected which services to use, but if you want to dive right into the Compose files and guidance on how to set them up for yourself, here's the repository: github.com/cybardev/homelab</a></p>
Hardware</a></h3>
Acer Aspire One Happy 2</a> (2011) netbook laptop, with a single-core 1.66 GHz Intel Atom N450 and 1 GB of DDR2 RAM. Originally it had a 160 GB Seagate hard drive, but I later upgraded to a 1 TB HDD, and most recently, a 250 GB SSD, which it is currently using.</p>
Didn't have much to choose from. I just had my main laptop and this, and didn't want to buy anything new (for now). I do have another old laptop with much better spec, but last I tried it didn't boot. Might try again later. For now I want to focus on low power consumption and few high-priority services, though I'm increasingly feeling the need for more available RAM...</p>
Operating System</a></h3>
Given the humble hardware, I needed to choose something extremely lightweight. I wanted to choose one of the container-based distros like OpenSUSE MicroOS</a>, or Fedora CoreOS</a>, but the requirements still seemed a bit above what I could offer. So I settled on Alpine Linux</a>, which has been pretty solid. Some things are quirky, like `doas</code> instead of sudo</code>, and the lack of systemd</code> conveniences; but nothing showstopping.</p>`
`Ideally I would like to use` `NixOS</a>. That way I could deploy the services using NixOS modules, cutting out the middleman (containers). I will probably try that when I get the other laptop to work.</p>`
Alternatively, I might install Fedora Server</a> (yes, the regular one, not CoreOS) or Rocky Linux</a> or AlmaLinux</a>, and put Kubernetes (kind)</a> on top. It's likely overkill for my purposes, but I want to use this as an opportunity to learn hands-on how to provision infrastructure using Terraform</a>, set up a production environment using Ansible</a>, orchestrate containerized services with redundancy through replication and load-balancing using Kubernetes, all on an OS that's similar to the industry standard Red Hat Enterprise Linux (RHEL)</a>.</p>
`CoreOS would make it more convenient, but then I don't learn as much. For me, that's the fun part.</p>`
Network Proxy</a></h3> It wouldn't be too useful if I was out and about, and couldn't use my services. I needed a way to forward the active ports while not having a static IP. There's various ways of doing that: Cloudflare Tunnel, Tailscale, WireGuard, Dynamic DNS + Reverse Proxy (like nginx</a>); to name a few.</p> Cloudflare Tunnel</a> is what I started with. My domain is on Cloudflare, and the web UI is very simple to use. I was all set up in a few clicks (after starting the server container in host network mode, ofc). The issue, tho, is that Cloudflare makes the services public</em>. That is, anyone who knows the URL can use the service. This would not be an issue for most things due to auth, and I would actually like some services to be public use (like SearXNG). But on a 1 core CPU with <1GB RAM... it gets a bit iffy if many people try to use it simultaneously. So until I upgrade my hardware, I needed to keep my services to myself...</p> Enter Tailscale</a>. Tailscale is a VPN that uses WireGuard under the hood. It basically takes the setup step out of WireGuard</a>, providing a premade subset and/or superset of the features that works for many cases. If one needs finer control, WireGuard may be a better solution, but for my purposes this is fine (at least for now). Tailscale proxies my server's local network over the internet, through their servers, to whatever other devices are connected to the same "Tailnet", which is just their marketing term for a VPN. I use Tailscale clients on my main laptop and my phone, and only those devices (client and server both must be aithn'd to my Tailscale account) can access the URLs of my services (while connected to the VPN) that are hosted on the server. The Tailscale server software is also running as a compose container, with host-mode networking.</p> I could directly use WireGuard, but that would be more effort than I'm willing to invest at the moment. Same issue with DDNS and reverse proxy. I might revisit this in the future, even if at least for the sake of learning how those go.</p> The endgame idea I have is to rent a VPS and host Headscale</a> there, thus having (mostly) full control of the network traffic. Headscale is... well, Tailscale's client software (even the servers are actually clients, since they connect to the Tailscale backend) is open-source; but Tailscale's backend, the parts that actually route the network traffic, is proprietary (this is my understanding; feel free to correct me), so some person/folks in the community made Headscale, which can act as that routing backend. It needs a static IP though, so a VPS would be needed, if static IP can't be acquired from the ISP. I'll see what I do when I get to it.</p> Search Engine</a></h3> If you've read my last post (cybar.dev/blog/selfhost-searxng</a>), you're already familiar with what I'm doing for this. The only difference is that previously I was hosting it on my main laptop using a Home Manager Nix module, while now it's using a Docker Compose file running on the potato "server". Also wasn't using a cache previously but now there's Valkey.</p> I did give 4get</a> a try, but it seems like it's not ready for prime time yet. There's a lot of things that can't be configured declaratively and needs to be set up using cookies on the client side through the web UI. And for some reason the Startpage backend didn't support info widgets like Wikipedia preview. It's also been similar to SearXNG in terms of memory footprint, so I'd be getting a worse experience for not much resource efficiency.</p> Very recently I came across OmniSearch</a> (they need better SEO...). While I haven't tried it yet, it appears promising and I will try setting it up sometime soon and update in a separate post.</p> Files, Photos, Contacts, Calendar</a></h3> Nextcloud</a>. Easy, right? Last time when I did it on the same hardware, back in 2020 or 2021, it was fine because I dedicated the whole machine to this one service. Now that I'm trying to diversify my setup, using Nextcloud is difficult on such low RAM. It alone takes between 200-600 MB of RAM (probably more), and has caused the server to freeze at least once. Funny thing is, it happened as I was editing the compose file to limit memory usage. Prophetic. Anyway, added the limits but then it got extremely slow (possibly because it started using swap. I could tell it to not use swap, but... maybe that would lead to other problems? I just did not want to keep optimizing this one thing, so I started looking for alternatives.</p> For Calendar and Contacts, I did not have to look far. Radicle</a> is a lightweight CalDAV and CardDAV server which was trivial to set up. File sync, though, was a different beast...</p> I tried to set up OpenCloud</a> but the setup was a showstopper. I wanted something that would work with mostly</em> minimal effort. OpenCloud looked</em> like that's what it would be, but it was anything but. The opencloud-compose</a> repository had way too many modules, and used subpar ways to activate the modules. After a few gruelling days of trying to set it up according to docs and debugging the endless stream of errors, I decided to move on.</p> I dismissed OwnCloud</a> as being no lighter than Nextcloud, and OwnCloud Infinite Scale (OCIS)</a> as being no less complex than OpenCloud (due to OpenCloud being based on OCIS).</p> Was reluctant to try Seafile</a> due to the hardware requirements being listed as considerably above what I had. I should probably give it a try sometime. It looks promising, and listed requirements often overestimate in favour of ensuring what the developers consider good UX.</p> Ended up with Cloudreve</a> for now, using WebDAV-compatible apps for file management and sync. It's fairly lightweight, and was absolutely trivial to set up. Caveat: the native iOS mobile app used for photos sync is not FOSS. I'll need to figure out how to sync photos to WebDAV. Or, use a "better" photo backup solution, which is what I tried</em> to opt for.</p> Immich</a> seemed to be the most popular option for photo sync. But I recall that on their issue tracker, when encryption at rest was requested to prevent rogue server admins from accessing user photos, or the server being a point of data leak to malicious actors, the official stance was that they will not support encryption for the foreseeable future and since it's meant to be self-hosted, you would have to trust the server (since it is presumably under your control). To me, this is unacceptable (I mean it makes sense for the project, it just doesn't suit my needs), so I dismissed Immich.</p> Ente</a> felt like a better solution for my needs. I came across it from a post by Steven Deobald</a>, an acquaintance from HaliHax</a>, a local dev group. It's Free and Open-Source Software, is fully self-hostable, and has End-to-End Encryption (E2EE). Fantastic. Except... it uses MinIO (which is now deprecated), and trying to use a different S3-compatible storage backend has been... challenging, to say the least. Last I tried Garage</a> but I just couldn't get everything to work well together. I got uploads to work on the web for a bit, but not on mobile; then it stopped working on web too. For now I am focusing on other things but I intend to get back to it. Hopefully by then there will be official Ente docs and a Docker Compose file for setting up Ente with Garage or some other MinIO alternative.</p> Passphrase Manager</a></h3> For why I call it "passphrase" and not "password", see the wonderful xkcd#936</code> (linked below).</p> </blockquote> </a></p> Bitwarden</a> seems to be the most popular in this area so I went with that, except on the backend I use Vaultwarden</a> because it has some extra features, and more importantly, consumes significantly less resources (from what I've read online) due to being (re)written in Rust.</p> The experience has been great so far. The autofill works well, sync works well, the setup was simple and smooth. Not much to say.</p> Passphrases, passkeys, and MFA are some of the most important things to secure, so having them self-hosted with tunnelled internet access has been a great relief. I was using Apple Passwords before and now I'm quite happy with Bitwarden/Vaultwarden, and I highly recommend it to anyone looking to increase protections for their most important secrets.</p> Git Remote</a></h3> Forgejo</a> is the standard Git remote frontend most people use. There is also cgit</a> but it's a bit too barebones for me; I prefer a more GitHub-like experience. Hosting it has given me no issues, but the reason I decided to put it on hold for now is the effort required to move everything from GitHub to Forgejo, the visibility that GitHub provides (which I intend to remedy by setting up mirrors, but again, more effort), and most importantly, the resource limits of my humble hardware. I feel like once I upgrade my hosting computer, I can feel more confident putting more demanding services on it. For now the config is there but commented out (thus deactivated) for my homelab. I did give it a try though, and it worked fine. I'm looking forward to when I can commit to hosting it again.</p> Media Downloader</a></h3> Cobalt</a> is a self-hostable media downloader for sites like Twitter, Reddit, YouTube, etc. Easy to self-host, given the provided Compose file and detailed instructions. Oddly only the backend is self-hostable (for now). The frontend you would use the "official" one and input your backend's URL in the settings page. I find this setup to be a bit awkward and would've preferred hosting my own frontend, but it is what it is; life doesn't always go our way and that's okay.</p> Discord Bot</a></h3> Cy | bot</a> is a Discord bot I made for some simple tasks like sending a message from the bot, searching YouTube videos, creating formatted timestamps, etc. using Pycord</a> when I wanted to learn how to make Discord bots. It was a fun and easy process, especially given how good the Pycord documentation is, as well as their helpful community Discord. It's very easy to self-host too, which is to just run an executable as a service. I containerized it and added it as a Compose file to my homelab, and it has been working great.</p> Monitoring</a></h3> At first I thought of using the usual Prometheus</a>, Grafana</a>, etc. stack to learn their usage in a hands-on environment, but after reading online about the hardware requirements, I decided against it. After looking a bit more I came across Glances</a>. Imagine htop but with a web UI — that's Glances.</p> There's a lot of data streams enabled by default which I disabled. I mostly just care about resource usage and alerts if it crosses a threshold, and seeing which programs are causing the high consumption. It's been a solid experience, being able to monitor my homelab from anywhere without blowing up the hardware.</p> Future</a></h2> Some of the things on my to-do list for the homelab setup are:</p> Better hardware</strong>: I want to host more services, more reliably, which would need a more powerful server. Maybe if I get a new main laptop, I'll use my current M1 MacBook Air as a server. That would also allow me to host LLMs (using something like LM Studio</a>, unless Ollama</a> gets MLX support</a> by then), which may be convenient.</p> OS</strong>: if I use the MacBook I'll just use macOS with Docker/Podman</a>/containerd</a> on top, but if I get a PC server, I might try something like NixOS, AlmaLinux, Fedora CoreOS, or even Proxmox VE</a>.</p> Redundancy</strong>: on better hardware I could also have replicas, especially if I have a multi-server setup or a VPS along with my current server. Even if the services are not redundant, I would at least like the data to be backed up in multiple places. I want to look into Kubernetes too, when I get to the point o increasing the reliability of my server.</p> Security</strong>: I should be using full-disk encryption but I currently am not, which means if someone breaks into my room and yanks the homelab (which is just a little 11" laptop) and scrams with it in tow, they can access all the data directly off the SSD since it's not encrypted at rest. While my threat model is not so high that I am at a high risk of this happening, the chance is always there and it's best to prepare for such scenarios. I intend to do that, also on better hardware.</p> And more</strong>: I am constantly learning, so there may be more things I want to consider changing as my knowledge grows. Stay tuned~</p>



Self-hosting a Privacy-focused Search Engine
cybardev — Wed, 31 Dec 2025 12:48:00 +0000

  
  You might not have anything to hide, my friend.
But you have everything to protect.
  </blockquote>
  — Kevin D. Mitnick</strong>, The Art of Invisibility</cite></p>
</quote-block>
It has been over 6 years since I stopped using Google as my default search engine. For a long while I was on Ecosia, and then switched to Brave Search when they launched it. After learning of the active CEO's questionable conduct, I dropped Brave (both browser and search) and started using Firefox with Startpage. Of course, I wasn't satisfied. Especially after getting a viewport full of ad results one day, I decided I had enough and that it was finally time to self-host a search engine.</p>
Previously I tried making my own search frontend (github.com/cybardev/search</a>); while it "worked", it served a different purpose (mostly as a learning exercise on how APIs work). It wasn't much more than a Google search proxy. This time, I needed something more; something more powerful, more feature-rich. Something like... Websurfx</a>?</p>
When it comes to self-hosted web search engines, SearXNG</a> is no doubt the standard. However, it's a massive piece of software with a lot more features than I need in a program to find links on the web. I wanted something a bit more lightweight, and with a bit of looking around, came across Websurfx. It's a metasearch engine like SearXNG, but it's a lot more lightweight and focused, which I appreciated. It looked like a perfect match for my use case... until I tried to use it. The setup was straightforward; I even made a home-manager module to configure it using Nix. But no matter what I tried, I could not get it to perform queries consistently. I looked up on their issue tracker, and realized it was a known issue. That in itself should not raise alarms, but the trouble was that looking at the other issues, the commit history, etc. it looked like the project was practically abandoned. I even joined the Discord community to check if there was any activity, or support to make it work, but it was a futile effort. With a sigh I concluded it was time to move on...</p>
SearXNG seemed like the only other option left (feel free to suggest me otherwise). I gave it a trial run in an ephemeral Nix shell and was satisfied with the search experience, so I went ahead and made a home-manager module</a> copying some aspects of the NixOS module (but a lot simpler). Did this so I could have the same setup on both Linux (NixOS or otherwise) and Darwin. Over the next month or so I tweaked my SearXNG configuration, only keeping the engines and tabs I care about. I even set up Cloudflare Tunnel</a> through cloudflared</code> so I can access it over the internet (as long as the laptop is running the service).</p>
A few days ago I thought, it would be nice to host a public instance I can access even when the laptop is off, so I made github.com/cybardev/searxng-instance</a>. It's a set of deployment files, including a Dockerfile that uses the official SearXNG image as base with my configs injected, and a Render Blueprint</a> (their own IaC — infrastructure as code — solution), allowing one-click deployment of your own instance; simply click on the "Deploy to Render" button in the repository README. I also used Render Key Value</a> — a Redis-compatible Valkey instance — for cache. Though, due to using a free instance, the actual SearXNG service goes down after a while of unuse. For most people (especially those with a VPS), SearXNG's Docker Compose files</a> are recommended.</p>
If you're privacy-conscious and are looking for an alternative search engine, give SearXNG a try and see how it goes.</p>


Celebrating My First Nixversary
cybardev — Tue, 23 Dec 2025 16:44:00 +0000
Earlier this month I crossed the 1 year mark since I started using Nix in some way or other, and I wanted to take a moment to reflect and appreciate what a positive experience it has been. What started off as a little curiosity has now become a lifeline — a tool that actively boosts my productivity, and allows me to focus on what’s important. It’s also been impactful in helping me understand how my system works, and cutting down unnecessary bloat.</p>
On Linux land, I was used to doing apt install</code> or pacman -Syy</code> commands for package management. Since getting a Mac that changed to brew install</code>, but the flow remained the same — and so did the drawbacks. Run a command, install software, if you don’t use it then forget it exists. The more software you install, the harder it gets to prune. You start hoarding packages like paper rolls during COVID. Mid-to-late 2024 I was looking for ways to lighten up my Mac, after several system warnings about my measly 256GB of storage filling up. Nix promised a solution — declarative configs; you know exactly what’s installed, and installing new programs requires you to type it out so you have time to reconsider if you really need it. I was sold.</p>

Here, a little Nix primer may be appropriate for readers unfamiliar with its ecosystem. Nix is not a single software but a variety of interconnected things. There’s Nix the functional programming language, for Nix the declarative package manager, around which NixOS the Linux distribution was built. For macOS there’s Nix-Darwin and community projects like Nix-Homebrew. For user configuration management there’s Home Manager. And to make it more confusing than it already is, there’s two paradigms of package management via Nix — channels and flakes. Flakes use lockfiles to pin versions, while channels does no such thing — you either accept the lack of full reproducibility, or use community-supported version pinning systems like npins. Flake has its own drawbacks, like copying the entire source tree to the Nix Store every time. And yes, Nix Store is another Nix thing; it’s the volume where Nix stores its artifacts (software, configs, etc.), which is different from the Filesystem Hierarchy Standard (FHS) we see in most other forms of package management. Now back to my Nix journey.</p>
</blockquote>
First I wanted to gently test the waters, so I tried installing NixOS on my Surface Laptop (yeah, the first one, which needs a custom kernel built from source for all the components to work under Linux; and this one had a dead SSD and only one USB type-A port so I had to use a dongle to connect the installation drive and the USB drive that'd act as root; way to test the waters, I know). I could not for the life of me get manual installation to work, at least not through the minimal ISO (did not try with graphical ISO). Downloaded the graphical ISO and booted up Calamares (I later found out I could try manual install through graphical ISO; didn't occur to me back then but seems obvious now that I think about it). GUI install went fine and I was on a fresh XFCE installation. Splendid. As I usually do, I swapped out XFWM for BSPWM, since I prefer automatic BSP tiling. Took me some weeks to get it configured exactly how I wanted, with all the software I used. Set up Home Manager, which is a way to manage dotfiles and user services in Nix. And all this I did with the peace of mind that once I have my config ready, I could just run a git clone</code> on my Mac and have it there too (of course I VCS'd my nixos config; one should always VCS anything they care for). Until now I didn't put Nix on my Mac because I had Global Game Jam 2025 coming up and didn't want to risk it. Once that was taken care of, it was time to let the floodgates open.</p>
I factory reset my MacBook, after backing up important data, and downloaded Nix. The rest of the year has been an exhilarating blur of learn new aspects of Nix, getting more familiar with the philosophy, engaging with the community, and tweaking my configs. You can see everything that happened in the following two repositories:</p>

nix-dotfiles</code> (github.com/cybardev/nix-dotfiles</a>): my NixOS and Nix-Darwin configurations</li>
nix-channel</code> (github.com/cybardev/nix-channel</a>): my personal package/module repository</li>
</ul>
Other than that, here's a quick rundown of the highlight of my Nix journey:</p>

Became the maintainer of Meta’s Pyrefly (Python type checker and LSP) package on Nixpkgs.</li>
Made PR (awaiting review) to add and maintain Huggingface’s Git-Xet package.</li>
Crafted a multi-machine, multi-platform config with shared modules.</li>
Maintaining a personal Nix package and module set for stuff I find interesting but don’t quite want to commit to maintaining in upstream Nixpkgs.</li>
</ul>
That's the gist of it for now. I've been absolutely loving the Nix experience to the point where I don't see myself mov away from it anytime soon. If Asahi Linux supported display out over type-C, I'd love to run full-blown NixOS on my Mac. Till then, Nix-Darwin, Home Manager, and DevShells have me covered.</p>
In later posts I will cover the "tricky" bits of Nix and its ecosystem, such as Flakes, Home Manager, the Module System, DevShells, and more. Stay tuned~</p>


My New CMS Setup
cybardev — Thu, 04 Dec 2025 15:35:00 +0000
When I was still using Hugo</a> for my website, I had set up Netlify CMS (and then moved to Decap</a> when they changed the name), thinking it would help me write blogs more smoothly. And sure, the process was less cumbersome than opening up my local repository, firing up a code editor, writing some markdown, and going through the Git flow. But something just didn't stick, and I ended up doing that cumbersome process anyway instead of using the CMS. Soon after, I stopped posting altogether. Not surprising.</p>
This year, when I moved my site to Zola</a> with a custom template, I thought I wouldn't add a CMS, given my lackluster experience with them in the past. Recently though, I found myself writing (and wanting to write) more and more blog posts. Thanks to that, my flow of writing things in Apple Notes, copy-pasting to code editor, then pushing to Git was getting rather tedious and boring. I was on the lookout for a headless Git-based CMS that would reduce the friction — especially on mobile.</p>
For starters, I went back to Decap. I set it up with a Cloudflare Worker OAuth proxy</a> for authentication, so everything remains in my control (at no extra cost). It "worked", but the mobile experience was as bad as it was the last time I checked (about 2 years ago). I kept looking for a better solution.</p>
Enter Sveltia CMS</a>. This looked rather promising, but for some reason I was hesitant. That is, until they tagged me on Bluesky</a> asking me to give it a try. I'll be honest, I was initially taken aback by the overeager marketing, but the "Made in Canada 🇨🇦" hook softened me a bit. I looked into it further and decided to give it a try. It was mostly a one line change</a>, with some extra conveniences added on top. I pushed my changes, waited for CI to rebuild and publish, then visited the admin URL. What used to look like an outdated login screen from 2015, now looked… white? I was greeted with a fully blank screen. That's not a good sign…</p>
I scurried to the issue tracker for Sveltia, hoping to find a solution, in case I wasn't alone. Unfortunately (or maybe it is fortunate that people didn't have to deal with it), no one else raised the issue. But before opening an issue, I wanted to confirm that it wasn't my fault — that I wasn't just using a broken config or something. So I headed to their GitHub Discussions</a> and asked what may be causing this blank screen. Within the next 40 minutes, the lead developer of the project had a look, figured out the issue, suggested a solution, and improved on his suggestion. Amazing support.</p>
The issue was Cloudflare's Rocket Loader, which I had to disable for the CMS script. Once that was done, I had a beautiful login flow, and elegant CMS interface that looked great on both desktop and mobile. I was thoroughly impressed and satisfied with the switch.</p>
Now, more than ever before, I feel inspired to write on my blog. Thanks Sveltia, for bringing back the joy in writing.</p>



Hand-coding an SVG Pixel Art
cybardev — Tue, 02 Dec 2025 20:42:00 +0000
A few days ago I had the sudden idea of putting up a watermelon "stamp" on a corner of my website (which you may have noticed by now). At first I thought I'd do a quarter-circle, but then I remembered I already drew a watermelon pixel art before. I wanted to use that but, being the minimalist I am, wanted to have it in a much smaller file size without losing any fidelity. Also didn't want to use a low-res image, in case people wanted to zoom in. Thus I concluded that I should recreate the pixel art in vector format (SVG).</p>
Now, SVGs can be made in various software (like Inkscape), but I have found the workflow to be rather cumbersome for pixel art specifically. The snapping to grid is so bad it may not as well be there. I can never get things to align exactly how I want. So, not wanting to deal with that, I chose the option any sane person would (not) — write the SVG code myself.</p>
Thankfully I looked around for a bit before I set off on this arduous task, and came across this wonderful project that can be used to create pixel art SVGs</a>. The code is straightforward and they have a static webapp live on GitHub Pages, which is convenient. So I recreated the watermelon there and saved the SVG. Quick and easy. However, the size (~12 KB) was not much smaller than a high-enough resolution export of the raster version of the image (~16 KB). What gives?</p>
It turns out that the webapp, being so simple, included no optimization attempts. So next I set off to look for an SVG optimizer and came across the SVGOMG website</a>, which is a frontend for the SVGO command-line utility (and Node module)</a> that does SVG optimization by converting shapes to paths (among other things). It did reduce the file size by a good amount (to ~8 KB), but it was still not enough because of how inefficient the input code was to begin with. Now what?</p>
I thought of combining adjacent squares, but was having trouble visualizing what the optimal combination of rectangles would be. I went on MDN and looked up how SVGs work, to see if there was an easier way. Interestingly, there‘s a section on create SVGs from scratch</a>, which was super helpful. From it, I learned how to use the polygon ta and, after brainstorming what the layers would be like, set off on combining the squares into polygons. It was pretty easy but a bit cumbersome having to keep track of the coordinates, how the lines would join up, optimal shape construction, etc. I was using this SVG Playground website</a>, which was nice; it has a code editor and image preview pane, which was convenient. I managed to bring down the size to 2.6 KB. This was adequate, so I used SVGOMG to convert it to paths, which more than halved its size to ~900 bytes. Afterwards I added comments to clarify which path was which part/layer in the image, which brought up the size to 1.3 KB — still more than good enough for my purposes.</p>
A mistake I made at the start, which made the entire journey harder than it needed to be, was I made the SVG size 20x of the original pixel art. I thought it would make things easier but nope, larger numbers are more difficult to reason about; who would've thunk, eh? I did convert everything down to 20x17 px before the last optimization step though (after I converted everything to polygons). Lesson learned.</p>

UPDATE</strong>: I looked into it a bit more and realized, it wasn't entirely my fault. The SVG pixel art editor</a> I used to generate the initial SVG used 20px squares for each "pixel". I just didn't think of changing it till I was done with the whole process.</p>
</blockquote>
Here's the final SVG. I'm pretty proud of it. 😁</p>



How I “Deploy” My Resume
cybardev — Sun, 23 Nov 2025 23:20:32 -0400
I briefly went over how I generate my resume in my last blog post Year So Far — Bonus</a>. Here I want to expand on it and describe how I publish my resume on my website for easier sharing.</p>
What</a></h2>
Recently I switched from a custom resume builder (github.com/cybardev/resumake</a>) to Typst for building my resume. This allowed me to focus on my resume instead of having to maintain a program/module alongside it. After all, the best solutions are the simplest.</p>
With my previous solution, I generated a PDF resume and published it on a GitHub Pages website. I set up a similar (but of course much simpler) workflow for the new Typst resumes. Previously I also had only one resume at a time, but this time I wanted some more flexibility, so now I publish multiple resumes — one for each type of role I target.</p>
How</a></h2>
I wanted to learn Typst starting from the basics, so instead of using an off-the-shelf Typst resume template, I decided to make my own. It wasn’t that difficult, actually; much easier than it would be with LaTeX, and a lot more manageable than Markdown + CSS. It’s available at github.com/cybardev/resume-template-typst</a> with an MIT license. There’s a function for each element, like header, project, experience, education, etc. and they can be organized into sections easily with some basic Typst. There’s a helper function to compose the whole resume, but it has a specific layout that not everyone might like.</p>
After writing my resume using the above template, I set up my editors to automatically generate PDF previews on save, and for a while I used the PDFs generated this way for job applications. That was fine, but I still wanted to have a public link I could share around and put on my social profiles. So, I set out to create a GitHub Actions workflow to deploy it to a GitHub Pages website, like how its predecessor Resumake had. You can see the workflow file by clicking this link</a>. It generates a resume from each *.typ</code> file in the src/</code> directory with a filename like Resume_Sheikh_Saad_Abdullah_(${1}).pdf</code> where ${1}</code> is the basename of the .typ</code> file.</p>
There’s yet another layer to this. My DNS is set up to publish this GitHub Pages site on resume.cybar.dev</code>, so my resumes would be available like resume.cybar.dev/Resume_Sheikh_Saad_Abdullah_(${1}).pdf</code>. No one is going to type all that. So I set up URI redirect rules in Cloudflare so when people go to resume.cybar.dev/devops/</code>, it expands to resume.cybar.dev/Resume_Sheikh_Saad_Abdullah_(devops).pdf</code>, and so on.</p>
Something to note is that the trailing slash is necessary, i.e. resume.cybar.dev/devops/</code> works but resume.cybar.dev/devops</code> does not. This is because without the slash, Cloudflare would have to interpret it as a file and attempt to redirect the URI to another file (the PDF), but then that file would also cause a redirect, leading to infinite recursion. This is because I am on the Cloudflare Free plan which only supports wildcard matching; Business and Enterprise plans have access to regex matching, which would allow capturing URI with paths not ending in .pdf</code>.</p>

UPDATE</strong>: The trailing slash is no longer necessary. I restructured the generated site so resume.cybar.dev/*/</code> paths are directories with the generated PDF, and an index.html</code> that redirects to the PDF. It uses the <meta http-equiv="refresh"></code> tag to achieve this. You can see how it works in the GitHub Actions workflow file</a>.</p>
</blockquote>

NOTE</strong>: You might’ve noticed that the resume</code> repo is older than the template repo. That’s cuz I didn’t think of making the Typst resume module a template. At the time I was making it for myself and didn’t think of starting with a template first, then implementing it for my own resume. Oopsie~ :3</p>
</blockquote>
Why</a></h2>
At this point you might be wondering, why would anyone even want to go through all this effort just to get some resumes out? A similar effect can be achieved with something like MS Word for resume creation and Google Drive for storing and sharing.</p>
The issue with most rich text editors is that they add a lot of unnecessary metadata to PDF exports, which may confuse ATS resume parsers. It’s not a certainty but from what I’ve gathered, it’s safer to generate PDFs programmatically via LaTeX or such. Also, I find it a much nicer flow to edit my resume in Helix editor in the terminal; the shortcuts and motions are very useful. That, and being able to have a plaintext source file to track cleanly in Git adds to the convenience.</p>
Conclusion</a></h2>
If you’re already familiar with LaTeX and want to make resume generation easier, there’s services like Overleaf</a> that can reduce the pain. If the Typst resume flow catches your fancy, feel free to check out and use my template repository</a>.</p>
And, if you’re looking for a developer who can get things done, here’s my resume: resume.cybar.dev/devops/</a></p>


Year So Far — Bonus
cybardev — Sun, 10 Aug 2025 17:00:00 -0300
What’s this about?</a></h2>
Oftentimes I get so immersed in what I do, one thing after the other, I forget to take a step back and notice what I’ve accomplished. It’s important to do this from time to time, so when I feel down about not doing enough in moments of downtime, I have something to look at and go, “No, I am doing my best.”</p>
This is one such list, for what I’ve been up to this year till now. Here’s a glimpse into the life of Sheikh, halfway through 2025.</p>
The List, continued...</a></h2>
[Bonus Part]</em></p>
Honourable Mentions</a></h2>
Here are some things I did this year, but either don’t have a lot to talk about, or have moved on from. Regardless, the experiences I got from working on them have become a part of me, and I learned a lot, so I wanted to at least mention them.</p>
HabitMap</a></h3>
Wanted to make a habit tracker app with a heatmap calendar similar to the GitHub commit chart. Started making it in Flutter because I wanted to learn it, and I did make some good progress. A few weeks in though, I came to know about HabitKit</a> from a YouTube video. It looked like exactly what I wanted, so I stopped working on my project in favour of it. It wasn’t a waste though, as now I have some exposure to Flutter and understand the basics of how it works.</p>
Resumake</a></h3>
A long-running project that has served me well. It was a resume generator, first made in Python, and later translated to Go, containerized, published using GitHub Actions CI/CD workflow. Learned a lot making it, and got to use it for over 2 years to make my resumes, getting me two co-ops and a part-time job. Recently though, I got to know about Typst</a> — a LaTeX alternative that actually makes sense. The syntax lies somewhere between LaTeX and Markdown, so it’s the perfect mix of ease and power. Using it going forward for writing my resumes, cover letters, and any other PDF documents.</p>
Learning OpenTofu/Terraform from The Linux Foundation</a></h3>
I’m quite interested in DevOps, SRE, Platform Engineering, etc. and one major aspect of it is managing infrastructure as code through technologies like Terraform. It’s always been sort of a “black box” to me; I understood what it did and what it’s used for, but wasn’t sure how to get started with it. While looking up resources on it, I came across this certificate program from The Linux Foundation on OpenTofu — the Free and Open-source fork of Terraform. Best part? It’s free and takes only an hour. Did that, then took the exam while waiting for the bus. The course content was pretty nice and clear. Concise, but covering all the important points. Really helped me demystify the technology, and I was able to implement it for a real project (the Graphite image editor, mentioned a bit below). Definitely recommend the course if anyone else wants a quick start guide for Terraform/OpenTofu: Getting Started with OpenTofu (LFEL1009) — The Linux Foundation</a></p>
Packaging Meta’s Pyrefly in a Homebrew Tap</a></h3>
Similar to the nixpkgs, I wanted to learn how to package software for Homebrew</a> — a package manager (previously for macOS, but it’s available on Linux too now). Since I already had experience packaging Pyrefly, I thought this would be a nice complement. Followed the official documentation and ended up making this “Tap”, which is basically just a personal package repository for Homebrew: https://github.com/cybardev/homebrew-tap</a></p>
Deploy Personal Instance of Graphite</a></h3>
Graphite</a> is a fantastic Free and Open-source graphic editor that handles both</em> raster and vector graphics. I now prefer it over GIMP and Inkscape. It’s still in its early days, but already usable for all my needs. It is a webapp, so it doesn’t need to be installed locally, but it’s static, so all the processing is done client-side (even restoring previous sessions work using browser cache) — no account needed. Had to deploy it somewhere, so I chose Render. Tried to use OpenTofu and almost got it working, but then was hit with “you need a paid Render subscription” for Terraform deployments, so I just used Render Blueprint — their own infrastructure-as-code (IaC) solution, which is available on free tier too. It’s up now at gfx.cybar.dev</a> (cold start, so probably have to wait a bit).</p>
HaliHax/Collect. Side Projects Meetup</a></h3>
Every Monday evening I meet up with folks from a local developer group called HaliHax</a> for a few hours of coding. Think of it like “parallel play”</a> but for adults coding. This kind of environment helps me focus and provides a sense of accountability; really nice to get work done, be it serious stuff, or just some new exploration. Sandy Walsh is the host, but usually takes a break from it every summer. I still wanted to continue, so every Monday I ping the channel to gather anyone who’s interested. We meet at the same bar and get cracking. Recently, the side-projects event series has rebranded to be a part of the Collect. community</a>, which is nice. Now it’s called Collect. Mondays.</p>
Bonus</strong>: My friend Naziya drew a gorgeous banner for Collect. Monday events:</p>
</p>
Miscellaneous</a></h3>
Something major I did near the start of the year is started using Nix for package management, configuration management, locally running services, and development environments. It has been a life changing experience, but I want to dive deeper into it, so I’ll leave it for another blog post.</p>
Another thing I want to do is to switch to a locally hosted VCS server. Initially I was thinking Forgejo</a> but someone introduced me to soft-serve</a> and I might give that a try instead. I already started using Forgejo a little, but haven't moved anything over. Eventually I want everything primarily local, with repositories mirrored on GitHub.</p>
Also changed the following tools and technologies:</p>

GUI editor: VS Code (Codium) —> Zed</li>
TUI editor: Neovim —> Helix (evil-helix)</li>
Git client: gitui —> lazygit</li>
File Manager: yazi —> lf</li>
Shell: zsh —> fish</li>
</ul>
Reasons:</p>

Zed feels</em> snappier, and more within my control. Also isn't Electron bloat. Still keeping VS Code (Codium) around for backup though, and some more "involved" projects, especially if I work with people who use VS Code.</li>
Helix comes with sane defaults and doesn't need a minimum of 300+ lines for a usable setup.</li>
Lazygit has interactive rebase, and there's more information in one UI instead of being split over multiple tabs (just my preference; some may prefer the sparse layout of gitui).</li>
Yazi was becoming a pain. Too active development, too many breaking changes too often, and tries to do more than I need it for. It feels like it's trying to provide sane defaults like Helix, but it's not nice if the "defaults" change every other week. Lf, though more barebones, is much more stable, and mostly does what I want. I can tolerate it for now, at least until Yazi stops moving so fast.</li>
I used to use fish before zsh, and now I'm back again. It's just more ergonomic for interactive use, and there's a lot more builtin features that I used plugins for in zsh. Zsh is still my system shell; fish is only used in the kitty terminal and the integrated terminal in GUI editors.</li>
</ul>
And More to Come…</a></h2>
That’s all for what I did so far. As for what’s next…</p>
I’m currently learning Rust, to try to understand what has made it “the most loved language” for about a decade (StackOverflow Developer Survey</a>). Might do a project, or translate one of my older ones. If I like it, I’d like to try making some FOSS contributions with it.</p>
I’ve also been learning Go (the board game now; I’m already a bit familiar with the language). The interest arose after having seen it in a few wuxia manhuas (Chinese comics of the martial fantasy genre). It’s a really deep and fascinating game, whose simple rules hide a much more complex story. While it’s been more frustrating than fun (due to skill issue) so far, I’m looking forward to diving deeper into this super-interesting ancient strategy game that’s survived for millennia.</p>
Bonus</strong>: A friend of mine (Naziya, the one with the beautiful art) suggested the anime (Japanese animation) Hikaru no Go, which is all about the board game and apparently helpful for learning some of the foundations. Will hopefully watch it throughout this September.</p>
Sometime soon I’ll get back to my Game Jam game and make a release for Bubble Blaster DX. Just need to polish the existing mechanics and see how I can add to the gameplay experience without diverging from the original vision.</p>
With this series, I’m trying to get back to blogging, so will try to post every now and then. Writing down ideas helps consolidate learning, so looking forward to it. Hope you all enjoy reading these as much as I do writing. If you have any questions, ideas, suggestions, or just want to chat, feel free to reach out on my LinkedIn (linkedin.com/in/cybardev</a>) or send me an email at sheikh@cybar.dev</a></p>
And, having graduated, I am now on the lookout for a new role. If you or anyone you know is looking for an ever-growing and curious soul who loves learning, exploring, and solving problems, let’s connect — I’d love to hear from you.</strong></p>


Year So Far — Part 3
cybardev — Sun, 03 Aug 2025 19:48:00 -0300
What’s this about?</a></h2>
Oftentimes I get so immersed in what I do, one thing after the other, I forget to take a step back and notice what I’ve accomplished. It’s important to do this from time to time, so when I feel down about not doing enough in moments of downtime, I have something to look at and go, “No, I am doing my best.”</p>
This is one such list, for what I’ve been up to this year till now. Here’s a glimpse into the life of Sheikh, halfway through 2025.</p>
The List, continued...</a></h2>
[Part 3 of 3]</em></p>
Packaging Meta’s Pyrefly for Nixpkgs</a></h3>
End of May I came across Meta’s new Python type checker and LSP — Pyrefly</a>. By now I’ve been deep down the Nix rabbit hole, and realized there’s no Pyrefly package on nixpkgs, so if I wanted to use it through Nix, I’d have to package it myself. After making a package request issue on nixpkgs thinking that it was beyond my skills (having zero Rust experience), I suddenly felt adventurous and started working on it anyway, making a draft PR. With substantial help from the wonderful community on the (unofficial) Nix/OS Discord, I made significant progress. Then suddenly someone in the Discord said they have been using a custom package for a while, and theirs looked cleaner than what I had. So we chatted and agreed to co-author and co-maintain the package. I opened the PR (NixOS/nixpkgs#412863</a>) and, after some code review and improvements, it got merged. This was my biggest PR so far, and first time contributing to such a large open source project used by thousands of people. I learned a lot from this experience; most notably, git rebase --interactive</code>, mainly relying on this wonderful Atlassian article: git rebase | Atlassian Git Tutorial</a></p>
I also got the chance to speak with the Pyrefly team on Discord, and they were very helpful and cooperative during the packaging process. The tool has been working out great for me so far, but it's still alpha software, so there's a lot more to come; most notably, the LSP server is lacking a few features, and they rely on rust nightly, which is a big no-no for packaging for both nixpkgs and homebrew. We had to use a hacky workaround, setting the environment variable RUSTC_BOOTSTRAP</code> to 1</code> to get it to work on stable rust. They're working on it though, so hopefully it'll be ready soon. One of the team members also sent me some cool Pyrefly merch, (stickers and screen wipe pictured below, and a t-shirt of my size they asked by email), so that was really cool. Perks of contributing to open source.</p>
</p>
ShiftKey Algorithms and Leetcode</a></h3>
Once a week through June, I attended the Intro to Algorithmic Problem Solving course by ShiftKey at Dalhousie. It was taught by Yuhan Fu, an MCS Graduate from Dalhousie and also a TA there. She also has experience in research on Optimization Algorithms, participated and won multiple hackathons, and volunteering as a full-stack developer. On another side, she runs a K-pop dance cover team and teaches K-pop dance classes. With such a multi-talented teacher at the helm, classes were bound to be interesting. Topics we went through included Fundamental Data Structures and Complexity Analysis, Sorting and Recursion, Searching and Graphs, and Greedy and Dynamic Programming. I honestly learned a lot. Got (somewhat) over my distaste of Leetcode. Had fun with solving problems, and finally understood why so many people live by it. It is, however, not my path, since I got so burnt out by the end of it, I ended up not taking the exam, so I didn’t get the certificate from this course. This is the farthest I have gotten with algorithms though, so big respect to Yuhan and ShiftKey for helping me get through it.</p>
I wish Leetcode questions focused more on realistic scenarios instead of fantasy situations. For me, it is difficult to feel interested in things I don’t see the point of, especially if that thing requires high mental effort. I recently did a coding assessment for a company where the questions were similar to actual work one would do. One question required me to parse a Google Doc from a given URL and perform data manipulation operations on an embedded table using the pandas</code> Python library, then printing human-readable information to standard output. If DSA is so crucial for jobs, they should design questions that give us a glimpse of how these DSA could be used at work.</p>
Personal Website with semantic HTML</a></h3>
End of June, I decided to remake my website. Previously I was using a pre-made template for Hugo, but the template has been unmaintained since 2021. I wanted to make my site using pure HTML/CSS as much as possible, ensuring full functionality even with JavaScript disabled. I did that, and learned a lot about CSS animations, media queries, and used semantic HTML for the structure. At first I thought to just not have a blog on there, but while going through the other websites in the web ring I joined (nixwebr.ing</a>), I came across Zola, which is a much more minimal static site generator than Hugo, so I reconsidered using it to add back the blog. Did that (cybar.dev/blog</a>, which you are now reading), and as a bonus added a gallery section too (cybar.dev/gallery</a>); it now shows some of my favourite artwork (pixel art) right on my website. It wasn’t much work to break up the HTML file to match the Zola template structure, and ultimately the served files are still just HTML and CSS for the most part. JS is only used to detect and store dark/light theme preference. Overall, I’m quite satisfied with how it turned out. I especially like the breathing “bar” on the homepage; even use it to time breathing exercises sometimes, which is fun.</p>


Year So Far — Part 2
cybardev — Sat, 19 Jul 2025 13:48:00 -0300
What’s this about?</a></h2>
Oftentimes I get so immersed in what I do, one thing after the other, I forget to take a step back and notice what I’ve accomplished. It’s important to do this from time to time, so when I feel down about not doing enough in moments of downtime, I have something to look at and go, “No, I am doing my best.”</p>
This is one such list, for what I’ve been up to this year till now. Here’s a glimpse into the life of Sheikh, halfway through 2025.</p>
The List, continued...</a></h2>
[Part 2 of 3]</em></p>
Digital Nova Scotia — Skills For Hire: Cybersecurity</a></h3>
February I started a 16-week Cybersecurity course with Skills for Hire by Digital Nova Scotia. It was with this course that the ShiftKey course had a lot of overlap with, but that meant I could use one to consolidate the other. We had Pluralsight videos, weekly TA sessions, assignments, and career development webinars, all of which were super helpful.</p>
The Pluralsight videos helped me understand a lot better how computer networking works, and what their weaknesses could be, as well as how to cover them. I also learned about risk management — since it’s impossible (or at least not feasible) to perfectly secure all aspects of a system, it makes sense to prioritize mitigating certain risks while accepting others and planning to work around them. I liked that there were a ton of hands-on components that I could try out, like log file analysis, cryptography, network monitoring, etc.</p>
The program included a waiver for the ISC2 membership fees if we passed the ISC2 CC exam at the end of the course. More on that in a bit.</p>
Convocation Ceremony</a></h3>
In May, SMU held the convocation ceremony for Jan 2025 graduates. I have always had little interest and faith in formal education, especially in the memorization-favouring system that we currently have, which was created to produce uniform-minded factory workers and not creative individuals prepared for modern society. And all that at the cost of my parents’ hard-earned money and my fleeting sanity. I find the whole ordeal utterly ridiculous and a prime waste of resources. I would not, had we a more favourable world for humans, but alas that is not the world we live in. Regardless, I graduated, and hopefully made my parents happy. That’s all that matters to me for this chapter.</p>
It was definitely an interesting experience going up on stage and receiving the roll of paper that validated the four and some years of learning I just completed. Got some nice pictures taken, spent time with friends. I wish my parents could attend though; this was for them, after all.</p>
</p>
PS</em></strong>: I don’t dislike university, in fact I believe all stages of education should have the level of freedom and agency that university gives us (and that universities should have more</strong> freedom, especially in letting us ditch unrelated electives). However I am an avid hater of mid-term and final exams. I am largely in favour of intermittent testing and practical assessments.</em></p>
Just thought I should clarify. Moving on…</p>
ISC2 CC Certification Exam</a></h3>
Second week of June, I sat for the ISC2 CC exam. ISC2, or International Information System Security Certification Consortium (you can see why I’ve been abbreviating it thus far and will continue going forward), is one of the world’s leading training organizations in the field of cybersecurity. The “Certified in Cybersecurity” (CC) certificate is their entry-level offering, which they’ve been giving away for quite a while now. The catch is that after you pass you have to pay the annual membership fee of 50 CAD, which is still way</em> less than any other entry-level cybersecurity certifications that are worth doing (looking at you, CompTIA and Cisco).</p>
The 4-month training from DNS Skills for Hire, as well as the ShiftKey Cybersecurity course, were greatly helpful for this exam. Thanks to those I barely had to study. I wanted to, but I only took one practice exam and barely passed that, then procrastinated till there was no time left to study. Then I just said Bismillah (in the name of Allah; Muslims say this before starting things) and went on to wing it.</p>
It was fun, cuz the morning of exam day I got a call which woke me up, from the testing centre, saying someone cancelled their morning slot so I can come in earlier if I wanted to. I thought I might as well get it over with, since I don’t believe in studying right before exams (if I touch it, I will only recall what I just read and nothing else, which is why I’d rather not and keep it all equalized). Went to the place and the test was so intuitively easy, (likely thanks to the training/courses), I finished the 120 minute exam with 95 minutes remaining. I was afraid, though, since there were quite a few questions I just guessed the answer to; but I don’t like dwelling on a problem to boil my brain over something I may or may not know, so I just take a guess and move on to the next question.</p>
After the test, the examiner handed me a paper saying I passed. I was pleasantly surprised cuz of how fast the evaluation was. I shouldn’t be, because it’s just MCQ with known answers, but it’s not as common as it should be. A few days later I got the official certificate online, which you can see here: ISC2 CC — Credly Badge</a></p>
I don’t know what industry value this certificate holds, but I learned a lot — about IT, Networking, Cybersecurity, and more — in the process of getting it, so I consider this a great success.</p>


Year So Far — Part 1
cybardev — Mon, 14 Jul 2025 11:20:00 -0300
What’s this about?</a></h2>
Oftentimes I get so immersed in what I do, one thing after the other, I forget to take a step back and notice what I’ve accomplished. It’s important to do this from time to time, so when I feel down about not doing enough in moments of downtime, I have something to look at and go, “No, I am doing my best.”</p>
This is one such list, for what I’ve been up to this year till now. Here’s a glimpse into the life of Sheikh, halfway through 2025.</p>
The List</a></h2>
[Part 1 of 3]</em></p>
CELPIP Exam</a></h3>
Mid-January I took the CELPIP Exam in preparation for applying for my Post-Graduation Work Permit. It’s an English proficiency test comparable to IELTS, but the score band is up to 12 points, with 1:1 equivalence with the Canadian Language Benchmark (CLB) scoring system. I passed with 12 points in Listening and Writing, and 11 points in Reading and Speaking. With these results, I applied for my PGWP soon after.</p>
Global Game Jam</a></h3>
Last week of January I participated in the Global Game Jam for the 3rd time, but it was my first time doing it solo. Previously I had participated with friends, so it was quite a different experience. I had a lot of fun making a whole game from scratch in ~2.5 days, including the graphics.</p>
I always wanted to make a game for some old retro console, and seeing this as my chance I did just that. I chose Gameboy as my target platform and GB Studio as my engine of choice. It’s a great engine that’s easy to get started with, and one of the best way to make games for the original Gameboy and Gameboy Color. Even considering that I made the graphics from scratch while working solo, the whole game was done way ahead of time, and I had plenty of room for going around and seeing what wonderful games everyone else was making. Also met some great people from Ubisoft Halifax who gave me valuable feedback on how I can make my game even better. That’s what I’m looking to work on, now that the pressure is off.</p>
Try Bubble Blaster here: cybardev.itch.io/bubble-blaster</a></p>
ShiftKey Cloud Foundations</a></h3>
Once a week through February, I attended the Cloud Foundations course by ShiftKey at Dalhousie. It was taught by Vansh Sood, who previously taught a course on GenAI, that I enjoyed. This course was a nice overview of how cloud fits into the software ecosystem, and the various providers and services available. It was also meant to help prepare for the AWS Cloud Practitioner foundational certification exam. As such, the course was mainly focused on AWS, but counterparts in Azure and GCP were discussed briefly as well.</p>
I haven't taken the AWS exam yet. That's because I'm thinking of going straight to a more advanced certificate like Solutions Architect. Regardless, I'm sure the knowledge I've gained from this course will be helpful in my projects and beyond.</p>
ShiftKey Practical Cybersecurity</a></h3>
Once a week through March, I attended the Practical Cybersecurity course by ShiftKey at Dalhousie. It was taught by Aman Bhalla, a fellow student, but one with quite a bit of industry experience through co-ops and internships. I like that they have students teach these courses. Makes them approachable and they also know what we need because they're currently going through the same things but are a few steps ahead. We went through topics like Information Security, Threat Analysis, Encryption, Data Protection principles, Cybersecurity Frameworks, Applications Security, Ethical Hacking, and Legal Frameworks for Cybersecurity.</p>
I expected this course to be redundant due to another course I was doing at the time (started that one earlier), but this ended up accelerating my learning in that course.</p>
More on the other course in the next part of this series…</p>


Half-Life
cybardev — Tue, 23 May 2023 00:00:00 -0300
Schrödinger's Cat

Looks around curiously.

Its fate uncertain but it cares not

For it's unaware of its gravity.</p>
Schrödinger's Cat

It meows and yawns

And lays its head down.

Lush black fur, trimmed with care.

He slips into a slumber.</p>
Schrödinger's Cat

Will he die?

Or will he hold onto his nine lives?

Nobody knows, until

The observer takes a peek.</p>
Curiosity killed the cat, they say.

Was he ever even that curious?

He was trapped in a box,

With not much else

And nowhere to wander away.</p>
Schrödinger's Cat

The observer saw

Sleeping soundly.

His spirit in peace

Free from the bounds

Of the cold hard earth

That gifted him cruelty.</p>
He had a chance, they say,

Fifty-fifty - to pass on or to survive.

Till the lid was popped

He was half alive.

Or so the science said.

It wasn't his fault, definitely not.

Nor of the observer's eye.</p>
Tis but a twist of fate, just that

Nothing to do about it.

His spirit passed on,

Peacefully I hope.

All we can do is pray.</p>
Schrödinger's Cat

We say goodbye.

We bid farewell

With tears in our eyes.

But we forget him next day

And go on with our lives.

Like nothing ever happened.

It's as if he never existed.</p>
It's okay. Life goes on.

The tides of time

Wait for none.

I just hope that

Schrödinger's Cat

Is remembered sometimes

By someone.</p>


Java Lists
cybardev — Mon, 22 Mar 2021 22:36:56 +0600
PS: This post is structured similarly to my post about arrays</a>. I will also refer to array concepts, so you may want to read that first if you're new to Java collections.</em></p>
What are lists?</a></h2>
Think of lists like a row of cardboard boxes. These boxes can be used to store different types of data - ints</code>, Strings</code>, even custom data types like Person</code>. You can add more boxes to the row, remove boxes from the row, or even have no boxes at all!</p>
One important thing to note is that you can have a variable number of these boxes for each list you make. This is different from arrays, as arrays can only have a constant number of boxes. There are two main types of lists in Java - ArrayList and LinkedList. They can be used identically, but are very different in how they store data. While making the list, you'll need to tell Java which kind of list you'd like to have. If you tell Java that this list will have 10 items, then you will always be able to change its size later to accommodate more or less items.</p>
Making new lists</a></h2>
There are two ways of creating lists in Java as described below. Make sure you set the type of the variable as List and not ArrayList or LinkedList. This makes your code more modular and portable so that if you ever want to convert between ArrayList and LinkedList, you only need to change it in one place instead of having to re-factor the whole code.</p>

The first way</strong> creates a list of Strings without specifying initial items. The type of list must be specified between angle brackets (<</code>, ></code>).</li>
</ul>
List</span><</span>String</span>></span> fruits</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
//</span> or</span></span>
List</span><</span>String</span>></span> fruits</span> =</span> new</span> LinkedList</span><</span>></span>(</span>)</span>;</span></span></code></pre>
This way of making lists is best used when you don’t know what items the list should initially have, but you know the number of values may vary. An example of this may be in a program that asks the users for their grades throughout a course, and you don’t know the maximum number of tests there are in that course.</p>

The second way</strong> creates a list of 3 Strings, and here we're providing each box with an initial value (which can be changed later as needed).</li>
</ul>
List</span><</span>String</span>></span> fruits</span> =</span> new</span> ArrayList</span><</span>></span>(</span>Arrays</span>.</span>asList</span>(</span>"</span>Apple</span>"</span>,</span> "</span>Banana</span>"</span>,</span> "</span>Orange</span>"</span>)</span>)</span>;</span></span>
//</span> or</span></span>
List</span><</span>String</span>></span> fruits</span> =</span> new</span> LinkedList</span><</span>></span>(</span>Arrays</span>.</span>asList</span>(</span>"</span>Apple</span>"</span>,</span> "</span>Banana</span>"</span>,</span> "</span>Orange</span>"</span>)</span>)</span>;</span></span></code></pre>
Here's a visual representation of the second list:</p>
Box</th> Index</th> Item</th></tr></thead>

1</td> 0</td> Apple</code></td></tr>
2</td> 1</td> Banana</code></td></tr>
3</td> 2</td> Orange</code></td></tr>
</tbody></table>
This way is best used when you know what values you want to start with. An example of this may be when you want a list with the names of all the countries in the world. You could also make a list the first way and add values later, as I’ll show below.</p>
Manipulating list values</a></h2>

Adding values</u>:</li>
</ul>
Let's say you like to keep things clean and simple, and want to use the first way to make an list of countries.
How would you add the country names to the list?</p>
Here's how: listName.add(newValue);</code></p>
For example:</p>
List</span><</span>String</span>></span> countries</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
</span>
countries</span>.</span>add</span>(</span>"</span>Atlantis</span>"</span>)</span>;</span></span>
countries</span>.</span>add</span>(</span>"</span>Bangladesh</span>"</span>)</span>;</span></span>
//</span> and so on...</span></span>
countries</span>.</span>add</span>(</span>"</span>Wonderland</span>"</span>)</span>;</span></span></code></pre>

Modifying values</u>:</li>
</ul>
To re-assign</em> values, you’ll need to use the set</code> method:</p>
countries</span>.</span>set</span>(</span>1</span>,</span> "</span>Neverland</span>"</span>)</span>;</span></span></code></pre>
This will change the value of the 2nd box (at index 1) from Bangladesh</code> to Neverland</code>.</p>

Removing values</u>:</li>
</ul>
To remove the value at a specific index:</p>
countries</span>.</span>remove</span>(</span>1</span>)</span>;</span></span></code></pre>
To remove the first occurrence of the specified value:</p>
countries</span>.</span>remove</span>(</span>"</span>Neverland</span>"</span>)</span>;</span></span></code></pre>
To remove all occurrences of the specified value:</p>
countries</span>.</span>removeAll</span>(</span>"</span>Neverland</span>"</span>)</span>;</span></span></code></pre>Calling list elements</a></h2>
Just like how people can be called by their names, these elements</em> can be called by their indices</em>. Elements is a technical term for the values in the "boxes" and Index is a technical term for the "position" of the boxes, and the first box is at index 0. So, the n^th^ box will always be at index (n-1)</code>, as long as n is at least 1.</p>
To access the nth list element in Java, simply call it by its index using the get</code> method, like fruits.get(1)</code>.</p>
An example of it in action:</p>
System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>.</span>get</span>(</span>1</span>)</span>)</span>;</span></span></code></pre>
This would print Banana</code> to the console. Banana is the 2nd</code> element, so its index is 2 - 1 = 1</code>.</p>
Length of a list</a></h2>
After all that creating, assigning and calling lists and their elements, you might not remember what the length of each one is. Well, fear not, because Java has you covered. Lists have a handy little getter method that you can use to know the length of a list. To access it, simply use listName.size()</code>.</p>
For example:</p>
System</span>.</span>out</span>.</span>println</span>(</span>countries</span>.</span>size</span>(</span>)</span>)</span>;</span></span>
//</span> output: 195</span></span>
</span>
System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>.</span>size</span>(</span>)</span>)</span>;</span></span>
//</span> output: 3</span></span></code></pre>Sorting lists</a></h2>
In case you assigned the names of the countries randomly and now want them sorted in alphabetical order, you can use the Collections.sort()</code> method from the java.util.Collections</code> class.</p>
Here's how to use it:</p>
import</span> java</span>.</span>util</span>.</span>Collections</span>;</span></span>
</span>
//</span> create the unsorted list of countries here</span></span>
</span>
Collections</span>.</span>sort</span>(</span>countries</span>)</span>;</span></span>
</span>
//</span> the list "countries" is now sorted</span></span></code></pre>
This will also sort numbers in numerical order, and other types in their natural order. It will also sort custom data types implementing the Comparable</code> interface as defined in their compareTo</code> method.</p>
Looping over lists</a></h2>
The process of looping through collections like lists, lists, sets, etc. is also known as iterating</em>. When we iterate</em> over an list, we're simply checking the value in each box of the list one by one and usually performing the same actions with each value, unless specified otherwise by some logic control (if-else</code> and such).</p>
There are a few ways to iterate over lists:</p>

Traditional for</code> loop:</li>
</ul>
String</span> country</span>;</span></span>
for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> countries</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
    if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span>
        country </span>=</span> countries</span>.</span>get</span>(</span>i</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
    }</span> else</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span></span>
            "</span>The answer to life, the universe </span>"</span></span>
            +</span> "</span>and everything...</span>"</span></span>
        )</span>;</span></span>
    }</span></span>
}</span></span></code></pre>

for-each</code> loop:</li>
</ul>
for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span>
    System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
}</span></span></code></pre>

while</code> loop:</li>
</ul>
int</span> i</span> =</span> 0</span>;</span></span>
String</span> country</span>;</span></span>
while</span> (</span>i </span><</span> countries</span>.</span>length</span>)</span> {</span></span>
    if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span>
        country </span>=</span> countries</span>.</span>get</span>(</span>i</span>)</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
    }</span> else</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span></span>
            "</span>The answer to life, the universe </span>"</span></span>
            +</span> "</span>and everything...</span>"</span></span>
        )</span>;</span></span>
    }</span></span>
    i</span>++</span>;</span></span>
}</span></span></code></pre>
As you can see, while the for-each</code> loop makes life easier for simple iterations, you have slightly less control over things as it doesn't give you the index easily. We can, however, mitigate that problem by using a variable to track the index, like in the while</code> loop:</p>
int</span> i</span> =</span> 0</span>;</span></span>
for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span>
    if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
    }</span> else</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span></span>
            "</span>The answer to life, the universe </span>"</span></span>
            +</span> "</span>and everything...</span>"</span></span>
        )</span>;</span></span>
    }</span></span>
    i</span>++</span>;</span></span>
}</span></span></code></pre>
Or you could just use the while loop.</p>
However, this kind of for-each</code> loop does have an advantage. The variable country</code> is created and used within the scope of this loop alone, so you can create a variable with the same name outside the scope and use it without conflicts. It can be done in the other loops too, but is much cleaner, easily readable and more efficient this way. Do note that the variable to track index, i</code>, is declared outside the scope of the for-each</code> loop, so make sure to be careful about that later. Next time you want to use it in that scope, you should reset it to 0</code> before you perform any operations with it, unless you actually want to retain the value it has after going through the loop.</p>
It's often important to choose the correct loop for the task at hand. Take a deep breath, relax and think about which loop might put you at an advantage.</p>
A better way to iterate</a></h2>
If you tried to modify list elements inside loops and had your program crash with a ConcurrentModificationException</code>, no need to panic. It’s just Java being cautious so that nothing weird happens in the program. To get around this, we need to use list iterators and the methods that come with them which we can use to manipulate the list safely.</p>
“With great power comes great responsibility.”
- Uncle Ben</em></p>
Here’s a little text filtering program to demonstrate ListIterator</code>s in action:</p>
import</span> java</span>.</span>util</span>.</span>ArrayList</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>List</span>;</span></span>
import</span> java</span>.</span>util</span>.</span>ListIterator</span>;</span></span>
</span>
public</span> class</span> FilterLines</span> {</span></span>
    public</span> static</span> void</span> main</span>(</span>String</span>[</span>]</span> args</span>)</span> {</span></span>
        //</span> create variables</span></span>
        List</span><</span>String</span>></span> lines</span> =</span> new</span> ArrayList</span><</span>></span>(</span>)</span>;</span></span>
        ListIterator</span><</span>String</span>></span> linesIterator</span>;</span> //</span> declare the iterator</span></span>
        String</span> currentLine</span>;</span></span>
</span>
        //</span> add lines to the list of lines to filter</span></span>
        lines</span>.</span>add</span>(</span>"</span>There was a line with the word bad here.</span>"</span>)</span>;</span></span>
        lines</span>.</span>add</span>(</span>"</span>There was another bad line here.</span>"</span>)</span>;</span></span>
        lines</span>.</span>add</span>(</span>"</span>This line will stay as is.</span>"</span>)</span></span>
        lines</span>.</span>add</span>(</span>"</span>Here's a good line.</span>"</span>)</span>;</span></span>
        lines</span>.</span>add</span>(</span>"</span>Have a good day!</span>"</span>)</span>;</span></span>
</span>
        //</span> code to filter the lines</span></span>
        linesIterator </span>=</span> lines</span>.</span>listIterator</span>(</span>)</span>;</span> //</span> assign the iterator</span></span>
        while</span> (</span>linesIterator</span>.</span>hasNext</span>(</span>)</span>)</span> {</span></span>
            currentLine </span>=</span> linesIterator</span>.</span>next</span>(</span>)</span>;</span></span>
            if</span> (</span>currentLine</span>.</span>contains</span>(</span>"</span>bad</span>"</span>)</span>)</span> {</span></span>
                linesIterator</span>.</span>remove</span>(</span>)</span>;</span></span>
            }</span> else</span> if</span> (</span>currentLine</span>.</span>contains</span>(</span>"</span>good</span>"</span>)</span>)</span> {</span></span>
                linesIterator</span>.</span>set</span>(</span>currentLine</span>.</span>toUpperCase</span>(</span>)</span>)</span>;</span></span>
            }</span></span>
        }</span></span>
</span>
        //</span> print out the lines</span></span>
        for</span> (</span>String</span> line</span> :</span> lines</span>)</span> {</span></span>
            System</span>.</span>out</span>.</span>println</span>(</span>line</span>)</span>;</span></span>
        }</span></span>
    }</span></span>
}</span></span></code></pre>
PS</strong>: It's important to assign the list iterator right before iteration as on line 20</code>. It can be declared beforehand, though, as on line 9</code>. This is because the listName.listIterator()</code> method gets the current</strong> state of the list and creates a ListIterator</code> object out of it. Changes you make directly to the list will not update the iterator and may result in unexpected behaviour.</p>
Running the above program produces the following output:</p>
This line will stay as is.</span></span>
HERE'S A GOOD LINE.</span></span>
HAVE A GOOD DAY!</span></span></code></pre>
As you can see, the lines with “bad” were removed and the lines with “good” were converted to uppercase.</p>
Check for identical lists</a></h2>
Now that you've made some lists, you might want to check if two lists contain the same things. We could of course make a method to compare two given lists using loops and if-else</code> control, but that would be too much work. Thus, the equals</code> method will certainly come in handy and take some load off our shoulders.</p>
Here's how it works:</p>
//</span> make a list, countries</span></span>
//</span> make a list, fruits</span></span>
</span>
boolean</span> isEqual</span> =</span> countries</span>.</span>equals</span>(</span>fruits</span>)</span>;</span></span>
</span>
System</span>.</span>out</span>.</span>println</span>(</span>isEqual</span>)</span>;</span></span>
//</span> output: false</span></span>
</span>
//</span> output will be "true" if the given lists are equal</span></span></code></pre>Helpful resources</a></h2>
Here are some resources I use to learn Java. I don't memorise anything, but rather just look them up when I need to. They're all great sites to learn Java (some have other languages too) and I hope you find them helpful.</p>

Java 8 docs of the List interface</a></li>
Java 8 docs of the ArrayList class</a></li>
Java 8 docs of the LinkedList class</a></li>
Java 8 docs of the ListIterator interface</a></li>
SoloLearn</a></li>
GeeksforGeeks</a></li>
W3schools</a></li>
tutorialspoint</a></li>
Javatpoint</a></li>
</ul>
Conclusion</a></h2>
That's all about lists for now. That should cover the basics of lists, but do let me know in the comments if I've missed something or made a mistake somewhere.</p>
I hope it was helpful for you. Thanks for reading through. See you later.</p>


My Experience with Online Learning
cybardev — Mon, 22 Mar 2021 13:29:40 +0600
My Story</a></h2>
I'm currently an undergraduate student studying at Saint Mary's University, Nova Scotia, Canada. As my major, I've chosen Computer Science (they call it computing science, but it's practically the same thing), as I had a keen interest in computers, science and technology from a very young age. Because of the ongoing pandemic, our school has decided to provide online classes with some optional in-person experiences. To save money on residence, food and other costs, I've decided to do online classes from Bangladesh until in-person classes fully begin. Here's my experience with online learning thus far.</p>
The Woes</a></h2>
Online classes can be hectic, especially if your school is on the other side of the globe. Ideally, you'd want to start your morning with classes, take some rest and start working on your assignments in the afternoon or evening. With online classes, I'm having to do the opposite - assignments in the morning, get exhausted from all the work, barely have any energy for classes in the evening/night. On Wednesday nights (or Thursday morning) at 3 AM, I have a 2 hr recitation class too, so that's not helping my health either.</p>
The Joys</a></h2>
That being said, I'm loving the different atmosphere of foreign universities. The teachers are mostly extremely helpful (not all though) and I'm glad to say my CS professor is the most joyful and inspiring character I've met out of all the professors there (Maths professor is the least, sadly). That teacher has humour, intellect, experience, a Ph.D. (of course he does) and is a complete joy to learn from. I'm glad I got him from the first year in my major course.</p>
Make Friends</a></h2>
I'm also enjoying the virtual company of my peers, although I'd love to meet them in person. As that's currently impossible, this is the best we can get. I'm thrilled to be able to share ideas and converse with so many people with similar interests and passions. I've also been able to build up a Discord server of 230+ students (many inactive accounts, but whatever. I tried). The owner of the server was kind enough to let me handle it when it was only about 20 people, and together, myself, the owner, and a senior at SMU were able to build it up to what it is today, with a little help from some of the members. Now we have different channels for different courses, reaction roles so that we can choose what course channels we can see and of course, many enthusiastic and active members.</p>
Explore Opportunities</a></h2>
I've even become part of a team of enthusiastic CS undergrads and we're hopefully set to make a little project of ours - a visual novel game - to practice our skills, learn new ones and get some hands-on experience in working with a team on a real project. A good idea if you're looking to build up your portfolio and have a good first impression on potential employers.</p>
Time Management</a></h2>
Make sure you use your time wisely though, as scheduling is very important. If you procrastinate, it becomes very difficult to cope up with the horde of assignments, quizzes, tests, recitations and everything else the University throws at you. Even though I managed to do a 2-month assignment in 2 days and still scored 28 out of 30 (don't be me. it was insanely exhausting). Be on top of your schedule and you'll be fine.</p>
Mental Health</a></h2>
Many universities, including mine, offer many free workshops and counselling sessions throughout the course of the degree. Make sure you take full advantage of these and always mail the advisors, counsellors and professors whenever you're in a pinch. They're really helpful and understanding and will patiently guide you through whatever you're having trouble with. Also, please do keep a check on your mental health. Many students face issues for a variety of reasons and there are often free counselling sessions available. Make your money worth it, and don't neglect yourself.</p>
Your Story</a></h2>
Something important some of us forget to do in school is building up a network of peers, seniors and professors, and make memories that enrich your life. While grades are pretty important still (because we study in an education system for the 1800s), these human resources are such that they can bring a lot more value to your life. University is the time to explore your interests, so make some friends, do personal projects, join or form clubs and enjoy your time.</p>
THIS IS YOUR TIME TO SHINE. DO YOUR BEST. (^_^)</strong></p>


Java Arrays
cybardev — Mon, 08 Mar 2021 16:03:05 +0600
What are arrays?</a></h2>
Think of arrays like a row of cardboard boxes. These boxes can be used to store different types of data - ints</code>, Strings</code>, even custom data types like Person</code>.</p>
One important thing to note is that you can only have a constant number of these boxes for each array you make. While making the array, if you tell Java that this array will have 10 items, then that array will always be able to contain up to 10 items - no more, no less, no changes to this size. You can store less than 10 items in that array and leave the others at default value (to change them later), but this might have weird effects on your program and is better avoided.</p>
Making new arrays</a></h2>
There are two ways of creating arrays in Java:</p>

The first way</strong> creates an array of Strings with a fixed number of the "boxes" (3 in the example below), and each box contains a default value given to it by Java. For String arrays like this one, that value is null</code>, which isn't actually a String, but you can read more on that here</a>.</li>
</ul>
String</span>[</span>]</span> fruits</span> =</span> new</span> String</span>[</span>3</span>]</span>;</span></span></code></pre>
Here's a visual representation of the first array:</p>
Box</th> Index</th> Item</th></tr></thead>

1</td> 0</td> null</code></td></tr>
2</td> 1</td> null</code></td></tr>
3</td> 2</td> null</code></td></tr>
</tbody></table>
This way of making arrays is best used when you know how many items the array should have, but you don't know what the values will be. An example of this may be in a program that asks the users for their grades throughout a course, and you know the maximum number of tests there are in that course.</p>

The second way</strong> creates an array of 3 Strings too, but here, we're providing each box with an initial value, instead of keeping the default value.</li>
</ul>
String</span>[</span>]</span> fruits</span> =</span> {</span>"</span>Apple</span>"</span>,</span> "</span>Banana</span>"</span>,</span> "</span>Orange</span>"</span>}</span>;</span></span></code></pre>
Here's a visual representation of the second array:</p>
Box</th> Index</th> Item</th></tr></thead>

1</td> 0</td> Apple</code></td></tr>
2</td> 1</td> Banana</code></td></tr>
3</td> 2</td> Orange</code></td></tr>
</tbody></table>
This way is best used when you know what values you want to start with. An example of this may be when you want an array with the names of all the countries in the world. It would be rather painful if you first made an array of nearly 200 Strings with default value and then added each country name individually.</p>
Assigning values to arrays</a></h2>
Let's say you're very hard working and like to take challenges, and want to use the first way to make an array of countries. How would you set the values to be country names instead of null</code>?</p>
Here's how: arrayName[index] = newValue;</code></p>
For example:</p>
String</span>[</span>]</span> countries</span> =</span> new</span> String</span>[</span>195</span>]</span>;</span></span>
</span>
countries</span>[</span>0</span>]</span> =</span> "</span>Atlantis</span>"</span>;</span></span>
countries</span>[</span>1</span>]</span> =</span> "</span>Bangladesh</span>"</span>;</span></span>
//</span> and so on...</span></span>
countries</span>[</span>194</span>]</span> =</span> "</span>Wonderland</span>"</span>;</span></span></code></pre>
You can also use this to re-assign</em> values:</p>
countries</span>[</span>1</span>]</span> =</span> "</span>Neverland</span>"</span>;</span></span></code></pre>
This will change the value of the 2nd box (at index 1) from Bangladesh</code> to Neverland</code>.</p>
Calling array elements</a></h2>
Just like how people can be called by their names, these elements</em> can be called by their indices</em>. Elements is a technical term for the values in the "boxes" and Index is a technical term for the "position" of the boxes, and the first box is at index 0. So, the (n)th box will always be at index (n-1), as long as n is at least 1.</p>
To access the nth array element in Java, simply call it by its index, like fruits[1]</code>.</p>
An example of it in action:</p>
System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>[</span>1</span>]</span>)</span>;</span></span></code></pre>
This would print Banana</code> to the console. Banana is the 2nd</code> element, so its index is 2-1 = 1</code>.</p>
Length of an Array</a></h2>
After all that creating, assigning and calling arrays and their elements, you might not remember what the length of each one is. Well, fear not, because Java has you covered. Arrays have a really nice property that you can use to know the length of an array. When each array is created, it's assigned an instance variable with the name length</code> that stores how many items there can be in the array. To access it, simply use arrayName.length</code>.</p>
For example:</p>
System</span>.</span>out</span>.</span>println</span>(</span>countries</span>.</span>length</span>)</span>;</span></span>
//</span> output: 195</span></span>
</span>
System</span>.</span>out</span>.</span>println</span>(</span>fruits</span>.</span>length</span>)</span>;</span></span>
//</span> output: 3</span></span></code></pre>Sorting Arrays</a></h2>
In case you assigned the names of the countries randomly and now want them sorted in alphabetical order, you can use the Arrays.sort()</code> method from the java.util.Arrays</code> class.</p>
Here's how to use it:</p>
import</span> java</span>.</span>util</span>.</span>Arrays</span>;</span></span>
</span>
//</span> create the unsorted array of countries here</span></span>
</span>
Arrays</span>.</span>sort</span>(</span>countries</span>)</span>;</span></span>
</span>
//</span> the array "countries" is now sorted</span></span></code></pre>Looping over arrays</a></h2>
The process of looping through collections like arrays, lists, sets, etc. is also known as iterating</em>. When we iterate</em> over an array, we're simply checking the value in each box of the array one by one and usually performing the same actions with each value, unless specified otherwise by some logic control (if-else</code> and such).</p>
There are a few ways to iterate over arrays:</p>

Traditional for</code> loop:</li>
</ul>
String</span> country</span>;</span></span>
for</span> (</span>int</span> i</span> =</span> 0</span>;</span> i </span><</span> countries</span>.</span>length</span>;</span> i</span>++</span>)</span> {</span></span>
    if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span>
        country </span>=</span> countries</span>[</span>i</span>]</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
    }</span> else</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span></span>
            "</span>The answer to life, the universe </span>"</span></span>
            +</span> "</span>and everything...</span>"</span></span>
        )</span>;</span></span>
    }</span></span>
}</span></span></code></pre>

for-each</code> loop:</li>
</ul>
for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span>
    System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
}</span></span></code></pre>

while</code> loop:</li>
</ul>
int</span> i</span> =</span> 0</span>;</span></span>
String</span> country</span>;</span></span>
while</span> (</span>i </span><</span> countries</span>.</span>length</span>)</span> {</span></span>
    if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span>
        country </span>=</span> countries</span>[</span>i</span>]</span>;</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
    }</span> else</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span></span>
            "</span>The answer to life, the universe </span>"</span></span>
            +</span> "</span>and everything...</span>"</span></span>
        )</span>;</span></span>
    }</span></span>
    i</span>++</span>;</span></span>
}</span></span></code></pre>
As you can see, while the for-each</code> loop makes life easier for simple iterations, you have slightly less control over things as it doesn't give you the index easily. We can, however, mitigate that problem by using a variable to track the index, like in the while</code> loop:</p>
int</span> i</span> =</span> 0</span>;</span></span>
for</span> (</span>String</span> country</span> :</span> countries</span>)</span> {</span></span>
    if</span> (</span>i </span>!=</span> 42</span>)</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span>country</span>)</span>;</span></span>
    }</span> else</span> {</span></span>
        System</span>.</span>out</span>.</span>println</span>(</span></span>
            "</span>The answer to life, the universe </span>"</span></span>
            +</span> "</span>and everything...</span>"</span></span>
        )</span>;</span></span>
    }</span></span>
    i</span>++</span>;</span></span>
}</span></span></code></pre>
Or you could just use the while loop.</p>
However, this kind of for-each</code> loop does have an advantage. The variable country</code> is created and used within the scope of this loop alone, so you can create a variable with the same name outside the scope and use it without conflicts. It can be done in the other loops too, but is much cleaner, easily readable and more efficient this way. Do note that the variable to track index, i</code>, is declared outside the scope of the for-each</code> loop, so make sure to be careful about that later. Next time you want to use it in that scope, you should reset it to 0</code> before you perform any operations with it, unless you actually want to retain the value it has after going through the loop.</p>
It's often important to choose the correct loop for the task at hand. Take a deep breath, relax and think about which loop might put you at an advantage.</p>
Check for identical arrays</a></h2>
Now that you've made some arrays, you might want to check if two arrays contain the same things. We could of course make a method to compare two given arrays using loops and if-else</code> control, but that would be too much work. Thus, the Arrays.equals()</code> method will certainly come in handy and take some load off our shoulders.</p>
Here's how it works:</p>
import</span> java</span>.</span>util</span>.</span>Arrays</span>;</span></span>
</span>
//</span> make an array, countries</span></span>
//</span> make an array, fruits</span></span>
</span>
boolean</span> isEqual</span> =</span> Arrays</span>.</span>equals</span>(</span>countries</span>,</span> fruits</span>)</span>;</span></span>
</span>
System</span>.</span>out</span>.</span>println</span>(</span>isEqual</span>)</span>;</span></span>
//</span> output: false</span></span>
</span>
//</span> output will be "true" if the given arrays are equal</span></span></code></pre>Helpful resources</a></h2>
Here are some resources I use to learn Java. I don't memorize anything, but rather just look them up when I need to. They're all great sites to learn Java (and other languages) and I hope you find them helpful.</p>

SoloLearn</a></li>
GeeksforGeeks</a></li>
W3schools</a></li>
tutorialspoint</a></li>
Javatpoint</a></li>
</ul>
Conclusion</a></h2>
That's all about arrays for now. That should cover the basics of one-dimensional arrays, but do let me know in the comments if I've missed something or made a mistake somewhere.</p>
I hope it was helpful for you. Thanks for reading through. See you later.</p>


Prefix (++i) vs Postfix (i++) Operators in Code
cybardev — Sun, 24 Jan 2021 21:40:48 +0600
The dilemma: ++i</code> vs i++</code></a></h2>
In C-style languages (C, C++, Java, etc.), the operators ++</code> and --</code> are used to add or subtract 1</code> from a variable. ++</code> is called the “increment” operator, and --</code> is called the “decrement” operator. If the operator is put before the variable, as in ++i</code>, it’s called a “prefix” operator. If the operator is put after the variable, as in i--</code>, it’s called a “postfix operator” or “suffix operator”. Here’s a table to help visualize all that:</p>
Operator</th> Name</th></tr></thead>

i++</code></td> Postfix increment operator</td></tr>
i--</code></td> Postfix decrement operator</td></tr>
++i</code></td> Prefix increment operator</td></tr>
--i</code></td> Prefix increment operator</td></tr>
</tbody></table>
The prefix and postfix operators do the same thing but have different operator precedence compared to the assignment operator. This can lead to your code having unexpected behavior when an increment/decrement operator is used in conjunction with the assignment operator. To demonstrate, I’ll show you some examples below.</p>
Standalone use</a></h3>

increasing the value of a variable using ++</code></li>
</ul>
#</span>include</span> <</span>stdio.h</span>></span></span>
int</span> main</span>(</span>)</span> {</span></span>
    int</span> x </span>=</span> 0</span>;</span></span>
    x</span>++</span>;</span></span>
    printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span>
}</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span>
int</span> main</span>(</span>)</span> {</span></span>
    int</span> x </span>=</span> 0</span>;</span></span>
    ++</span>x</span>;</span></span>
    printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span>
}</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span>
int</span> main</span>(</span>)</span> {</span></span>
    int</span> x </span>=</span> 0</span>;</span></span>
    x </span>=</span> x </span>+</span> 1</span>;</span> //</span> or x += 1;</span></span>
    printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span>
}</span></span></code></pre>
The above codes all have the exact same effect: increase the value of x</code> by 1</code> and print it. The decrement operator --</code> would have a similar effect. This behavior can be used in while loops to add to a count</code> variable on each iteration.</p>
Use with assignment</a></h3>

prefix operator</li>
</ul>
#</span>include</span> <</span>stdio.h</span>></span></span>
int</span> main</span>(</span>)</span> {</span></span>
   int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span>
   y </span>=</span> ++</span>x</span>;</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 1</span></span>
}</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span>
int</span> main</span>(</span>)</span> {</span></span>
   int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span>
   x </span>=</span> x </span>+</span> 1</span>;</span> //</span> or x += 1;</span></span>
   y </span>=</span> x</span>;</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 1</span></span>
}</span></span></code></pre>
As we can see here, the prefix operator first increases the value of x</code> and returns the new value which is then assigned to y</code> via the assignment operator.</p>

postfix operator</li>
</ul>
#</span>include</span> <</span>stdio.h</span>></span></span>
int</span> main</span>(</span>)</span> {</span></span>
   int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span>
   y </span>=</span> x</span>++</span>;</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 0</span></span>
}</span></span></code></pre>#</span>include</span> <</span>stdio.h</span>></span></span>
int</span> main</span>(</span>)</span> {</span></span>
   int</span> x </span>=</span> 0</span>,</span> y </span>=</span> 0</span>;</span></span>
   y </span>=</span> x</span>;</span></span>
   x </span>=</span> x </span>+</span> 1</span>;</span> //</span> or x += 1;</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> x</span>)</span>;</span> //</span> prints 1</span></span>
   printf</span>(</span>"</span>%d</span>\n</span>"</span>,</span> y</span>)</span>;</span> //</span> prints 0</span></span>
}</span></span></code></pre>
Here, the postfix operator first returns the current value which is then assigned to y</code> via the assignment operator and then increases the value of x</code>. This works a bit differently than what it looks like. More on that below</a>.</p>
Use in loops</a></h3>
You’ll be glad to know that in for loops, i++</code> and ++i</code> have essentially identical effects. This is because the order of operations in a for loop flows like this:</p>
for</span> (</span>int</span> i </span>=</span> 0</span>;</span> i </span><</span> 5</span>;</span> ++</span>i</span>)</span> {</span></span>
    //</span> loop body</span></span>
}</span></span></code></pre>

initialize loop variable i = 0</code> 
(this is executed once and only</strong> once</em> before anything else is done with the loop)</li>
check condition i < 5</code></li>
execute loop body</li>
add 1</code> to i</code> in ++i</code> or i++</code></li>
repeat from step 2</code></li>
</ol>
A little tip</a></h3>
However, due to the nature of the operators and their precedence explained at the start of this post, ++i</code> is considered a slightly better programming practice. This is because i++</code> actually does this:</p>

save the original value of i</code> to a temporary variable</li>
add 1</code> to i</code> (the same as ++i</code>)</li>
return the original value of i</code> stored in the temporary variable 
(++i</code> would return the new value since it doesn’t store the original value in any temporary variable)</li>
</ul>
So, in cases like in the for loop where it doesn’t make a difference in behavior, it just takes up some extra memory and is better avoided. Although, modern compilers are smart enough to catch this and optimize the code to mean the same.</p>


Welcome to my blog
cybardev — Tue, 19 Jan 2021 14:38:01 +0600
What's this about?</a></h2>
Usually it's just going to be me and my thoughts. Won't be regular, but
I do want to use this as a diary of sorts so might make frequent but short posts
every now and then. I will mostly post about computers and technology since
that is my field of interest. Sometimes I might also post about science and
pop culture.</p>
Who are you?</a></h2>
An undergrad computer science student from Bangladesh who loves Linux
and all things science and tech.</p>
What do we have to do with all this?</a></h2>
You could visit the site from time to time and read up some of my posts.
Who knows, you might find something of interest. I might also put
affiliate links in some tech posts. If you purchase anything from the site
following those links (not necessarily the linked product), I will receive a
small comission with no extra cost to you. It'd be a nice way to show your
kind support.</p>
Thanks~</strong></p>