DEV Community: Aweys Ahmed

First time guest on a Podcast.

Aweys Ahmed — Fri, 20 Aug 2021 15:57:16 +0000

Hey everyone,

I'm exited to start blogging again but in the meantime, I wanted to share a link to a podcast that I was a guest on recently.
https://www.codewithjason.com/code-with-jason-podcast/episodes/103-from-junior-to-intermediate-with-aweys-ahmed-q0qcp5wc/

It was an honour to be a Guest on Jason Swett's podcast. In the episode we discussed how new developers can level up and some of the obstacles that new developers face.

I hope you enjoy the podcast and I would checkout Jason's other podcasts and material as well. https://www.codewithjason.com

What are Service Objects in Ruby on Rails? Should you use it?

Aweys Ahmed — Mon, 16 Mar 2020 12:55:06 +0000

In a previous blog post, I mentioned that it was considered good practice to keep your controllers skinny and add the bloat to your model. However, this is not always desirable.

Using service objects we can try and keep both our controller and model lean, readable and easier to test. This will make everyone happy.

What are Service Objects?

Service Objects are plain old Ruby Objects (PORO). They are created to remove the bloat from your controller and/or model.

It is intended to move business logic into separate files that you can be used elsewhere.

Service objects should adhere to the single responsibility principle. This means that your service object should focus on doing one thing.

It is important that your service object method returns something substantial and meaningful like an object.

Let's look at an example of code that needs to be refactored. In the example below, we'll have an Employee's controller that renders the employees details but what we'll be focusing on is the calculation of federal and provincial taxes (This is not based on actual tax rates in Canada).

class EmployeesController < ApplicationController
  before_action :set_employee, only: [:show, :edit, :update, :destroy]

  # GET /employees/1
  # GET /employees/1.json
  def show
    @federal_tax = @employee.salary / 10
    @provincial_tax = @employee.salary / 20
  end
end

So you can see that we are calculating the tax rates and storing them in an instance variable to be rendered in the show view. This works but isn't optimal.

Let's see how service objects can help us.

How do we use a Service Object?

The first thing we need to is to create a services folder under the app directory. Rails will autoload anything under the app directory.

Then we will create a class called ApplicationService that our service objects will inherit from.

class ApplicationService
  def self.call(*args, &block)
    new(*args, &block).call
  end
end

This above class method creates a new instance of the class with the arguments that are passed into it and calls the call method on the instance.

(WHATTTTTT?)

Let's look at an example to make sense of what that means.

Let's create a service object that converts kilometres into meters.

class KilometresToMeters
  attr_reader :measurement

  def initialize(measurement)
   @measurement = measurement
  end

 def call 
  measurement  * 1000
 end
end

If we didn't inherit from the ApplicationService, this is what our service object would look like in our controller.

def calculate
 @distance = KilometresToMeters.new(params[:value]).call
end

Here is the same call using the ApplicationService inheritance. Since we created an instance of the class in our ApplicationService, we don't need to do it when we use the service object in the controller.

def calculate
 @distance = KilometresToMeters.call(params[:value])
end

It isn't the biggest change but I prefer this way of shortening the service object call and it increases the readability of the code.

Now let's implement our service objects for our tax calculator.

class FederalTaxAmount < ApplicationService
 attr_reader :salary

 def initialize(salary)
  @salary = salary
 end

 def call
  salary / 10
 end
end

Let's repeat the process for the provincial tax calculation.

# frozen_string_literal: true

class ProvincialTaxAmount < ApplicationService
  attr_reader :salary

  def initialize(salary)
    @salary = salary
  end

  def call
    @salary / 20
  end
end

Now that we have created our service objects, let's see what they will look like in the controller.

  def show
    @federal_tax = FederalTaxAmount.call(@employee.salary)
    @provincial_tax = ProvincialTaxAmount.call(@employee.salary)
  end

This controller looks cleaner than what we used in the beginning. This was a simple example for illustration purposes but you can imagine how this could clean up a larger and more complex controller.

