DEV Community: Luigi Antonio Guillen

Ruby Debugging, VS Code, Gems, and Bundler!

Luigi Antonio Guillen — Thu, 05 Sep 2024 07:31:01 +0000

After installing your Ruby development environment, you might find yourself in the void thinking what to do next. In this article, we take a look at the bigger picture before you, as a developer, would dive into the smaller chunks of going through your projects: setting up your code editor and get to know how gems work, as they are the essentials!

While the article's title may sound like a random mashup of four concepts, it's more like setting up your ground for your code to be written down to running/debugging, knowing how to extend your code through libraries or gems, and make your project immune to dependency hell with the help of Bundler, especially when sharing your projects to everyone else who definitely has a different set of gems installed on their environment!

Debugging

With a fresh installation of your environment, you can immediately run your Ruby file (ending in .rb) in the Terminal. The same is true for Python and various C/C++ compilers (clang, gcc, MinGW)

ruby FILE
# EXAMPLE
ruby /Users/User/Desktop/hello.rb

You can learn more about how your file will be interpreted (flags) by executing ruby -h.

Ruby and Visual Studio Code

For developers who want to streamline their code editor experience into a near-IDE one, code editors like Visual Studio Code (VS Code) offer extensions to streamline your Ruby experience and your development environment!

Extensions

For beginners, I suggest three extensions for you to get started with:

Ruby Language Server Protocol (LSP) - for rich features in the editor like semantic highlighting and documentation on hover for classes, modules, etc.
VSCode rdbg Ruby Debugger - a debugger-focused extension with some support for running code without debugging
Code Runner - supports Ruby among many languages focusing on running code without debugging

The Ruby LSP and Code Runner works out of the box but the VSCode rdbg Ruby Debugger extension needs configuration after installation. On the next section, we focus on the big elephant in the room, the rdbg Ruby Debugger.

Configuring VSCode rdbg Ruby Debugger

Prerequisites: debug

What makes the rdbg Ruby Debugger distinct from our Code Runner extension is that it makes use of VS Code's debugging part of it, allowing you to make breakpoints and keep track of Variables, Watch, and your Call Stack found in the same Run and Debug view on your sidebar. It is identical to when you try to debug a C/C++ or Python program given you have these VS Code extensions and compilers installed.

After installing the extension, install the debug gem via the terminal

gem install debug

For your launch configurations which are applied only to the scope of your current project, these are the default configurations in your launch.json:

{
        // Use IntelliSense to learn about possible attributes.
        // Hover to view descriptions of existing attributes.
        // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
        "version": "0.2.0",
        "configurations": [
                {
                        "type": "rdbg",
                        "name": "Debug current file with rdbg",
                        "request": "launch",
                        "script": "${file}",
                        "args": [],
                        "askParameters": true
                },
                {
                        "type": "rdbg",
                        "name": "Attach with rdbg",
                        "request": "attach"
                }
        ]
}

If your Ruby project doesn't have launch configurations or you are unsure of it, you can navigate to the Run and Debug in VS Code found on your sidebar. The same action can also be done by navigating to Run > Add Configuration… in the menu bar. This will allow you to configure a launch.json for your currently opened project.
Attempting to debug your program under Run > Start Debugging will pop up a notification on the bottom right that it cannot find a program to debug. Closing the notification will also trigger the same action of configuring your launch.json.

You should be greeted with the said JSON file in a new tab.
For this purpose, we can save and leave anything unchanged in this file that has been automatically generated for us. For more advanced projects, you might have to tinker on how your project will be debugged with flags (similar to how I discussed earlier on executing ruby -h at the Terminal to learn more about the various flags that can be executed with your project).

Afterwards, you can now debug your code by going to Run > Start Debugging or by hitting F5 on your keyboard. You will be presented with this bundle command for every time you will debug, so simply hit ENTER.

And voilà! You can now debug your current project, even breakpoints! This is how you'll configure your launch configurations for every new project you'll make on moving forward.

Ruby LSP and Code Runner

Since they run right away after installing these extensions, I'll give you a quick run through of these extensions!

First is the Ruby Language Server Protocol (LSP), this extension is similar with the C/C++ and Python extensions in VS Code in that it can display documentation and suggestions of certain keywords as you type them in.

