Forem: Magerman714

Quantum Computers: The Weird Science of the Small

Magerman714 — Mon, 08 May 2023 03:08:21 +0000

Quantum physics is an emerging and frankly baffling science that humanity is still struggling to understand. Its findings are confusing and even sometimes appear to be impossible given our current understanding of physics, but nonetheless have lead to designs of computers that could potentially greatly accelerate our ability to conduct experimental simulations, transmit information, or even enhance the processing speed of our current PCs.

But what is a quantum computer exactly? To understand it, we must first examine how our current computers function.

Traditionally, the computers that are most in use today operate by using 'bits' at the base level. Bits are essentially switches that are either on (have power running through them) or off (don't have power running through them) at any given time; these are read as the 1's and 0's that most people know of. These 1's and 0's are known as 'binary code', and is used as the basic building blocks of a computer. Every process that we program in, every image or video we view from our monitors, every change that happens as a result of a keyboard button press or mouse click, all are essentially the result of programming languages being translated into (or reading) binary code.

Quantum computers, however, use something different from a bit: a "Qubit" (pronounced CUE-bit). Qubits are quantum particles which you can envision as a sphere with a point inside of it which is constantly in motion; that point can at any time be in any position within the sphere. Because of this, a Qubit can equal 1, 0, or anywhere in between!. This concept is known as "Superposition". Here is a visualization of a Qubit:

Qubits (and quantum particles in general) have a few interesting properties. For one thing, while a Qubit can be, say, 0.42 for instance, the moment it is actually measured or observed in any way, even secondhand through, for instance, the radiation it emits, its value will "collapse" into either a 1 or a 0 - nothing in between. This, of course, makes them difficult to measure properly, however another interesting property of the Qubit does assist to some extent: entanglement.

If 2 or more Qubits are close enough to each other, they will become "entangled". If two entangled Qubits are measured at the same time, they will each always yield the same result - that is to say, for 2 entangled Qubits measured at the same time, their measurements would always be either 1 1 or 0 0; never 1 0 or 0 1. An especially intriguing aspect of this property is that it is true regardless of distance! If 2 entangled Qubits are on the opposite side of the planet, they will still always yield the same value if they are measured at the same time.

So how do we measure Qubits such that we can use them in the same way we use bits in a computer? The answer is a concept known as "interference", which involves measuring Qubits strategically at certain points according to a complicated quantum algorithm known as "Grover's Algorithm" (seen below)

Now, the math of that algorithm is beyond me, but the effect is understandable: using said algorithm, it is possible to get a Qubit's true value, effectively expanding the amount of information a single Qubit can contain when compared to a traditional bit. To give some context, a quantum computer with only 10 qubits would theoretically have a storage capacity equal to 2^10 (1,024) values, which would require 16,000 bits in a traditional computer. For a traditional computer to equal the computational power of quantum computer that had 500 qubits, it would require more bits than there are atoms in the known universe!

This technology is still new, and though some functional quantum computers have been made, but only on a small scale and certainly not in any way that would be commercially viable. Still, as the field grows and becomes more refined, who knows what wonders the quantum computer might unlock?

Sources

https://www.youtube.com/watch?v=jHoEjvuPoB8

https://www.youtube.com/watch?v=lt4OsgmUTGI

https://www.youtube.com/watch?v=zhQItO6_WoI

https://www.youtube.com/watch?v=ooDt9oaQZfE

https://www.youtube.com/watch?v=dAaHHGHuy1c

https://www.youtube.com/watch?v=OFFjECcv9Lc

https://www.youtube.com/watch?v=p-MNSLsjjdo

https://www.youtube.com/watch?v=tt8gVXDsh7Q

https://physicsworld.com/a/retrieving-data-from-a-black-hole/

https://www.investopedia.com/terms/q/quantum-computing.asp

https://www.energy.gov/science/doe-explainsquantum-computing

https://aws.amazon.com/what-is/quantum-computing/

https://www.ibm.com/topics/quantum-computing

https://www.wired.com/story/wired-guide-to-quantum-computing/

Git Gud: How to Avoid/Fix Detached HEAD and Hunt Buggy Commits

Magerman714 — Mon, 24 Apr 2023 04:01:54 +0000

While Git is a very useful version control tool, it can also be harsh and unforgiving to those inexperienced with using it. All of us who've used Git have surely felt the frustrating sting of merge conflicts, branch mismatches, and the dreaded detached HEAD state. This guide will provide some rules of thumb for branch navigation, detached HEAD troubleshooting advice, and some bonus tips and tricks I've picked up in my studies.

Branch Management

One of the primary ways you can avoid a detached HEAD state is by effective usage of branches to organize your commit history and keep your working tree clean. So, if you're ever about to start making significant changes that might break things in your code, don't be afraid to use a branch!

git checkout -b <branch name> will both create a branch named and check it out at the same time. Efficient!

Once you've finished whatever work you were doing on your branch, and have tested it to ensure it's working, simply use git checkout <main branch name> (typically 'master' or 'main') to move to the main/master branch, then use git merge <branch name> to merge that branch into it.

Fixing Detached HEAD

To fix this problem, let us briefly delve into what the problem actually is.

The HEAD is essentially just a reference pointing to the most recent commit in a branch. It can be moved, however, with the git checkout command, which will allow you to access a version of the code at that commit. Whenever the HEAD is pointing to a specific commit rather than the most recent commit of the currently checked out branch, it is said to be 'detached'. This can cause all sorts of annoying issues, but thankfully, there is an easy fix!

The easiest and most straightforward way to correct this issue is to simply use git checkout <commit id of the most recent commit on the currently checked out branch>. If you're not sure which commit this is, you can use git status, which should show the HEAD among other commits.

Of course, most of the time when you check out another commit it's because you want to use some or all of that commit's code. Simply checking out the HEAD won't accomplish that, but thankfully there's an easy solution to that too!

If you want to merge changes from the commit you'd checked out which caused the detached HEAD state, first you just need to create a new branch using the command we'd previously discussed: git checkout -b <branch name>. That will copy all of the changes in the currently checked out commit into a new branch. After that, just check out the current HEAD using the command described above. Once you've done that, run git merge <name of the branch you created in the first step> and presto, the merge will be initiated! Once you've resolved any merge conflicts, you'll have ended the detached HEAD state and be ready to continue coding!

Using `git bisect` To Find A Problem Commit

Sometimes, a bug goes unnoticed for a long time and the commit that introduced it is unknown. In a situation like that, we might want to return to an earlier commit, but how can we find which one to return to? Enter git bisect!

git bisect is a useful command that allows you to choose a starting commit (where you know the code was functional and the bug not present) and an ending commit (where you know the bug is present - typically the current HEAD) and test the commits in between to locate the one that introduced a bug. Here's how to use it:

Run git bisect start. Nothing will appear to happen after running this command; that's expected.
Run git bisect bad <commit id of latest commit you know is bad> to start the process. Note that if you omit the commit id, it will use the commit you are currently on as a default.
Run git bisect good <commit id of latest commit you know is working> to give a starting point to the tool. The tool will then checkout a commit somewhere in between of the 'good' and 'bad' commits you indicated.
Test the code at the commit that was checked out, then run either git bisect good if the bug isn't present, or git bisect bad if it is.
After marking each commit the tool checks out as either good or bad, the tool will either checkout a new commit, or end; keep marking commits good or bad until it ends.
When the tool ends, it will identify the earliest commit where the bug is present, which will allow you to search through the code there (particularly the changes specific to that commit) and determine what corrections will be needed to fix it
Remember, at this point you will be in a detached HEAD state! In order to fix this, run git bisect reset to end the bisect session.

Conclusion

I hope that this has helped you to get better at avoiding the detached HEAD state, empowered you to be able to fix that state should it occur, and given you some information on how to hunt out buggy commits more easily without encountering unintuitive Git errors. Happy coding!

Sources:

https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging

https://www.atlassian.com/git/tutorials/using-branches/git-merge

https://git-scm.com/docs/git-bisect

https://git-school.github.io/visualizing-git/

https://www.youtube.com/watch?v=U83Utlp3vYg

https://www.youtube.com/watch?v=HvDjbAa9ZsY

https://www.youtube.com/watch?v=wIY824wWpu4

https://www.youtube.com/watch?v=ecK3EnyGD8o

https://www.youtube.com/watch?v=P3ZR_s3NFvM

CSS Flexbox: How to Get Your Elements to Adjust to Page Size

Magerman714 — Mon, 10 Apr 2023 02:29:29 +0000

Designing the layout for a website such that all of the elements end up appearing where you want them to can be surprisingly tricky, but fear not! Flexboxes can make this task less of a chore, and I'm here to teach you the basics of how to make use them.

Introduction

So first, what is a Flexbox? In short, it's a set of CSS properties that can be used on a container element to allow its child elements to dynamically position themselves based on the webpage's size. Let's take a look at the basics - say we have the following HTML code:

<div id="container">
  <div>Element 1</div>
  <div>Element 2</div>
  <div>Element 3</div>
</div>

Without adding any CSS styling, the default values would have the child elements display top to bottom in a column.

So let's add the first of the CSS properties needed to implement our Flexbox:

#container {
  display: flex;
}