The service objects have also made it easier to determine what our application is doing.

Here is a view of what the services folder looks like.

Looking at the services folder of this simple application gives you a very good idea of what this application does. This can also be very helpful for larger projects.

I hope you found this blog helpful and that you can implement a service object in your next project to keep you controllers and models lean.

How to create a basic search form and how to use Elasticsearch as an alternative.(Ruby on Rails)

Aweys Ahmed — Thu, 05 Mar 2020 15:22:23 +0000

In this the tutorial, we will review how to build a search form and then we'll look at how to implement a search form using ElasticSearch. I'll be using a book review app that I built recently.

I want to implement a search function that will allow users to search the database for a book that has been reviewed.

Basic Rails Search

In the app, a user can have more than one book review and a book review belongs to a user.

Let's look at what the respective models look like.

This is the book review model.

# frozen_string_literal: true
class BookReview < ApplicationRecord
  belongs_to :user
end

This is the user model.

# frozen_string_literal: true
class User < ApplicationRecord
  has_many :book_reviews
end

We'll have to work with the model, view and controller in this app.

The first thing we'll do is add the search function to our view. We'll be using the index view to add the search function.

Modifying the view

  <%= form_with url: book_reviews_path, method: :get, local: true  do |form| %>
    <%= form.label :search, "Search Books:"%>
    <%= form.text_field :search, id: :search, class: "form-control" %>
    <br />
    <%= form.submit "Submit", class: 'btn btn-primary'%>
  <%end%>

This will create our search form and our controller is waiting to receive the params[:search] and that is set in the form.text_field.

Modifying the Book Review Model

The next thing we want to do is add the logic for our search to the model. The reason we are adding it to our model and not our controller is that it is good practice to keep your controllers lean and add logic to your models.

# frozen_string_literal: true

# BookReview Model with validations
class BookReview < ApplicationRecord
  belongs_to :user

  def self.search(search)
    if search
      book_reviews = BookReview.where('title LIKE ?', "%#{search}%")
      if book_reviews.present?
        where(id: book_reviews)
      else
        all
      end
    else
      all
    end
  end
end