And second is Code Runner. It also works for a variety of other programming languages as it simply taps in to the Terminal to execute your Ruby project.

Now that VS Code is seamless with how you manage, run, and debug your Ruby projects—and speaking of projects—let's tackle about gems!

💎📚 Gems

Like I shared in my first Ruby article, gems are libraries of Ruby code that can be reused and for the simplicity sake of your code (especially if you can think that such a function may be already open-sourced by others). For context, gems are analogous to C/C++ library (.h) files.

RubyGems is the Ruby's community hub for these gems while also serving itself as a gem hosting service. Not only you can install but also publish your own gems that you may think others may find it helpful! Treat this as your directory plus documentation for gems that you might search in the future!

Installing Gems

Installing a gem to your Ruby environment involves this command syntax:

gem install [NAME]

Some gems in their documentations may require you to run this command with a sudo command such as the rails gem for example.

For users that use a version manager to manage their Ruby environments (i.e. rbenv, rvm, or asdf), installing a gem in one version may be independent from another version; it will not carry across different Ruby versions.

By default, your Ruby development environment comes with essential gems necessary for building on top of other gems. For a fun little exercise, we can make use of a gem in a sample project that is more down-to-earth!

Using Gems in Your Ruby Project

To include a gem to use in your project, the syntax is as follows,

require '[NAME]'

In our sample project, let's make use of the matrix gem that's included with our Ruby installation. If it comes that you run this sample code and stopped with an error because this gem is not found, you can execute gem install matrix in the Terminal.

require 'matrix'

Now let's define a matrix and print the determinant of this! Take note of Ruby's object-oriented nature, as that's how you "call" things from a class on libraries (as seen in mat.determinant).

require 'matrix'
mat = Matrix[[2, 3], [5, 6]]
puts mat.determinant # => -3

And that's how you can use gems in your Ruby project! If you want to learn more about the documentation of the matrix gem, you can head here!

For an index of the documentations of gems, you can head to rubydoc.info or ruby-doc.org!

🔨 Bundler

Prerequisites: bundle

When sharing Ruby projects with the gems you used to someone else (such as GitHub), it is likely that they can't run it because they haven't installed it on their own environments or they have the gems but somehow, a newer or older version is interfering with the gems they have on their environment, this is what I meant by dependency hell.

Bundler eliminates that, as its job is to keep an exact list of gems and optionally specify versions of gems for your project. This ensures that other people will have these exact gems installed without them manually telling them about it with a simple command later on.

Upon installing Ruby, the bundle gem should come with the installation. If somehow this gem doesn't exist, you can install it with the gem command.

Getting Your Project Ready for Bundler

In your project folder, Bundler needs two files, Gemfile and Gemfile.lock (yes, the first file doesn't have an extension). You can add a file by the Explorer found in the sidebar in VS Code:
In addition, you can do the same action using the touch command in Unix/Unix-like systems (i.e. Linux and macOS) in the terminal.

touch Gemfile Gemfile.lock

Now, let's focus on the Gemfile!

The `Gemfile`

The Gemfile is where you can specify the gems that will be used by your project. This file will be read by Bundler.

In practice, you include the source of where your gems should be downloaded from, though this is not required at all times. In this case, RubyGems will be our source since they also host gems!

source 'https://rubygems.org'

Listing a gem in the Gemfile is done through this similar syntax, differing only by a word when we require a gem in our project:

gem '[NAME]'

In another sample project, let's try to include another gem that's not installed in our fresh Ruby environment, the fibobacci gem!

source 'https://rubygems.org'
gem 'fibonacci'

With this gem syntax, by default it will install the most current release of that gem. Should you need to install a gem with a specific version is in the form of this syntax, using fibonacci as an example:

gem 'fibonacci', '~> 0.1.8'

After listing the gems you need for your project, simply run this command in VS Code's terminal:

bundle

When you make changes to your Gemfile, you can run this command again. Additionally, you can view the information of that gem you installed and where it's at by executing bundle info [NAME].
Now we can get the first n terms of a Fibonacci sequence where n is inputted by the user with this snippet of code!

require 'fibonacci'

fib = Fibonacci.new
num = gets.chomp.to_i # Removes the terminating character at the end of the input and converts the input to integer
fib.print(num)

You can learn more about getting started with Bundler here! If you want specifics about how the Gemfile works, then head here!

Conclusion

Now that you have a near-IDE experience with VS Code, learned more about how to embed gems in your project, and learned the basics of Bundler so that other developers can also tap in to your project with the exact gems that you used, you can definitely rest easy and code away on your Ruby journey!

Most of what I shared here, particularly with gems and Bundler, is just the foundation of what you'll encounter later with other gems and frameworks in Ruby!

That is all, I hope you learned a lot about Ruby with this one! :)