With that CSS property in place, the child elements will now display left to right in a row instead of a column.

Of note, if you want your elements to be displayed in a column, all you would need to do is add the following CSS property: flex-direction: column;

Aligning Your Child Elements

We now have a few options for how to align our items along the axis we have decided for them to appear on (i.e. in a column or row). For this, we use the justify-content CSS property, which can have the following values:

flex-start - The default value, this will cause the child elements to start at the top (for columns) or left (for rows) of where the container is placed on the page.

flex-end - The inverse of flex-start, this will cause the child elements to start at the bottom/right depending on if it's a row or column

center - This will center the elements in the middle of the row or column they're on

space-between - This will evenly distribute the child elements along the row or column they're on

space-around - This is identical to space-between except that it will include some space between the edges (that is to say, the left and right edges of the page for a row or top and bottom edges of the page for a column)

space-evenly - This is much like space-between in that it will evenly distribute space between all of the items is the same, rather than distributing all items evenly along the row/column they're placed on. This distinction is most significant when the elements within the container are different sizes.

The above values are also used for the align-items CSS property, which pertains to the cross axis (i.e. if the child elements are being placed in a row, it would pertain to the vertical axis; if they were being placed in a column it would pertain to the horizontal access). This allows you to fine tune how the elements in your Flexbox are positioned on your page.