(I'm using Rails 5.1.7 and with this comes the ability to use all instead of typing BookReview.all)

Our search function will render on the index page. If there isn't a search parameter entered it will render all the books. It will also render all the books if the search doesn't find a match.

Now that we have seen how a basic search form is added to a rails project, let's look at what we can use that will allow us to scale and have a more efficient and robust search.

The current search we are using works well for a small project but large scale applications will need something else.

ElasticSearch

Elasticsearch is an open-source search and analytics engine. It uses a REST API that makes it easy to use.

It has multiple uses but for this blog and tutorial, were are going to use it as a search engine.

If you are using brew you can issue this command to install elasticsearch

brew install elasticsearch

To use elasticsearch in our rails app, we'll need to add this gem and run bundle install.

gem 'searchkick"

Then we need to add searchkick to the model that we would like to search. In our example, we would add it to your book_reviews model.

# frozen_string_literal: true

class BookReview < ApplicationRecord
  searchkick
end

Then you'll want to add data to the search index.

rails searchkick:reindex CLASS=BookReview"

Type elasticsearch in the command line and then you can type

curl http://localhost:9200

in a separate window to make sure elasticsearch is up and running.

We don't need to make any changes to our index view, however, we will need to make changes to our model and controller.

Let's add the search logic to our model so that we are adhering to the design principle of fat models and skinny controllers.

  def self.advanced_search(search_results)
    if search_results
      BookReview.search(search_results, fields: [:title])
    else
      all
    end

Let's add this method to our controller

 def index
    @book_reviews = BookReview.advanced_search(params[:search])
  end

This is all we need to do to add elasticsearch. ElasticSearch will yield results out-of-the-box even if the user hasn't spelled the word correctly.

ElasticSearch can do some much more but I hope this tutorial has given you the knowledge on how to add it to your rails application.

What is Model-View-Controller (MVC)? (Ruby on Rails perspective)

Aweys Ahmed — Thu, 27 Feb 2020 13:42:42 +0000

Model-View-Controller (MVC) is a software design pattern invented in 1978 by Trygve Reenskaug while he was a visiting scientist at the Learning Research Group (LRG) at Xerox Parc.

The goal of MVC was to resolve the issue of users controlling a large and complex data set.

MVC was designed for desktop use but has been adapted for web applications and can be used differently depending on the framework.

Let's look into the three parts of MVC and how they work together to create a Ruby on Rails application.

Controller

In rails, the Control is called Action Controller. (Throughout the blog I will call it Controller instead of Action Controller)

The controller works with the view and the model in a rails application by acting as an intermediary. When an HTTP request is made the controller will determine the correct controller class and method to use.

Let's generate a scaffold to demonstrate how the controller works in a simple application.

# frozen_string_literal: true

class BooksController < ApplicationController
  before_action :set_book, only: [:show, :edit, :update, :destroy]

  # GET /books
  # GET /books.json
  def index
    @books = Book.all
  end
end

I have set the root of the application to the books#index route. So when the user reaches the root path of our application, the book's controller will know to use the index method.

Our index method uses Active Record to pull all the books from our database and stores it in an instance variable. Then we can use our index view to render all books.

<p id="notice"><%= notice %></p>
<h1>Books</h1>
<table>
  <thead>
    <tr>
      <th>Title</th>
      <th>Author's First name</th>
      <th>Author's Last name</th>
      <th>Year published</th>
      <th colspan="3">Settings</th>
    </tr>
  </thead>
  <tbody>
    <% @books.each do |book| %>
      <tr>
        <td><%= book.title %></td>
        <td><%= book.author_first_name %></td>
        <td><%= book.author_last_name %></td>
        <td><%= book.year_published %></td>
        <td><%= link_to 'Show', book %></td>
        <td><%= link_to 'Edit', edit_book_path(book) %></td>
        <td><%= link_to 'Destroy', book, method: :delete, data: { confirm: 'Are you sure?' } %></td>
      </tr>
    <% end %>
  </tbody>
</table>
<br>
<%= link_to 'New Book', new_book_path %>

View

The job of the view is to present information to the user. To display content from the model that was retrieved using the controller, we need to use a template engine. In the above example, we used embedded Ruby.

We can also use views to send data to our controller. The controller will then use Active Record which works with our model to save data to the database.

 # POST /books
  # POST /books.json
  def create
    @book = Book.new(book_params)

    respond_to do |format|
      if @book.save
        format.html { redirect_to @book, notice: 'Book was successfully created.' }
        format.json { render :show, status: :created, location: @book }
      else
        format.html { render :new }
        format.json { render json: @book.errors, status: :unprocessable_entity }
      end
    end
  end

private

  # Only allow a list of trusted parameters through.

  def book_params
    params.require(:book).permit(:title, :author_first_name, :author_last_name, :year_published)
  end
end

The create method above receives input from the new.html.erb file. The new method renders the form and the create method handles the input and stores the input into the database using Active Record.

Model

The model uses Active Record to interact with the database to fetch data or to store data in the database. The controller will use Active record to store the data in an instance variable. We have an example of that in our index method in our books controller.

Summary of MVC

The controller in a rails application works between the model and the view. This, in theory, allows for a separation of responsibilities in a rails app.

So when an HTTP request is sent, the controller will call on the correct method to determine whether or not data needs to be retrieved from the model via Active Record or will it post data. After this is determined, the controller will have the correct view displayed to the user.

What is Active Record? (Quick Intro)

Aweys Ahmed — Mon, 24 Feb 2020 13:23:25 +0000

In this blog post, I'll introduce you to Active Record which is used in the Rails framework.

Ruby on Rails uses a software design pattern called Model-View-Controller (MVC) and Active Record is part of the model in MVC. This means that Active Records works with your database.

Object Relational Mapping (ORM)

Active Record is an ORM. Using an ORM allows a developer to use the language they are working with to query a database without having to use MySQL, PostgreSQL or other databases query commands.

Active record maps the class name to a table in a database and each row to an instance of the class.

This is part one of the intro into Active Record and it will be a series. The following blog posts in this series will cover.

Intro Part II
Migrations
Validations
Callbacks
Associations
Queries

So far what you need to know about Active Record is that it is an ORM. It allows you to interact with a database using the language that you are building your application with.

In part two, we will look at some examples of how Active Record allows you to interact with your database.

Test-Driven Development (TDD) tutorial using Rspec and Ruby on Rails.

Aweys Ahmed — Tue, 11 Feb 2020 14:51:43 +0000

What is Test-Driven Development (TDD)?

It is a software development process where the development of your code is moved forward by the tests you write. It may seem counter-intuitive but with TDD you write tests that will fail and then you write code that will pass those tests.

In Kent Beck's book "Test-Drive Development By Example" he states these two rules.

Don't write a line of new code unless you first have a failing automated test
Eliminate Duplication

These rules bring us to Red/green/refactor method of TDD. The first test that you create will fail and then you write the necessary code to pass the test. Red indicates a fail and green means you passed. However, getting to green does not mean you are done. After you have passed the test, you will need to refactor what you have written.

Why test first?

Testing first can minimize bugs and the need to refactor as your codebase increases in size and complexity. Starting off with well written and tested code can also save cost and time.

Tests can also serve as documentation for your feature in an application. Other developers on the team can read your tests and easily figure out what your code is looking to achieve.

By creating the tests first, you can ensure that the function that you are testing works the way it is intended to work and avoid any surprises further down the line.

What is Rspec?

It is a domain-specific language written in Ruby and specifically designed for test writing. It is used for testing ruby applications. However, there is also a gem for testing ruby on rails applications called RSpec-rails.

In this tutorial, we will be using the rails testing version of Rspec.

The setup

To get this tutorial started let create a rails application. Let's open up the terminal and run this command in the directory in which you would like to create the app.


 new [name-of-your-app] -T

The reason we are using the -T flag is to prevent the rails Mini-test from being installed since we will be using Rspec in this tutorial.

Make sure you add the gem to the development and test section fo the gem file. Your gem rpsec-rails version may differ. At the time of writing this tutorial, 3.9 was the latest stable release.



#gemfile
group :development, :test do
  gem 'byebug', platforms: [:mri, :mingw, :x64_mingw]
  gem 'rspec-rails', '~> 3.9'
end

After that, you'll need to type run this command in the terminal.


 install

Then you'll need to run this command


 generate rspec:install

Now that we are set up for testing let's go over some of the RSpec syntaxes.

Important keywords

describe
context
it
expect

What is describe?

The describe keyword contains a group of tests called examples in Rspec.
The keyword takes a class name or a string argument.

The examples will be enclosed in a ruby do/end block.



describe Pet do 

end

In the above example, we are passing a class name as an argument.

What is context?

The context keyword is similar to describe in that it can take a class name or string as an argument and it also encloses examples in a ruby do/end block. It is optional to use but it can help add more information to your test.



describe Pet do 
 context "validations" do
 end
end

What is "it" and expect?

The Rspec keyword "it" is used to introduce a test or example.



describe Pet do 
 context "validations" do
  it "ensure the presence of a name" do 
  end
 end
end

The expect keyword outlines an expectation from the test results.



expect("value").to eq("actual value")

Let's see how this works as an example. Were going to create a Pet model


 generate model name:string

This command will also create the file needed to run the RSpec tests. It will be located in this location in your app



spec/models/pet_spec.rb

Now were are ready to start with TDD. Our Pet model requires a name. We want to validate the name before it is saved to the database.



require 'rails_helper'

RSpec.describe Pet, type: :model do
  context 'validations' do
    it "ensures the presence of name" do
      pet = Pet.new(name: "").save
      expect(pet).to eq(false)
    end
  end
end

The test above expects that the initialized pet object will return false because we passed in an empty string to the name attribute but we do not have any validations in place so we will get true when our expectation is false.

Since we only have one test that we are running, we can type in RSpec into the command line.

To get your test results to look like the above, you'll need to add --format documentation to your .rspec file which is located at the root level of your application.

The test has failed and we have our first red in the red/green/refactor of TDD. We need to prevent empty strings from been saved to the name attribute and turn this test green.

We'll need to head to our the Pet model in our application add a name validation.



class Pet < ApplicationRecord
  validates :name, presence: true
end

Now we run the test, we should expect it to pass and give us the green that we are looking for.

For this test, I specified the location of the RSpec file that I wanted to test. This will come in handy when you are testing a large application and you don't want to test every test that has been written.

Our test has now passed and for this example, we won't need to conduct a refactor for the pet model validations.

The next test we will write will ensure that the name of the pet has at least two characters.

So let's start by writing a test that will fail.



   it "ensures that name has two or more characters" do
      pet = Pet.new(name: "j").save
      expect(pet).to eq(false)
    end

Here is the output from the command line.

We have our failing test now so now we need to create the validation that will put us in the green.

In our pet.rb file, we'll include this



validates :name, length: {minimum: 2}

Using the length Active Record helper we can make sure that only names with 2 or more characters can get saved.

Let's run the test again and see if we get the passed.

We have passed the test and this example will not require a refactor.

For this tutorial, we will create one more test to ensure that valid names will be accepted.



  it "ensures that valid name will be saved" do
      pet = Pet.new(name: "Stella")
      expect(pet).to be_valid
    end

In this scenario, I don't expect it to fail but I'm going to add just to demonstrate what you can test for.

Here is the output of the final test.

I hope after this tutorial you have a better understanding of TDD and Rspec. There will be another TDD and Rspec tutorial that will encompass refactoring and other Active Record validation helpers.

What is Redis?

Aweys Ahmed — Thu, 06 Feb 2020 14:04:45 +0000

As you continue to learn more about software development, you'll start to hear about more Frameworks, libraries, tools and databases.

Sometimes this can feel overwhelming but rest assured you don't have to know and master everything in software development. No one has or will.

However, it doesn't mean you cannot try and learn as much as possible.

Once you start working on a larger project with a bigger development team, you may encounter Redis.

What is Redis?

It is an in-memory data structure store. It can be used as a database or cache. It can be used as a message broker as well but this is beyond the scope of this blog post.

When used as a database it would be considered a NoSQL database that uses Keys and Values. It supports these data structures.

strings
hashes
lists
sets
sorted sets
bitmaps
sorted sets

One of the main appeals of using Redis is its speed. Redis data is kept in-memory whereas other databases store data on disk or on SSDs.This allows Redis to access information much quicker. Redis will only store data on disk when it requires persistence.

Redis contains many other features that we will explore deeper in future blog posts.

I hope this blog post has given you enough information to know what Redis is?

If not, feel free to ask me and I will gladly provide more information.

Building and Publishing my first Ruby Gem. (Also a tutorial)

Aweys Ahmed — Mon, 27 Jan 2020 13:57:45 +0000

I have been looking forward to building a Ruby gem for quite some time. I have used them in my projects and wanted to see what is required to build one.

I'm also excited about sharing this process so that you can also build a Ruby Gem. If you choose to do so.

What is a Gem?

A Ruby Gem is a software package that you can download using the command line.

gem install [gem-name]

Ruby Gems extend your code and can reduce the amount of code you will have to write. They can work directly with your source code or help automate some tasks.

Here are examples of Gems that you can install.

Rails
Bundler
Rspec

Getting Started

I decided to build a Ruby gem that contains two Class functions that calculate the future value of an asset and the other function calculates the amount needed to have a certain value in the future.

Here is the link to my gem time_value_money so that you can look at the source code of a completed gem.

The first thing we will need to do is create an account at rubygems.org

After you have done that, you will need to open your terminal and type this command.

bundle gem [gem-name]

The output to your terminal should look like the below image.

The next thing you'll need to do is to push this up to your git account. You'll need your git source code URI to add to your README.md file.

The ReadME.md file will also have a few changes that need to be made.

We'll also need to create a CHANGELOG.md file in the root of your project. This will be used to log any changes to your gem file. The changes can come from either you or others.

Here is the CHANGELOG.md from my gem file to give you an idea of what needs to be included.

After creating the CHANGELOG file, you'll need to open up the gemspec file.

[gem-name].rb

The sections Marked TODO will need to be changed.

You will also want to remove or comment out these lines if you plan on posting it to rubygems.org.

To add functionality to your gem, you'll need to go to this file located at

lib/[your-gem-name]/[your-gem-name].rb

After you have added your code, you'll need to test it to make sure that it is working.

Once you have done that, you'll need to get your gem file ready for deployment.

You'll need to run this command in the terminal.

gem build [gem-name].gemspec

Then you'll need to sign in to rubygems in the command line. This can be done by typing

gem signin

and follow the login instructions.

Then you can finally push your gem to ruby gems by typing

gem push [name-of-gem]-0.1.0.gem

Congratulations, you have published your first Ruby Gem.

What is Flutter?

Aweys Ahmed — Tue, 21 Jan 2020 14:57:12 +0000

This weekend I decided to take the dive and build a mobile app. I always assumed that I would use React Native because I use React at work and it would be an easier transition.

However, I have also been curious about trying something different and something with the ability to work on ios, android, and web.

So I decided to build this app using Flutter over the weekend. The app is a simple future value calculator that determines what the value of an asset will be in the future.

What is Flutter?

Flutter is an open-source UI toolkit that can be used for mobile, web or desktop and is created from a single codebase. So you write your code once and it will run on ios, android, and desktop.

Dart Programming Language

Flutter uses the Dart programming language because it can be used to develop on different platforms (ios, android, web). It also has a fast development cycle by making use of hot reload. Any changes you make to your flutter application are automatically reflected in UI instantly.

Dart will be familiar to you if you have used JavaScript, Swift or Java.

Variables do not have to have their datatypes explicitly stated. However, when you create a function the parameters should have their datatypes specified.

Let's look at some sample dart code.

//function
void main() {
 print("Hello World");
}

Every app has a main() function and it has the keyword void to indicate that it isn't returning anything.

Let's look at how we would declare a function.

int addNum(int x, int y)
 return x + y;
}

