DEV Community: Sebastien Sanz de Santamara

An Intro to Debian & Ubuntu

Sebastien Sanz de Santamara — Mon, 16 Sep 2019 16:43:04 +0000

Taking a brief look into two popular linux operating systems, Debian and Ubuntu.

As a newcomer, peeking at the current state of the linux operating system world may induce a degree of vertigo.

Generally the world is simple when choosing a computer operating system, most everyone pics a side with Mac OS and Windows, and then Linux.

While Apple & Microsoft focus their resources on delivering updates to only one version of their operating systems at a time (Windows XP, 98, 7, or Mac OS 9, Snow Leopard, Mojave, etc..), Linux distributions is a vast chasm of myriads of instances, flavors, and mutations of the OS; each engineered to do different things.. or more often then not, do the same things differently.

Linux distributions is so rich and diverse, it resembles the vastness of code repositories found on versioning control services like Github. In fact, its no surprise that the Git versioning system was created by Linus Torvalds, the creator of the Linux kernel.

There are a gazillion-trillion linux distributions available. Actaully 898:

Today we're going to take a comparative look at two most popular of distributions, Ubuntu, and its original parent OS called Debian.

Debian is one of the first original Linux distros developed in 1993, and Ubuntu, a fork of Debian, came into light in 2004, 11 years later.

Releases

Version releases for these to flavors are noticeably different. While Debian has been around for longer, its latest version rests at 10, while Ubuntu has nearly twice the amount. This is because Debian is supported by a volunteer-based community that strictly adheres to an open-source ethos. Ubuntu, while also open source driven, is actively maintained by Canonical, a private company that also sells enterprise style services.

Debian always has at least three releases in active maintenance: stable (currently Buster), testing (Bullseye) and (Sid) unstable.

Debian Unstable is permanently named Sid after the boy next door in Toy Story 1 who liked to destroy toys. Use at your own risk!

Ubuntu abides by a strict release schedule but with more frequency introducing a release every six months and an LTS – Long Term Support release every two years.

Compatibility and Management

Both flavors use the same software packaging system called "apt", but the difference lies with the delivery and inclusion (or not) of proprietary software. Debian explicitly promotes free and open source software and hardware drivers, and does not include proprietary software by default.

This means that Debian, in certain occasions, can be restrictive to what type of hardware or apps you want to use with it, and while there are work-arounds, the process is not for the faint of heart.

On the other hand, Ubuntu bundles a variety of open, closed, free, or licensed software giving more flexibility.

Performance

For me , an appealing factor about a Linux distro is the efficient use of resources and often lightning fast performance compared to Windows or Mac.

Ubuntu is noticeably faster then Windows or Mac, but slow compared to Debian. This is because Ubuntu's desktop environment and specific items like its Accounts features and GUI does affect performance. Debian on the other hand, is just bare-bones, thus super fast and lightweight at the expense of a kinder/gentler user experience.

Which one is better?

Like all things development/programming/code, it depends on the problem you are trying to solve.

Ubuntu provides a solid desktop experience that competes with the likes of Windows or Mac, but sacrifices some the open-source ethos that Linux, as a concept, stands up to. Canonical is a privately owned company that does in fact provide services at cost.

Debian provides strict security and low use of resources, all while adhering and being maintained by the open-source community, at the cost of ease of use..

In general the latter is an ideal environment for a more experienced user who wants much more control and configuration, while the former is an ideal solution to the consumer / beginner user looking to get their feet wet.

Rails Setup on Ubuntu 19.04

Sebastien Sanz de Santamara — Thu, 13 Jun 2019 19:31:13 +0000

Around this time last year we soft released the first version of Rivet, a marketplace designed to find and activate resources for the development of creative practices.

I asked our developer, the amazing Francis Tseng, to teach me how to setup a local development environment so that I could a) make copy edits to our view templates and b) learn how the system works with the (at the time) far fetched idea that one day I could maintain the product and build new features.

The first challenge was to get my hands on a Unix based operating system. This meant I either had to setup a Linux distro via a Virtual Machine on my Windows machine, or just wipe the hard drive and go full Linux.

Since I like to do things the hard way, I chose the latter and after many(and i mean many) installs of various linux distros, I've settled, for the moment, with good old Ubuntu.

As such, today I want to share how to setup a Ruby on Rails local development environment on a Linux machine running Ubuntu 19.04 Disco Dingo:

Step 1: Install the latest version of Ruby.

There may be a need to work with older versions of the Ruby language depending on your project, no worries, you'll be able to add them after this initial setup with rbenv(see more below).