How to Install Ruby on Windows, macOS, and Linux

Luigi Antonio Guillen — Sun, 01 Sep 2024 04:37:32 +0000

Updated September 2025: Now friendly for Linux/WSL users!

This is my take on making a tutorial on how to install Ruby across Windows, macOS, and Linux all in this one article!

In a pinch, Ruby is an interpreted, dynamically-typed and high-level programming language where everything is an object! While it is a true object-oriented programming language, the paradigms of programming in a procedural and a functional way can also be done.

Outside of the programming scheme, Ruby is popularly used alongside Ruby on Rails which is a full-stack web framework. Others include Bundler which provides a consistent environment for managing gems and versions between independent Ruby projects, Ruby 2D for creating 2D apps, games, and visuals, and Pry as an interactive shell. All of these four are what you refer to as Gems, basically libraries also containing Ruby code!

That's all for the background of Ruby and without further ado, let's get right to installing Ruby on your machine!

Note: In any mention of a version number past this point indicates the version of Ruby that was released at the time of writing this article. If you are looking to install an older version of Ruby, this guide is also for you! Just find the version you're looking for in the downloads page or by listing it in their respective package/version managers. This applies to future Ruby versions as well.

Windows

Using the standalone RubyInstaller setup executable

If you're a novice, GUI-based person, you can install Ruby with a usual setup application:

Download the latest setup executable here and make sure it's the one with a DevKit. Note that you need the DevKit version in order to build C/C++ extensions for Ruby and is necessary for Ruby on Rails, and hundreds of Ruby gems rely on it, so might as well go with the DevKit version as opposed to none
You're given an option to let the installation be limited to the current user or system-wide. If you don't know what to select, let the installation be only installed to you, the current user
Along the installation, you will be asked to add Ruby executables to your PATH environment variable and associate Ruby-related files. Assuming this is your first installation of Ruby, leave these checked. If you have an existing Ruby installation, either uncheck these or wipe your current Ruby installation before proceeding
After finishing with the setup window, a terminal window will pop up that's the DevKit part! Specfically, MSYS2 concerns with necessary dependencies for building Ruby as well as Ruby gems with C-extensions. Press ENTER to continue. This will pop up again after installation so hit ENTER afterwards
After installation, you're good to go! There's a Start Menu folder for Ruby where the Interactive Shell and documentation can be found. To verify your installation, you can type ruby -v in the Terminal (this also verifies if Ruby is in the PATH environment variable as well!). You can also try line-by-line statements in the interactive shell or type ruby in the Terminal followed by a .rb file to interpret that Ruby file!

Using the Windows Package Manager `winget`

If you have an up-to-date version of App Installer (updated from the Microsoft Store), you can use winget from the terminal to install Ruby with the following syntax:

winget install RubyInstallerTeam.Ruby.{MAJOR}.{MINOR}

where {MAJOR} is the major version, while {MINOR} is the minor version.

To list all available versions:

winget search RubyInstallerTeam.Ruby

To install Ruby 3.2.4 with DevKit, the version available from winget at the time of this article:

winget install RubyInstallerTeam.RubyWithDevKit.3.2

Afterwards, you should be able to perform the same little tests mentioned above as if you used the RubyInstaller method!

macOS

Prerequisites: git, curl, Homebrew, libyaml, asdf

Since OS X 10.11 El Capitan, Ruby is bundled alongside the operating system and the ability to install gems as the operating system came with such.
This is Ruby 2.6.10 that is bundled with macOS 11 Big Sur. With Homebrew, The built-in Ruby and its dependencies (especially libyaml) can be updated with this command:

brew install ruby

However, this is for the system-wide Ruby installation. Most Gems wouldn't be compatible especially if they require Ruby 3 and later (such as Ruby 2D). We ran this command in preparation for the next step with the now-updated dependencies.

