Forem: FigueroaR

Ruby, Videosgames & DrangonRuby Engine

FigueroaR — Tue, 18 Aug 2020 16:47:56 +0000

As part of ongoing research on Ruby, I wanted to know what was possible with Ruby, to what extend we can push the language and the outcomes. Along with researching Ruby, I researched other languages like Python, Java, JavaScript, and C along with C++. There are many game engines for Ruby like:

Gosu
Shoes
ruby 2d
gioco
rubygame
gamebox

check out the ruby toolbox to learn more about each library.

Although we have many libraries for Ruby, there has not been many popular games released. We have to understand why. Most games on consoles or mainstream games have dedicated engines. Example: Frostbite Engine & Unity are built with c++ . These two engines are extremely powerful.

Of all the ruby engines, DragonRuby seems to be the most developed well executed, easy to understand engine. Some game were released in the App store for IOS and now Nintendo Switch.

It is a difficult task to build a Ruby Engine, Amirali Rajan explains why in this video. Essentially, we need low level computing languages to build a structure that can then be manipulated by a high-level language like Ruby.

So, what’s next? Does time mean there will never be a powerful engine like Frostbite Engine or Unity for ruby? There is a glimmer of hope.
Ruby was never meant to be fast; it was meant to make the developers happy, but slowly and surely ruby has gotten faster. With the release of Ruby 3 (or 3x3), Ruby claims to be 3 time faster than Ruby 2.0. Ruby 3.0 is expected to be released Q4, 2020, however it is not set in stone. This leads me to believe we could have a bright future for development for be it, mobile apps, or game application with Ruby. I cannot foresee the future, but I only hope this user-friendly (Ruby) language gets the push that it needs.

Mobile Apps & Ruby

FigueroaR — Sun, 05 Jul 2020 20:15:42 +0000

During my journey studying & learning Ruby, to my surprise, Ruby is a beautiful user-friendly language as many of you have come to realize and love! Like any specific field of study, we come across difficult concepts to master. With programming, be it any programming language, our thought process changes. Currently when I look at projects/objects in life, I no longer take them for granted, I now see the mind that built and engineered the idea. I have an appreciation for the mind and our seemingly endless capabilities.

For this reason, when I looked at website and mobile apps, I see the strenuous work that went behind it to make it come alive. This led me to ask myself more about mobile applications and how they work. I researched how to develop mobile apps and what it takes to create one. From the device OS, native OS programming language, cross platforms programming language (how to build apps for multiple Devices with one language), to how can ruby be implemented to build mobile apps.

I have good and bad news:

The Good

There is a method of developing mobile apps that has come to the forefront compared to other alternatives for Ruby, It is called Ruby Motion. This is a cross-platform native app builder, if you don’t realize how big a deal that is…. let me explain bit further! We can build apps for Android && IOS at the same time with one build. Yes, there are other cross platforms like React (which requires learning JavaScript) & Flutter (which requires learning Dart programming language). Ruby Motion is built specifically for Ruby. Personally I love Ruby for its easy of programing. Ruby Motion has a slack channel to stay up to date with any ongoing.

The Bad

Ruby Motion is for development on OS X (Mac Desktops) only, Windows and Linux developers miss out on the fun. This will hurt Ruby Motion on the long term. Ruby Motion has a real shot at becoming adopted in mass if they include other OS systems. I hope to see them expand, Ruby is a beautiful user-friendly language and future developers will have fun with this cross-platform app builder. Meanwhile Ruby Motion has a slack channel to stay up to date with any ongoing.

Why I like restful routing

FigueroaR — Sat, 13 Jun 2020 01:12:32 +0000

Let us take a walk down memory lane. When we access our thoughts, we do it in an abstract manner. Through a smell, a color, a location we can access many memories, memories from years ago or as recent as a few seconds ago. Our brain is a beautiful thing, but we cannot always control it the way we would want to.

Accessing our memories on demand is a complicated thing. With time our memories tend to lose their detail. While recalling memories under stress we tend to forget what we already know by heart. We do not have a specific method of accessing each memory category. For example, let us say we want to remember a recipe. Its difficult to access a section called” recipes”, in part because that does not exist in out brain. We do not have little folders in our brain referencing each material or type of ideas.