To help illustrate how these values work, here's handy visual reference:

Making Your Elements Wrap

Now, if you were to try out a CSS styling object that looked something like this:

#container {
  display: flex;
  justify-content: space-around;
  align-items: flex-start;
}

then you might notice that when the page shrinks enough to compress the elements in your Flexbox, each individual element will scrunch up, maybe pushing some of its characters onto the line below. What if you wanted to have the elements themselves shift to lower rows rather than their contents? This is where flex-wrap comes into play!

Setting the flex-wrap CSS property to the value wrap will allow the child elements to be pushed onto a new line (or column) if the page is shrunk enough to compress them, rather than squishing them together on the same line as the default value nowrap would do. The way these elements are repositioned can also be customized with the align-content CSS property, which uses the same values as the other alignment based properties previously discussed (i.e. flex-start, flex-end, etc.) to determine how to handle where child elements are 'pushed' to along the cross axis.

Conclusion

And that's it, those are the basics of Flexboxes! I hope that this blog post has given you some insight into how to more easily position elements on your webpages!

Sources

https://www.joshwcomeau.com/css/interactive-guide-to-flexbox/

https://css-tricks.com/snippets/css/a-guide-to-flexbox/

https://css-tricks.com/almanac/properties/j/justify-content/#:~:text=space%2Daround%20%3A%20items%20are%20evenly,alignment%20subject%20is%20the%20same

https://www.w3schools.com/css/css3_flexbox.asp

https://www.w3schools.com/css/css3_flexbox_container.asp

https://www.w3schools.com/css/css3_flexbox_items.asp

https://www.w3schools.com/css/css3_flexbox_responsive.asp

https://www.youtube.com/watch?v=phWxA89Dy94&list=PLSkg_1mheG-12IDNqSdHS02_nvaT4B_a1&index=9

Hacking 101: Common Attacks and How to Stop Them

Magerman714 — Sun, 05 Mar 2023 22:39:25 +0000