Therefore, the use of a version manager like asdf is recommended.

Installing `asdf`

Asdf is a version manager that not only supports Ruby but also Node.js, Elixir, Erlang and more! Rbenv is usually the main go-to but there's only one con in that it's only a version manager strictly for Ruby, so from a scalability standpoint, I think asdf is the way to go!

Recently, it is recommended that asdf is installed through a package manager, using brew from earlier:

brew install asdf

After installation is finished, normally you wouldn't need to modify your shell profiles as the installation earlier would've taken care of that. Just in case that invoking asdf does not work in the terminal, below are the additional steps to it.

Adding shims directory to path/shell

Edit ~/.zshrc to include this line, which will make asdf be able to switch between versions of tools/plugins across the system

export PATH="${ASDF_DATA_DIR:-$HOME/.asdf}/shims:$PATH"

If you have Oh My Zsh installed

Look for plugins=() then include asdf inside plugins.

Making asdf Take Control of Your Ruby Environment

Add Ruby as a plugin in asdf
```
asdf plugin add ruby
```
Search for a version of Ruby you want to download and install
```
asdf list all ruby
```
Multiple unrelated plugins may be listed. Scroll up the terminal until you find listings that are just version numbers, those are the available Ruby versions to download.
Download and install your desired Ruby version, for example, Ruby 3.2.4
```
asdf install ruby 3.2.4
```

After installation, switch to your newly installed Ruby version after opening a new terminal session

# SWITCH TO THE NEW RUBY
asdf set ruby 3.2.4
# SWITCH BACK TO THE SYSTEM'S RUBY
asdf set ruby system

Take note that when using version managers, a gem installed in one version is independent from another. So for example, installing the rails gem in our 3.2.4 installation will not carry to the operating system's 2.6.10 installation.

What if Ruby failed to install in asdf?

A common problem is with libyaml. It should be resolved by reinstalling it using Homebrew:

brew install libyaml

Afterwards, proceed installing Ruby in asdf with the same syntax above.

Linux (including WSL)

For context, this is being installed on Windows using the Windows Subsystem for Linux (WSL) on an Ubuntu/Bash distribution. Later, this is also being installed on on Linux Mint, an Ubuntu-based distribution, which is also based on Debian.

In case if you didn't catch it, yes, this also applies to Windows Subsystem for Linux (WSL) environments

I know, this heading may be a too much than just specifying what kind of "Linux" it is, but if you're using a different Linux distribution such as Fedora or Arch, you can head here from the official Ruby documentation website exploring these various distributions. The installation should be similar, only differing in the package manager in your Linux distribution.

Like with the previous systems, you have the option of installing Ruby that taps in natively with your system with, for example, on Ubuntu:

sudo apt-get install ruby-full

However in the real world, there's no one Ruby version that everyone's using (fragmentation). From this point on, we'll still use asdf for this, but the steps are different as we don't have the luxury of an available package manager at the time of this writing.

Obtaining a pre-compiled binary

For our Ubuntu/Bash environment, we first make sure to install dependencies needed beforehand:

apt install git bash

In the context that we'll use Ruby as one of the plugins in asdf, it also needs these dependencies to compile successfully and work with gems you will be using:

sudo apt install -y \
git curl wget unzip \
build-essential \
libssl-dev \
libreadline-dev \
zlib1g-dev \
libyaml-dev \
libxml2-dev \
libxslt1-dev \
libcurl4-openssl-dev \
libffi-dev \
libgdbm-dev \
libncurses5-dev \
automake \
libtool \
bison \
pkg-config \
libc6-dev \
libyaml-dev \

We go to the latest releases of pre-compiled asdf binaries from their repository and download the latest version tailored for our architecture (for the vast majority, it is amd64). As of this writing, version 0.18.0 is pre-compiled.

For this, we'll place the downloaded file in our home directory. We now extract the archive using the tar utility:

tar -xzf asdf-v0.18.0-linux-amd64.tar.gz

We then move the now-extracted binary to /usr/local/bin(and make it executable via chmod):

sudo mv asdf /usr/local/bin/

Finally, we can verify if asdf is on our shell's $PATH by running the following:

type -a asdf
# asdf is /usr/local/bin/asdf

Configuring shell for asdf