Those were a few features of Dart. Head to the Dart to learn more about dart.

Here is a link to the Flutter App I built this weekend.

AweysAhmed / flutter-app

how_much

A new Flutter project.

Getting Started

This project is a starting point for a Flutter application.

A few resources to get you started if this is your first Flutter project:

For help getting started with Flutter, view our online documentation, which offers tutorials, samples, guidance on mobile development, and a full API reference.

View on GitHub

I still have some refactoring to conduct but the UI and the ability to calculate the future value are complete. Let me know if you have any questions or suggestions for the app.

I'll post about Flutter after I refactor and start the process of launching the app.

What is Object Orientated Programming (Part-three) Polymorphism?

Aweys Ahmed — Mon, 20 Jan 2020 14:29:03 +0000

This blog post will cover the object-orientated principle of polymorphism. Some of the concepts in polymorphism will also relate to inheritance.

What is Polymorphism?

Polymorphism means many forms. In OOP, this allows us to create a Superclass with a method that is inherited by its subclasses but the method in the subclass will perform a different action.

class Mammal
 def live_birth
  puts "We give birth to live animals"
 end
end

class Platypus < Mammal
  def live_birth
    puts "We lay eggs."
  end
end


duckBill = Platypus.new

duckBill.live_birth

#output 
"We lay eggs"