Welcome to the basics of some common hacking tactics, an overview of how they work, and what can be done to defend against them.

Brute Force Attacks

One of the oldest hacking tactics is the brute force attack. This involves the hacker testing different username and password combinations until one works. While this can be technically be done manually, the sheer number of possible combinations is generally too time intensive to be realistic. Therefore, hackers usually employ some form of software to randomly generate passwords, and possibly usernames as well if they don't already have one.

Countermeasures
From the user's perspective, the best way to defend against a Brute Force Attack is to simply have a password that is difficult to guess. Most password generation software will try more common passwords first, such as variations of the word "password", common words with random numbers at the start or end, words with certain letters replaced with look-alike numbers, etc., so the more random your password is the less likely it is that such a program could quickly guess it.

Most organizations nowadays employ a variety of methods that make Brute Force Attacks difficult or even impossible, such as password encryption algorithms, two-factor identification methods, or simply locking access to the login page for a few minutes after too many failed login attempts.

Denial of Service Attacks

These attacks come in two main varieties: DoS/DDoS attacks, and DNS attacks. Both serve to do the same thing: flood a target server with so many dummy requests that it's unable to process legitimate ones, effectively taking it offline.

The DoS attack is the most basic form of this: a hacker simply sends rapid-fire requests from their own computer, often making use of a program to streamline the process. This version might slow down a server, but only until network security is able to identify the attack - after that all they need to do is block the hacker's IP address to stop it. The more advanced DDoS attack gets around this by recruiting a large number of "zombie" PCs with different IP addresses to assist. This is usually done by distributing some form of malware to as many different unsuspecting devices as possible, so that the hacker can activate them all at the same time to conduct the attack.

While a DNS attack has the same goal of taking a server down by flooding it with dummy requests, its methodology is a little different. This attack works by spoofing DNS servers, which are what turn internet domain names into IP addresses, by redirecting DNS queries intended for other servers to the target server. After this, the hacker will typically rapidly send queries intended to generate large replies to the DNS server, effectively getting the server to do their dirty work for them. While this method can also make use of "zombie" PCs to increase effectiveness, the fact that the query responses are much larger than the code the hacker is sending effectively means that fewer computers are needed to reach the critical mass necessary to down a server.

Countermeasures
Though it is difficult to outright prevent these sorts of attacks, there are a few ways that a company can make them less effective. Firstly, the more bandwidth they have available to them, the harder a hacker needs to work to reach the critical mass of dummy requests needed to down the servers. Moving to the cloud is a good start, as the cloud typically has more bandwidth and stronger security than private networks. For DNS attacks specifically, using Domain Name System Security Extensions (DNSSEC) adds another layer of security for interactions with DNS server to ensure that no malicious redirections have occurred. Beyond these options, al companies can really do is monitor their network traffic for evidence of these attacks and have a plan of action for what to do if one occurs to ensure a swift response.

Injection Attacks

These attacks involve tricking websites into executing code they did not intend to or modifying the execution of existing code in critical ways. The most common forms are SQL Injection, which targets server side code, and XSS attacks, which target client side code.

XSS attacks involve the hacker exploiting vulnerabilities to inject their own script into a webpage which will later be executed by a victim's browser when they load that page. This can be done to steal data, install viruses, add phishing ads to the webpage, and more. For instance, they might record the login info of victims, or recruit a victim's computer as a "zombie" for a future DDoS attack.

SQL attacks, on the other hand, involve strategically entering data into input boxes in order to trick a SQL query into doing what the hacker wants. To illustrate how this works, we will use a simplified example taken from this YouTube video from channel NetworkChuck:

Say we are logging in to a website that utilizes databases to store its data. We might be given an input box for Username and another for Password. Once we enter these and click the Login button, the system might be running a query that looks something like this:

SELECT * FROM users WHERE username='userNameInput' AND password='passwordInput'

Thus, if we inputted "George" as the username and "password123" as the password, the query would look like this:

SELECT * FROM users WHERE username='George' AND password='password123'