We add the shims to our PATH using our .bashrc shell config. We can simply echo it to the file without opening any text editor:

echo 'export PATH="${ASDF_DATA_DIR:-$HOME/.asdf}/shims:$PATH"' >> ~/.bashrc

Then we source .bashrc or also completely restart the terminal:

source ~/.bashrc

For zsh, the steps are the same, only that the above command must be appended to ~/.zshrc or adding asdf to the plugins list of your Oh-My-Zsh configuration, then source ~/.zshrc.

Similar to the guide above for macOS, we can now install the Ruby plugin for asdf and install the version of Ruby that we want.

Applying Ruby to Shell or Working Directory

We simply set the Ruby version to be used, noting that a .tool-versions file will be created at ~ or wherever working directory you're currently on. At the time of writing, we set it to version 3.4.5:

asdf set ruby 3.4.5

Bonus: Installing Gems! 💎

Think of gems like Python or C/C++ libraries; they're also Ruby code that's also open-source! However, do note that this is applied/installed globally, so if you're working on a Ruby project that has gems (or dependencies) that your global Ruby environment does not necessarily need, it's important that you separate them (like using Bundler).

Importing gems to a Ruby project is similar to the likes of C/C++ and Python save for syntax differences

// C/C++
include <stdio.h>

# PYTHON
import json

# RUBY
require 'rake'

Anyway back to Linux, I'll be installing the gem pry which will allow me to have an interactive shell in the Terminal:

sudo gem install pry

This is how you add these gems or libraries into your Ruby environment. Also notice how we need elevated permissions with the sudo command when installing most gems.

After installation, we can immediately interact with the Ruby interpreter by simply typing pry in the terminal! You can perform the same tests I've done above!

Conclusion

Now that you have reached the end, you have not only installed Ruby as a fresh development environment alongside your system, but also discovered the convenience of version managers and learned the basics on how to install gems on your Ruby environment! You can now use this environment to run Ruby files with the ruby command in the Terminal or interpret Ruby lines real-time with your respective interactive shells. With the power of gems, you can now explore the vastness of there is to offer with the simplicity of Ruby!

For documentation on the Ruby programming language such as manuals, head here!

Hope to do a future article on a deep dive on gems, specifically Ruby on Rails!

Navigating Technological Enthusiasm: Al, Privacy, and Virtue Ethics in Human-Computer Interaction

Luigi Antonio Guillen — Mon, 19 Feb 2024 12:47:59 +0000

📖 10 min. read

This article was co-authored by @quennebria.

You live in a time of rapid technological advancement and change. With all your enthusiasm, you're missing something important, aren't you? How do we handle ethics, privacy, and surveillance?

With Artificial lntelligence (AI), regarding to data collection, are concerns over its aggressiveness, loss of privacy, and even unintended consequences. How do we address these gray areas of AI? This is where virtue ethics comes into play.

In this article, we will dive into ethical considerations around the integration of Artificial Intelligence (AI) into our daily life, particularly with privacy issues and use of virtue ethics in human-computer interaction. A moral machine-driven future isn’t science fiction and you can be one of the people that help make it come true.

Understanding Technological Enthusiasm in the Age of Artificial Intelligence (AI)

Artificial Intelligence (AI) is becoming increasingly ingrained in our routines, yet issues, like automation, bias, and data privacy have surfaced (Biswas, 2023). An imbalance between innovation and ethical consideration will hinder us as a whole from advancing our humanity.
In the progress of AI, one must impart teamwork across the fields thriving with ethical values that adhere to this invention, like policy making and tackling issues in advance, considering the following:

What is information?
How is it utilized? How could a system harm communities?
Who takes responsibility if things go awry?

By encouraging collaborations and discussions, we increase the likelihood of developing AI that promotes welfare.

These dilemmas will always remain to be the subject of continuous navigation between progress and precaution. On the other hand, we cannot let enthusiasm lead to technology development inconsiderate of ethics as it may create technologies that might do more harm than good.

Privacy Concerns and Ethical Considerations for AI

While we laid out a rather utopian approach to AI, there is a need to voice out back to reality. As tech enthusiasts who witnessed the advent of AI from two years ago as of this writing, many have begun to question its gray area of the do’s and don’ts when using various AI models.