The above method of using polymorphism uses inheritance. The superclass and the subclass both contain the method live_birth but the Platypus class has changed the output of the method. This allows flexibility in your code.

In our Mammal class, it made sense to inherit that method because most mammals do give birth to live young, however, for the platypus class polymorphism has allowed us to override that method.

Summary

Polymorphism allows a subclass to use a method that is inherited from the superclass and to change it to meet the needs of the subclass.

The next blog post will still be about polymorphism but also include super and Modules.

What is a TypeScript Interface?

Aweys Ahmed — Mon, 13 Jan 2020 15:33:29 +0000

TypeScript Interface

Interfaces in TypeScript create a structure of what the object should contain. Think of how we created variables in the previous post and then stated what type the variable would accept. Interfaces allow us to do this with an object.

Let us imagine that we have a recreational basketball league and we want teams to register their players. However, we want to ensure that teams register their players with specific information. What we can do is create a basketball player interface and define its structure.


interface BasketballPlayer {
  firstName: string;
  lastName: string;
  jerseyNumber: number;
  position: string;
  currentTeam: string;
}

Now that we have created a Basketball player interface, let's see how we can use this.

const registerPlayer = (registerPlayer: BasketballPlayer) => {
  console.log(registerPlayer);
}

let kingJames = {
  firstName: "Lebron",
  lastName: "James",
  jerseyNumber: 23,
  position: "All",
  currentTeam: "Lakers"
}