There is a solution, we can save the recipes in a computer, in a nice folder and have other subfolders in it, where we can save different types of recipes. If we have this information on a website, maybe we want to add, create, update, or delete recipes. This is all possible thanks to Thomas Fielding. Mr. Fielding had the wonderful idea called RESTful routing, an idea that dictates a manner to access information via an address that follows a protocol. Example: /recipes/:id/edit. Here we access our recipes, now we need a specific one (:id), then we go an edit it.

It is all 20/20 hindsight, but early websites did not apply RESTful routing, this made it difficult to locate yourself in a website. But with REST routing, it is easier to navigate and even guess what the next address is, we can maybe type it in ourselves and have access (depending on our security logic). This has brought a type of standardization to the industry, one much needed.

Get Your Github Repo Verified

FigueroaR — Sun, 07 Jun 2020 13:58:21 +0000

This is a quick guide to get your repo verified on Github.

First step is to enter Github and create your repo, name it anything you want!

Second step is to choose a license, without a license, our repo will not get verified.
The one I always pick is the "MIT License". With this option anyone can use or code, but they have no guarantee.

Setting up Rails --Api

FigueroaR — Mon, 01 Jun 2020 01:24:50 +0000

A good question is: Why would we want a rails Application Programming Interface? Well… you came to the right place. A short quick and simple explanation. An Api serves to maintain, hold and transfer information. Let’s pretend we are a start up and we have a product called tweeter. Tweeter is an application where we can send tweets (thoughts &/or information) on the internet. Now we need a location (databse) to hold our users who sign up and tweet. Our API talks to our database who stores all out information. This is crucial for any application. For now we are involved in the backend (database) and API – (middle backend) of our application.

Continuing with our start up example. We need to set up our rails API. First line of code we need to write is

rails new tweeter –api

we of course called our api “tweeter” but you can give it any name you like

rails new any-name –api

And that is it, our API is up and running. However, we do not have a database set up. For that we need to create a table and rows of information. It is simple, lets look. So our user here will have a username, email, phone number and a password (we will call it password_digest).

rails g scaffold User userName email password_digest phoneNum:integer

rails g scaffold Tweet content user_id:integer

On our column, no need to declare it a string, all info is taken as strings, but phone number which are integers must be declared as integers. Booleans & integers must be declared with their corresponding column.

Next we run rails db:migrate and we have our first table, model, controller, but for now we wont worry about our views, we will take a look at associations our next talk.

Do not forget to bundle our gem ‘bcrypt’ it is essential on our Gemfile. Visit our Gemfile and uncomment or add –

gem bcrypt

Then in our terminal run

bundle install

We are closer now to setting up tweeter.

At this point we need to scaffold a table, migrate that table, create our associations, console into our project and create users and tweet. Sound Simple enough? Lets dive in then!

First lets create out “Tweet” table

rails g scaffold Tweet content user_id:integer

And we get

class CreateTweets < ActiveRecord::Migration[6.0]

  def change

    create_table :tweets do |t|

      t.string :content

      t.integer :user_id

      t.timestamps

    end

  end

end

So now we have a user table and Tweet table and we need to migrate them.

rails db:migrate

At this point our controller and model have been set up.

class Tweet < ApplicationRecord
end

class TweetsController < ApplicationController
  before_action :set_tweet, only: [:show, :update, :destroy]

  # GET /tweets
  def index
    @tweets = Tweet.all

    render json: @tweets
  end

  # GET /tweets/1
  def show
    render json: @tweet
  end

  # POST /tweets
  def create
    @tweet = Tweet.new(tweet_params)

    if @tweet.save
      render json: @tweet, status: :created, location: @tweet
    else
      render json: @tweet.errors, status: :unprocessable_entity
    end
  end

  # PATCH/PUT /tweets/1
  def update
    if @tweet.update(tweet_params)
      render json: @tweet
    else
      render json: @tweet.errors, status: :unprocessable_entity
    end
  end

  # DELETE /tweets/1
  def destroy
    @tweet.destroy
  end

  private
    # Use callbacks to share common setup or constraints between actions.
    def set_tweet
      @tweet = Tweet.find(params[:id])
    end

    # Only allow a trusted parameter "white list" through.
    def tweet_params
      params.require(:tweet).permit(:content, :user_id)
    end
end

This outcome applies to our User table too. However, our models need an association, how would our table look now? Both User and Tweet

class User < ApplicationRecord

  has_many :tweets

end

class Tweet < ApplicationRecord

  belongs_to :user

  has_secure_password