AI has completely changed the landscape of what already was convoluted when it comes to privacy, particularly user data. The user-generated content of the World Wide Web has been leveraged out of the box wherein these are used to train AI models.

Personally when AI surfaced two years ago, the first backlash felt against AI was the creative community, particularly digital artists. An article by O'brien (2023) states that the vast majority of artists criticize AI because

Their works being used without their permission
Their art is used to train AI models (or so-called data scraping)
AI Art “devalues the value of human work”

Because of this, artists and creative minds alike are much more hectic in emphasizing rights to their works, with mixed opinions about the creative landscape living with AI. This judgment towards AI goes beyond IT ethics, as it also questions its artistic ethic that art is about the hard work and emotions that were put on a canvas.

Art and Artificial Intelligence are just one among many scenarios questioned about the responsible use of AI, but a common theme arises: data scraping. AI Models in particular are trained with this method which is fed with data to be better, causing concern over the data of users in the user-generated content space of the World Wide Web (also known as Web 2.0). Not only does it concern copyright, but leaves a gray area for privacy.

Privacy and Giving Control Back to The User

As of this writing, Web 2.0 is the current iteration of the World Wide Web (Paul, 2024).

It is a defined era of the World Wide Web mainly due to user-generated content
With user-generated content in mind, it gave birth to centralized networking platforms such as social media
Because the web is mostly centralized, data is viewed as a capital asset for companies

With the rise of smarter web advertisements that follow you around as you surf with the help of third-party cookies, these are data brokers-companies that’s only sole purpose is to collect and sell your data. Not only do these practices track you across the web without your consent or prior knowledge, but the user now has a unique fingerprint that can be easily identified across the web. This allows individuals or companies that capitalize on data to give you relevant advertising in exchange for your data.

In the near future, Web 3, when successful, could be the pioneer of Web 3.0 that contrasts to Web 2.0:

Decentralization
Data is now user-first and has all the rights and consent of the owner
Blockchain — basically a transparent, distributed database

Reviewing Privacy Settings on Your Accounts

On a personal note, when encountering account creation on another platform or application, I always hunt down for privacy controls about my data. Additionally, I can only secure not only my data but of how private or anonymous I can be on that platform.

As a user of the internet, especially when you already signed up for an account on a platform, managing your account settings may seem like a horror for most. These are pages or screens you wouldn’t want to tinker with. In reality, they are usually straightforward to use! Sometimes, however, navigating through privacy settings may be vague and can get you easily lost.

Google and Meta’s Ad preferences are an example wherein they refer to the user’s basic information and other observed behavior like suggested interests and similar search queries

With recent laws and antitrust lawsuits that sparked in recent years concerning user privacy, particularly the General Data Protection Regulation (GDPR), companies were required to give the user a transparent overview of how their information and data is used.

Some platforms or services collect your data for a number of reasons:

Data is used to improve the application, platform, or service
Data is used to sell to advertisers to give you a personalized experience
Data is/may be used to train AI models for a better experience (i.e. Grammarly AI)

If you are concerned about your privacy, you are free to review these settings either by selecting parts of your data not to be shared, completely opting out of a personalized experience, or by deleting your data from the company from which your account was made.

In short, if you’re concerned about your privacy as a user, you could either:

Voluntarily let all of your data be collected
Only select some of your data to be collected
Opt-out entirely of the platform or service’s data collection

At the very least, it’s about giving control back to the user of how their data should be managed.

Virtue Ethics and Technological Enthusiasm

As tech enthusiasts, ethics, particularly IT ethics, are important to take note of every day. These are a set of moral principles and do’s-and-don’ts that one must adhere in the field of technology looking forward.

Applying Virtue Ethics to Human-Computer Interaction

Virtue ethics offers an important frame for the ethical considerations of AI. Hagendorff (2022) says about the abecedarian principles of virtue are:

Equivalency
Compassion
Probity

AI systems can be developed in a way that reflects moral values and ethical norms by enforcing these ideas in their design.

Achieving this balance between invention and ethics becomes consummate as we become more habituated to AI in our daily lives. The excitement about progress has the effect that it can make one learn new effects about inventions and technology, but it can also beget a person to overlook troubles or unintended consequences. Training AI can be directed to conform to moral norms using virtue ethics.