First, we need to make sure you have all the dependencies required for both Ruby and Rails.

In your terminal, run:

sudo apt install curl
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list

sudo apt-get update
sudo apt-get install git-core zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev software-properties-common libffi-dev nodejs yarn

Install Ruby using the version managing tool called rbenv.

Note you can also use another manager called rvm, but personally I had an easier experience with rbenv.

In your terminal, punch in:

cd
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL

git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' >> ~/.bashrc
exec $SHELL

rbenv install 2.6.3
rbenv global 2.6.3
ruby -v

The last 3 lines are important here because once you have rbenv setup, you can install other versions of ruby and switch between them per your development needs.

The below example will install ruby 2.5.1 and set it as the local version for a specific application you may be working on. Make sure you're in the working folder of your app.

rbenv install 2.5.1
rbenv local 2.5.1

Last but not least, install Bundler so you can package ruby gems to your hearts content.

gem install bundler

rbenv users need to run rbenv rehash in your terminal after installing bundler.

Step 2 - Configure Git

For versioning control of your code, we have to setup Git with your account info (for this tutorial, we're using a Github account):

git config --global color.ui true
git config --global user.name "YOUR NAME"
git config --global user.email "YOUR@EMAIL.com"
ssh-keygen -t rsa -b 4096 -C "YOUR@EMAIL.com"

The last step generated a new SSH key for you and your machine. Copy the output of your key from the following command:

cat ~/.ssh/id_rsa.pub

and paste it in your Github settings here

Then go back to your terminal to see if it works:

ssh -T git@github.com

You should see:

Hi (username)! You've successfully authenticated, but GitHub does not provide shell access.

Installing Rails

gem install rails -v 6.0.0.rc1

Since we are using rbenv, run the following command to make rails executable available:

rbenv rehash

With Rails installed, you can run the rails -v to check if the version installed installed correctly:

rails -v
# Rails 6.0.0.rc1

Setup PostgreSQL

Rails comes with SQLlite out of the box, very practical.. but if you want to deploy your app to a service like Heroku, you will need to use PostgreSQL.

To set up PostgreSQL, first we'll need to add a repository to your machine:

sudo apt install postgresql-11 libpq-dev

Next, you'll need to setup a user with permissions to create databases locally.

sudo -u postgres createuser username_of_ur_choice -s

You can also (not required) set a password for this user, then:

sudo -u postgres psql
postgres=# \password username_of_ur_choice

And now, drum-roll...

Lets create your first Rails app!

## Using SQLite
rails new myapp

## Using Postgres
rails new myapp -d postgresql

# Move into the application directory
cd myapp

# Note - If your Postgres is installed with a username/password, modify the
# config/database.yml file in your ruby app folder to include the username/password you defined when setting up postgresql

# Create the database
rake db:create

# Moment of truth
rails server

Go to http://localhost:3000 on any browser of your Disco Dingo install to view your locally deployed install of Ruby on Rails!

You should see:

Now that you're up and running, it's time to start building your awesome application/s.

Sinatra, No One Cares

Sebastien Sanz de Santamara — Tue, 14 May 2019 15:21:09 +0000

Sinatra is a Ruby low-level micro-framework.

What is a framework? Glad you asked!

A software framework is an abstraction in which software providing generic functionality can be selectively changed by additional user-written code, thus providing application-specific software. A software framework provides a standard way to build and deploy applications.

https://en.wikipedia.org/wiki/Software_framework

Sinatra, as a framework, lets you CRUD within a RESTful structure, thus Creating, Reading, Updating, and Deleting data via a web browser. It does this through standardized RESTful conventions like GET and POST. With Sinatra, you can make things like a simple website, blog, or barebones content management system.

As our mod geared up towards Sinatra, some peers from earlier mods I’ve spoken to described this little framework with a slight tinge of disdain, as in “Eww, you’re going to start using Sinatra”. And any time someone made an icky face about Sinatra to a noob like myself, it reminded me of the album cover for Frank’s seminal work “No One Cares”, a collection of heart-brake and love-struck songs depicting how even a staple like Sinatra himself, also gets no love.

I couldn’t help correlating lonely Frank and the relationship some programmers might share with Sinatra versus Rails.

But despite said pity party, lets take a look at some statistics showing how Sinatra actually holds it's own in the framework field.

Sinatra's usage is only a mere 95% less than Rails in 2016, but that means it’s being used by 5% of the Ruby framework market and that’s not a negligible number in any market. More so, it ranks 73rd place in Ruby Gem usage in 2018. Not bad considering there are at total 152,505 gems available.

from: https://infinum.co/the-capsized-eight/analyzing-rubygems-stats-v2018

This goes to show that Sinatra is a robust little tool, and therefore when comparing it with Ruby, would be more suited toward something like the below image:

Here lies the importance of getting comfortable with Sinatra before jumping into larger frameworks. When your hardware store is closed or your power tools are broken, having a deeply rooted skillset to solve challenges (because you’ve solved them with a simpler tool like a foldable knife) is crucial.

Beyond that, it also helps you understand and thus deeply appreciate a framework like Rails. Having a good base of experience with Sinatra will allow you to program better with larger, more complex tools. It will help you find solutions to bugs and challenges you'll hit in the future.

Lastly, Sinatra is ideal for projects that don't require all the bells and whistles Rails provides. Sometimes you don't need an 18v lithium powered cordless hammer drill/driver, a pocket knife will do.

Using Sinatra, through its simplicity, may even evoke the words of this Amazon reviewer for “No One Cares”,

Frank is so good that he can put you in the mood whether you were in that mood to begin with or not.”

Check out this awesome long list of apps, tools, and websites using Sinatra.

Writing JOINS in SQL

Sebastien Sanz de Santamara — Sun, 05 May 2019 20:33:19 +0000

Week two at Flatiron School had us jumping straight into SQL. I was keen to learn more about SQL since I have experience running Wordpress sites, like the artist residency program I co-founded, Residency Unlimited.

I have spent unhealthy amounts of time googling SQL queries to figure out, for example, how to assign single posts from one post-type to another in phpMyAdmin (and back again, yuck!).

With a deeper grasp of databases and their management via SQL, I find it easier to grasp Object Orientated Programming and particularly value how Active Record streamlines the process between a database and your code.

Databases themselves are about as exhilarating as tanks of gas, but that’s ok, they don’t need to be exciting. Their purpose is to hold the fuel (in our case, content) that our car needs to function. SQL is a means to get the gas from tank to engine.

Lets dive into SQL JOINs by observing the following situation:

This diagram shows us how we can apply a JOIN to the above scenario.

A JOIN in SQL returns rows from multiple tables by identification through these three sections: INNER, LEFT, and RIGHT.

Let’s take a look at how different JOIN types do different things.

INNER JOIN

INNER JOIN — or simply JOIN, can be used to find a match between two tables. Both tables need to share a key. This key is used to make the match. Non-matching results are discarded.

SELECT \*
FROM TableD Dogs 
INNER JOIN TableC Car
ON Dogs.key = Car.key;

LEFT JOIN

LEFT JOIN — Returns all rows from the left table, and the matched rows from the right table.

SELECT \*
FROM TableD Dogs 
LEFT JOIN TableC Cars
ON Dogs.key = Cars.key;

You can also add a WHERE clause to return only rows from the outer section:

SELECT \*
FROM TableD Dogs 
LEFT JOIN TableC Cars
ON Dogs.key = Cars.key
WHERE Cars.key IS NULL;

RIGHT JOIN

RIGHT JOIN — The same as LEFT, but in reverse. Returns all rows from the right table, and the matched rows from the left table.

SELECT \*
FROM TableD d 
RIGHT JOIN TableC c
ON c.key = d.key;

And like in the previous example, return only rows from the outer section.

SELECT \*
FROM TableD Dogs 
RIGHT JOIN TableC Cars
ON Dogs.key = Cars.key
WHERE Dogs.key IS NULL;

FULL OUTER JOIN

FULL OUTER JOIN — Returns all rows when there is a match in ONE of the tables.

SELECT \*
FROM TableD Dogs 
FULL OUTER JOIN TableC Cars
ON Dogs.key = Cars.key;

Just want OUTER JOINS, excluding INNER?

SELECT \*
FROM TableD Dogs 
FULL OUTER JOIN TableC Cars
ON Dogs.key = Cars.key
WHERE Dogs.key IS NULL
OR Cars.key IS NULL;

Why is this important?

It reflects the DRY (Don’t Repeat Yourself) rule.

Only using INNER JOINs on every query returns a unique match discarding any non-matching entry. There is no way to know which dogs have never been in a car, or which car has never had a dog in it. You quickly find yourself going back and forth to find that specific information when you need it.

Using LEFT, RIGHT or FULL JOINs provides more detail in one fell swoop, resulting in faster insight to what your database contains and how its contents are related.

Other JOINS

There are other operators in SQL that help you parse rows. For example, using CROSS will join everything with everything, and UNION joins the results of two queries into one column and removes duplicate entries.

Check out SQL definitions on W3schools and try out your JOIN skills on Hack Array.