With this query, if the username and password don't both match with data from the users table, no value would be returned and the login would fail, but if there was a user "George" whose password was "password123" the query would find it and successfully log in. Well, what if a hacker wanted to log in to George's account, but didn't know their password? Since this hacker knows how SQL queries operate and how certain characters can affect them, and either knows or can guess at what SQL query is being run after the inputs are received, they might instead use the following input for the username field: George'--. Now, the query that is run looks like this:

SELECT * FROM users WHERE username='George'-- 'AND password='password123'

So what's going on with that query? Well, '--' is the SQL code indicating a comment; essentially it means "ignore everything on this line after this", which means that the "AND password='password123'" line isn't being executed at all, allowing the hacker to login with just a username! And auto-logging in isn't even the worst thing a hacker could do with this exploit. A clever hacker can use it to obtain any sensitive data they want from the database, or even to delete critical information!

Countermeasures
Luckily, there are ways to prevent these sorts of attacks, though not all websites employ them. Firewalls, for instance, can be utilized to prevent XSS attacks by constantly patching the website. As for SQL Injection attacks, the most straightforward countermeasure is to "sanitize" the user input. This essentially means preventing user input from affecting queries by, for example, preventing certain characters (like ' for instance) from being read from user input, escaping user input before entering it into queries, or even constructing the code that executes the query in such a way as to prevent user inputs from being misinterpreted as code.

I hope that this has been an enlightening overview of some of the more common forms of attack that hackers can employ. Remember: use firewalls/antiviruses/anti-malware programs, keep your software up to date, and be careful what you click on!

Virtual and Augmented Reality - Is It the Future Already?

Magerman714 — Tue, 28 Feb 2023 05:21:07 +0000

VR headsets and virtual HUDs were once mere science fiction, but both exist in modern day! Are these burgeoning fields ripe for innovation, or just a passing fad? And how does one code VR/AR apps anyway?

Virtual Reality

VR has come a long way from the bulky VR arcade machines that some lucky few may have crawled into in the early 90's. Today, there exist a few different VR headset options for home use such as the HTC Vive or Oculus Quest, each costing about as much or even less than a modern gaming console. While these headsets do offer many different video game options such as the well known rhythm game Beat Saber (pictured above), there are other virtual experiences users can enjoy. For instance, many use the popular chat room like VR Chat program for online socialization, where they are able to customize virtual environments or even personal avatars for others to perceive them as. Another example is Google Earth VR, which allows one the experience of standing on any street corner in the world, or even soaring through the air like a superhero!

VR is not without its flops, of course. Some of these, like the Virtual Boy, were simply too ambitious for the current level of tech. One of the most infamous modern VR flops, however, would be Facebook's "Metaverse", which was designed to be an immersive virtual world which users could shop, play, and even work in. Unfortunately, it was marred by poor design decisions, numerous delays, and a stunning lack of critical features. According to Slash Gear, Metaverse currently sees only about 400 users logged on at any given time, far from the revolutionary product it was pitched as.

Augmented Reality

While Virtual Reality seeks to create immersive virtual environments for users to interact with, Augmented Reality instead seeks to provide an altered view of the real world, usually through some sort of lens or overlay. Nowadays, this is most commonly experienced through a Smartphone, altering the view through the device's camera in some way. One of the most popular AR Smartphone apps is the well known Pokemon Go game, which allows users to find and capture various creatures by physically moving around in the real world. The widely used app Snapchat also sports popular AR technology in the form of various camera lenses which alter faces and/or environments in different ways.

AR has some practical applications as well, though many of these are still new and not necessarily very widely available. One example of this would be in the automotive industry, where some new models of cars such as the 2022 Mercedes-Benz EQS have incorporated virtual overlays over video feeds on the dashboard or even the windshields of the vehicles themselves! These can communicate things like current speed, visual queues for GPS routes, and even highlighting the sides of the road at night or during visually impairing weather conditions like fog or heavy precipitation.

Of course, Augmented Reality is not without its flops as well. Google Glass is perhaps the most well known - a product designed to project a virtual overlay onto a pair of glasses worn by the user. Unfortunately, the enthusiasm Google devs had for the device was not shared by their customer base; the product was seen as silly looking and not particularly game changing - few people ever purchased one.

Under the Hood: How Does the Code Work?

While ultimately providing a different form of functionality (visually modifying the surrounding environment versus creating an entirely new one), both AR and VR operate using the same basic principal: tracking patterns in 3D space using specialized cameras. There are a few ways this is typically done. The most well known method is to use Image Targets, which are graphics which physically exist in the real world and which programs are able to recognize. The most ubiquitous example of these is QR codes, barcode-like graphics that are scannable with most smartphones and which typically provide small bits of data, such as the URL for a restaurant's menu, or an image to display on your phone. Another example would be the controllers for VR headsets, which usually use LED lights or other subtle features to allow the headset cameras to track them. More complicated than that is Plane Detection, which uses "feature points", patterns that weren't specifically placed to interact with the app. Examples of this would include face detection software as well as the feature of some VR headsets such as the Oculus Quest which detects hands, eliminating the need for controllers. Finally, there is Depth Sensoring, a cutting edge approach for AR which uses a device's depth sensor to measure distance, enabling the placement of virtual objects to be placed and tracked behind real world objects.

So what does the code actually look like for this sort of thing? Given that, as shown in the graph above, the most commonly used language for VR apps is JavaScript, we will look at some JavaScript code written by Minhaz which is used in conjunction with a little bit of HTML to recognize QR codes:

HTML:

<script 
    src="https://raw.githubusercontent.com/mebjas/html5-qrcode/master/minified/html5-qrcode.min.js">
</script>

<div id="reader"></div>

<input type="file" id="qr-input-file" accept="image/*">
<!-- 
  Or add captured if you only want to enable smartphone camera, PC browsers will ignore it.
-->

<input type="file" id="qr-input-file" accept="image/*" capture>

JavaScript:

/**
 * Scans an Image File for QR Code.
 * 
 * This feature is mutually exclusive to camera based scanning, you should call
 * stop() if the camera based scanning was ongoing.
 * 
 * @param {File} imageFile a local file with Image content.
 * @param {boolean} showImage if true the Image will be rendered on given element.
 * 
 * @returns Promise with decoded QR code string on success and error message on failure.
 *            Failure could happen due to different reasons:
 *            1. QR Code decode failed because enough patterns not found in image.
 *            2. Input file was not image or unable to load the image or other image load
 *              errors.
*/
scanFile(imageFile, showImage /* default = true */) {}

const html5QrCode = new Html5Qrcode(/* element id */ "reader");

// File based scanning
const fileinput = document.getElementById('qr-input-file');
fileinput.addEventListener('change', e => {
  if (e.target.files.length == 0) {
    // No file selected, ignore 
    return;
  }

  // Use the first item in the list
  const imageFile = e.target.files[0];
  html5QrCode.scanFile(imageFile, /* showImage= */true)
  .then(qrCodeMessage => {
    // success, use qrCodeMessage
    console.log(qrCodeMessage);
  })
  .catch(err => {
    // failure, handle it.
    console.log(`Error scanning file. Reason: ${err}`)
  });
});

html5QrCode.clear();

As explained by Minhaz in his blog post, the code above uses a div tag with the placeholder element "reader" in the HTML to hold the scanned QR code, which it reads from the input tag (note that only one of the two input tags in the HTML code block is meant to be included, depending on whether the app is meant to work only with smartphone cameras or if it is intended to work on PCs as well). The JavaScript code then uses an event listener to constantly scan image files for a recognizable QR code. Upon detecting one, it uses a Promise based API system to decode and display the encoded message (or throws an error if a problem occurs). Finally, html5QrCode.clear() is used to clear the canvas after use, as start() and stop() are not supported by the API used for this code.

The Future is Near!

While the world of VR and AR has had its share of gaffes, both in the past and the present, it definitely has more than a foothold in the modern tech industry. We may not be plugging in to the Matrix in the near future, but these technologies are slowly picking up steam and will likely continue their refinement. With the right innovation, they may even see an explosion in popularity that changes the game in the same way that smartphones, television, or even the internet once did!

Sources:
https://www.statista.com/statistics/1343292/coding-languages-used-in-ar-vr-worldwide/#:~:text=A%20survey%20conducted%20between%20late,projects%2C%20followed%20closely%20by%20Python.

https://gamedevacademy.org/how-to-code-an-ar-application/

https://www.youtube.com/watch?v=YaWzVkI4v0Q

https://spectrum.ieee.org/augmented-reality-car-hud?utm_campaign=post-teaser&utm_content=8k7cu2ho

https://virtualspeech.com/blog/history-of-vr

https://www.slashgear.com/1012807/the-biggest-vr-and-ar-flops-of-all-time/

https://techcrunch.com/2022/03/13/augmented-realitys-half-decade-of-stagnation/

https://www.freecodecamp.org/news/augmented-reality-with-javascript-a-case-study-c9cffaadcf07/

https://blog.minhazav.dev/HTML5-QR-Code-scanning-support-for-local-file-and-default-camera/

https://circuitstream.com/blog/vr-controllers-the-way-of-interacting-with-the-virtual-worlds

Ruby - How Many Carats is this Gem?

Magerman714 — Mon, 13 Feb 2023 03:55:52 +0000

Ruby is a flexible, high level, object oriented language that prioritizes ease of use for programmers, but how does it compare to tried-and-true JavaScript?

PRO - Easy to Learn and Use

Ruby was designed by Yukihiro Matsumoto with the goal of being simple, easy to read, and to allow for multiple approaches to achieve a programming goal. The language is known for being easy to interpret, with code being generally intuitive to grasp based simply on the syntax and plain English word choice for various commands, and often less verbose than other languages. To illustrate this, here is a snippet of JavaScript code which creates and then calls a function that will will greet the name passed to it as an argument, followed by a snippet of Ruby code which does the same thing:

JavaScript:
function greet(name){ const greeting = "Hello ${name}"; console.log(greeting); }; greet("Marcus");

Ruby:
def greet(name) greeting = "Hello #{name}!" puts greeting end greet("Marcus")

As you can see, the Ruby code has a more natural feel to it, eliminating a lot of the more technical characters used by JavaScript, such as the curly braces and variable declaration keyword "const", and uses the keyword "end" to indicate where the function code stops. This makes it easier for a reader to parse, particularly with larger code blocks.

Of note, Ruby also allows more variation in syntax, allowing the programmer to choose what style they prefer. For instance, the function call in the code snippet above could have instead been written like this:

greet "Marcus"

CON - Sharing Code Between Programmers can be Problematic

Because of the design goal of allowing many different approaches to a coding problem, and especially the syntactic variations the language allows for, two programmers with different coding styles may find it difficult to make use of each others' code, at least by copying. This can make collaboration between multiple programmers on a single project a little more difficult than with other more syntactically strict languages, though it is worth it to note that Ruby does contain functionality to create plug-and-play libraries of programs, called "gems", which can easily be added to other Ruby programs to be made use of, which mitigates this downside to some extent.

PRO - Flexibility

While Ruby is most commonly used for GUIs and web apps/development, it is a highly adaptable language that can be used in a variety of situations. Since just about everything in Ruby is an object, even its base components can be altered or removed as needed to customize it to whatever end the programmer desires. This allows programmers to customize even the basic commands used in the program.

For example, take this code snippet pulled from the about section of the Ruby programming language webpage which adds a "plus" method that can be used in place of the addition operation:

class Numeric def plus(x) self.+(x) end end y = 5.plus 6

CON - Programs Run Slowly Compared to Other Languages

Making just about everything an object does have its price: Ruby programs run notably slower than other coding languages, about 50-200% slower than JavaScript programs in fact. That may sound like a huge problem, but given that most code runs in almost imperceptible amounts of time regardless of language, this really only comes into play with code that requires extremely large numbers of operations to complete. Thus, while it is definitely an issue worthy of consideration, it's also true that it is not even a noticeable problem most of the time.

PRO - Robust and Welcoming Developer Community

Ruby is an open source language, a fact which draws many developers to it and generally encourages sharing and collaboration in its use. This has resulted in a large, friendly community which is very welcoming to those new to the language, be they beginner programmers or experienced ones looking to add a new language to their repertoire; the community continues to grow even to this day. This gives a lifeline to those still learning the language and those who have been using it for years alike, which is definitely a feather in Ruby's cap. A supportive community not only means updates, improvements, and sharing of tips and tricks, but also a place to go to for help or advice when a programmer's code isn't functioning properly despite their debugging attempts. And speaking of debugging...

CON - Debugging can be Difficult

Yes, even with help from the community debugging Ruby can be more difficult than with other languages. This is due in large part to some of the advantages mentioned earlier, namely the highly variable/adaptable syntax and the fact that Ruby is a simple to look at but fairly complex under the hood high level object oriented language. The variety in approach when using this language also means a wide variety of errors, with different users doing the same tasks potentially encountering very different hurdles to face. It is worth it to note that Ruby does have exception handling features to aid in error management, though the underlying complexity of the language means that those may not be enough in every situation.

Conclusion

The advantages that Ruby was designed to include are often double edged swords, but given how easy the language is to learn coupled with how adaptable it is, I would argue that it makes both a good first language for a beginner to learn and and a good "back pocket" language for any experienced programmer to pick up. While other programming languages like JavaScript might outclass it in certain areas, the fact is that Ruby is still a widely used language across a variety of coding professions, so learning it will certainly expand your portfolio without consuming too much of your time.

Sources:

https://www.ruby-lang.org/en/about/
https://blog.boot.dev/javascript/ruby-vs-javascript-which-language-should-you-learn-first/
https://careerkarma.com/blog/ruby-vs-javascript/
https://careerkarma.com/blog/what-is-ruby-used-for/
https://activebridge.org/blog/what-do-experienced-developers-think-of-ruby-the-ultimate-ruby-guide
https://www.youtube.com/watch?v=UYm0kfnRTJk
https://www.youtube.com/watch?v=vFEPkXybAlo

Recursion

Magerman714 — Tue, 03 Jan 2023 16:16:32 +0000

How to Think About Recursion

Recursion is when a function calls itself in a return statement

This may be confusing at first - "won't this make an infinite loop?" you might ask. The key in recursive functions is that every time they call themselves, they change their parameters slightly so that an included if statement can check for an end state and properly stop the function from continuing

for example:

function recur(count){ if(count === 0){ return; } console.log(count); return recur(count - 1); }

The above function would print the numbers from count down to 1 to the console; note that it would not print "0" because when count eventually becomes 0, the if statement will simply return. If we wanted to print 0 as well, we'd need another console.log within the return statement.

Another looping mechanism for your repertoire

The best way I have found to think of recursion is that it's simply another way to do loops. It has all the pieces of, say, a for loop, just in a different order. For instance, if we wanted to print the above function using a for loop it would look like this:

function forLoop(count){ for(let i = count; i > 0; i--){ console.log(i); } }

Let's break this down:

the first part of the for loop, "let i = count", sets up how many iterations we will go through based what argument is passed to the function. No "i" variable is needed in the recursive function, but the argument passed to "count" still serves the same purpose.

The second part of the for loop, "i < 0", indicates the stop statement for the loop; the loop will continue iterating so long as i is greater than 0. The same functionality is served by the if statement at the top of the recursive function; once count = 0, the loop is ended by a return statement.

The third part of the for loop, "i--", is what changes the variable that is tested for in order to stop the function once it has gone through all the iterations we want it to, and to prevent it from becoming an infinite loop. The same purpose is covered by the return statement at the end of the recursive function: "return recur(count - 1);".

So if we think about this, if count = 5, then the first time we go through the recursive function it will console.log count (5), then it will return itself with count - 1 as the argument, so it will essentially return "recur(4)". It will do this until the if statement's condition is met (i.e. it runs "recur(0)"), at which point it will hit the return statement and stop iterating.

In summary, a recursive function has all of the pieces of a for loop, just in different locations.

I hope this helps your understanding of recursion!

Forem: Magerman714

Quantum Computers: The Weird Science of the Small

Git Gud: How to Avoid/Fix Detached HEAD and Hunt Buggy Commits

Branch Management

Fixing Detached HEAD

Using git bisect To Find A Problem Commit

Conclusion

CSS Flexbox: How to Get Your Elements to Adjust to Page Size

Introduction

Aligning Your Child Elements

Making Your Elements Wrap

Conclusion

Hacking 101: Common Attacks and How to Stop Them

Virtual and Augmented Reality - Is It the Future Already?

Ruby - How Many Carats is this Gem?

Recursion

Using `git bisect` To Find A Problem Commit