In character.ai when a user enters a prompt that would lead to a “character” to say sensitive topics (i.e. inappropriate content), the character would refuse to reply and warns the user that the AI-generated prompt is against the platform's guidelines

Virtue ethics, the primary idea of which is to develop moral rates and positive character traits, is the main end. The characteristics of empathy, translucency, and integrity are the most important for Al. Empathy should be shown by companies and inventors who are investing in AI Technology by considering the possible negative influence that Al has. Transparency should also be espoused in systems where individuals can understand how they operate and the reasons for their opinions.

Ethics Hidden in Plain Sight

One of these ethics is a tech enthusiast’s duty to educate our less-tech-oriented peers and loved ones who are trying to keep up with the jargon of today’s technology in a friendly manner, not in a manner in which we assume that they would or assume to know.

When looking back at privacy, it’s not just about privacy to the user’s data, but the user itself. Giving back control to the user is also their means of privacy and consent, which was previously mentioned. One example is the user’s freedom to change their settings that do not necessarily default to the application’s preference.

Buried underneath an obscured level of menus that’s not entirely “social media” friendly, Facebook has settings, for example, for controlling how notifications are sent through your device, e-mail, or SMS

By default, every user on Facebook will have notifications sent through your device and e-mail, but we have the freedom to change it to our preference and liking with these granular settings. Personally, I changed these settings so that notifications would only happen inside the app. Knowing this paradigm, we may consider the following:

Notification preferences
Email subscriptions
Optional data sharing (to the platform)
Any (Optional) checkbox that you checked thinking it’s necessary

Shedding some light that we change settings on this centralized platform is a gesture of “bringing back control to the user”.

An email thread, a registration form with an optional checkbox, and a cookie popup asking the user if they accept all cookies or review if the user denies cookies

It is not all the time we have to agree or check an option or action
If you are literate enough and see that you have the right not to, you can always leave that checkbox unchecked
If the platform provides it, you have the right to unsubscribe to a mailing list or change notification preferences that are flooding your email inbox

When you are tech literate enough to scour through every “Settings” page of any application or platform or read carefully if you “Reject all cookies” on a webpage, you will feel that you have regained your privacy and control as a user.

Conclusion

With technology having rapid and exponential progress, being enthusiastic about it sometimes lets us forget about consideration to be ethical and human-friendly without infringing one’s rights, especially when it comes to the user-generated content of the World Wide Web. With AI one of the rapidly developing technologies of the decade, we should also develop responsible technologies—empathy, transparency and responsibility around Al will help us keep our humanness while bringing technology into our lives.

As tech enthusiasts, we should be happy and responsible advocates of Artificial Intelligence and remember that you have every right and control when it comes to your data and privacy!

DEV Community: Luigi Antonio Guillen

Ruby Debugging, VS Code, Gems, and Bundler!

Debugging

Ruby and Visual Studio Code

Extensions

Configuring VSCode rdbg Ruby Debugger

Ruby LSP and Code Runner

💎📚 Gems

Installing Gems

Using Gems in Your Ruby Project

🔨 Bundler

Getting Your Project Ready for Bundler

The Gemfile

Conclusion

How to Install Ruby on Windows, macOS, and Linux

Windows

Using the standalone RubyInstaller setup executable

Using the Windows Package Manager winget

macOS

Installing asdf

Adding shims directory to path/shell

If you have Oh My Zsh installed

Making asdf Take Control of Your Ruby Environment

What if Ruby failed to install in asdf?

Linux (including WSL)

Obtaining a pre-compiled binary

Configuring shell for asdf

Applying Ruby to Shell or Working Directory

Bonus: Installing Gems! 💎

Conclusion

Navigating Technological Enthusiasm: Al, Privacy, and Virtue Ethics in Human-Computer Interaction

📖 10 min. read

Understanding Technological Enthusiasm in the Age of Artificial Intelligence (AI)

Privacy Concerns and Ethical Considerations for AI

Privacy and Giving Control Back to The User

Reviewing Privacy Settings on Your Accounts

Virtue Ethics and Technological Enthusiasm

Applying Virtue Ethics to Human-Computer Interaction

Ethics Hidden in Plain Sight

Conclusion

References

The `Gemfile`

Using the Windows Package Manager `winget`

Installing `asdf`