end

What happened here? Well we are bringing in extra methods that can be called upon when we need to derive associated information. Our ‘‘has_secure_password” helps to mantain our password hidden when displaying information, it needs ‘gem bcrypt’ to function. I do need some extra users in the database however, so I’ll dig into the console and add them manually.

rails c

then

User.create(username: "rocky", phoneNum: 2021234567, email: "rocky@email.com", password_digest: "rocky")

& a Tweet

Tweet.create(content: "First tweet!", user_id: 1)

The user id column is so important, that is where we put the id of the user who creates the Tweet. Now when we run

Tweet.all

User.all

in our console and we see we have populated information. To see our data display as json data, we simply go to our localhost and use the routes. Run

rails s

in your terminal and In this case we will go to

localhost:3000/users

localhost:3000/tweets

in our browser, (yes it has to be plural or according to your routes if changed). All our information we inserted manually should be there waiting for us.

That was not so bad! Next, we will utilize active model serializers to display information that is associated with one another

To setup our Active model serializers we need a few steps. It will be so quick; it will surprise you. Before we start let us look at the data that is presented to us when we initialize our localhost and hit our routes from our backend

[
   {
      id: 1,
      username: "rocky",
      phoneNum: 2021234567,
      email: "rocky@email.com",
      password_digest: "rocky"
   }
]

Our password is being shared; we do not want that. So, lets fix it. First, we must access our gem files and add our gem.

gem 'active_models_serializers'

Then install with

bundle install

Once we have set our gem up, we need to create the serializer objects based on the models we have created.

rails g serializer User

rails g serializer Tweet

Great. Now we have our serializers:

class UserSerializer < ActiveModel::Serializer
  attributes  :id
end

Oh no, we have only one attribute on our serializers.

[
   {
      id: 1
   }
]

Here is where we add or remove our information. Naturally with our routes, our information is being sent through our controllers. But with our serializer we control the data and what is being displayed.

 class UserSerializer < ActiveModel::Serializer
  attributes :id,
         :username,
             :phoneNum,
             :email
end

Fantastic, we now are sending the specific information we want to share and display Our data now looks like this.

[
   {
      id: 1,
      username: "rocky",
      phoneNum: 2021234567,
      email: "rocky@email.com",
   }
]

A cool trick is to associate data through our serializers, it’s just like creating associations between our models. It looks something like this.

[
   {
      id: 1,
      username: "rocky",
      phoneNum: 2021234567,
      email: "rocky@email.com",
      tweets: [
         {
            id: 1,
            content: "My first Tweet",
            user_id: 1
         }
      ]
   }
]

How cool is that? We now have finished building Tweeter’s Backend, what an accomplishment!

One last thing, on your Config/Application.rb file you must have your file like this

class Application < Rails::Application
    config.middleware.insert_before 0, Rack::Cors do
      allow do
          origins '*'
          resource '*', headers: :any, methods: [:get, :post, :delete, :patch, :options]
      end
    end
    # Initialize configuration defaults for originally generated Rails version.
    config.load_defaults 6.0

    # Settings in config/environments/* take precedence over those specified here.
    # Application configuration can go into files in config/initializers
    # -- all .rb files in that directory are automatically loaded after loading
    # the framework and any gems in your application.

    # Only loads a smaller set of middleware suitable for API only apps.
    # Middleware like session, flash, cookies can be added back manually.
    # Skip views, helpers and assets when generating a new resource.
    config.api_only = true
  end

and add the rack CORS gem.

gem 'rack-cors'

along with pry if you so desire

gem 'pry'

then we bundle install.

Now you are ready to do some Asynchronous calls to your --API

Thoughts? let me know!

Create & Publish Your First Ruby Gem

FigueroaR — Fri, 06 Dec 2019 01:50:17 +0000

We can build and publish our gem in a few steps.

After we have written our code, our command line interface(CLI) and inspected it, we are ready to upload it (https://rubygems.org).

Today we will be updating, creating and publishing a Ruby Gem. We currently are in version 0.1.3.gem.

In order to update this gem we need to change the Version, to a higher number preferably.

Once we have manually change the version number, run this command:

"gem build insert-name"

At this point our gem has bee created, I recommend taking the time to visit "rubygems.org" where our gem will be pushed/uploaded to. Create and register an account, you will need it while pushing via command line.

Now it is Live!
https://rubygems.org/gems/crypto_price