registerPlayer(kingJames);




# console.log output  { 
    firstName: "Lebron",
    lastName: "James",
    jerseyNumber: 23,
    position: "All",
  }

Using the type of BasketballPlayer ensures that the correct information is submitted by all the teams and adds consistency to the application.

Any attempt to add other properties or omitting them will result in an error when being compiled.

We can also included properties that are optional. Let's assume that in our recreational league adding a nickname is optional. We could add that by adding ? after the property.

Here is what our BasketballPlayer type would like like with an optional nickname.

interface BasketballPlayer {
  firstName: string;
  lastName: string;
  jerseyNumber: number;
  position: string;
  currentTeam: string;
  nickName?: string;
}

Nickname is now optional and allows some flexibility on adding properties that are not imperative.

In our next blog post, I'll review how we can use Interfaces with Classes.

Framework vs Library (What are they?)

Aweys Ahmed — Fri, 10 Jan 2020 18:52:14 +0000

Using a Framework or library or both can help you build out applications. They are different despite these terms being using interchangeably.

What is a Library

A library is a collection of reusable code that has been created somewhere else. You end up calling these methods onto your code. The fact that you call the methods from the library into your application is a key differentiator from a framework.

Let's use React's render method to demonstrate how a library would be used in your code.

class Demo extends React.Component {
 render() {
   return <h1>We just used the render method</h1>
  }
}

In the above example, we used the React's render method to return the jsx code that we have written.

We use a library for the predefined methods and features on the code that we create.

What is a Framework?

A Framework creates a skeleton or scaffold that calls on the code that you have written. Once you implement the Framework, you fill in the rest of the code with your code. The framework will then call on your code.

Let's use Rails which is a ruby framework to demonstrate this.

class ArticlesController < ApplicationController

  def index
    @articles = Article.all
  end

end

Let's review the Ruby Controller above to see what the rails framework is doing.

I used rails to create this Articles controller and we have one method called index. The name of the method corresponds with a URL. When a user heads to the correct URL, rails will call the index method and run the code we defined in that method. So in the above example, every article will be stored in the @articles instances variable.

A framework calls on your code to execute whereas you as the developer call on methods from a library.

Inversion of Control

When you are using a library, you create your code and call on the library as you need it. With a Framework we have an Inversion of control and the Framework calls on your code to execute the unique features of your code.

Here is a quick analogy for Library vs Framework.

If you wanted to build a car from scratch you would need tools to get the job done. The tools that you would use to build the car from scratch would be your library.

If you were to use a Framework to construct a car, you would start with an already constructed chassis or vehicle frame and you would put in the unique finishing touches.

I hope this helped you getting a better understanding of Framework and Library.