Five Good Reasons to Use Spree Commerce for Your Storefront

If you read this article, you might be thinking about moving your business to the internet. Now is the best time because the e-commerce industry all over the world has grown significantly in recent years. More and more customers prefer online shopping to traditional ways of making purchases. In 2014 e-commerce sales exceeded $1.5 trillion globally.

However, moving your sales to the internet requires careful planning and implementation. The first and the most important step is choosing the right e-commerce platform for your online store and the developer team to make the heart of your internet empire beat. If you make a wrong decision, you might end up with a sluggish and inefficient system, time-consuming order management and ever increasing maintenance costs.

Based on recent marketing researches, the ideal e-commerce platform must meet certain criteria such as cost efficiency, ease of use, scalability, support and other. Spree Commerce is the platform that combines the best features of modern e-commerce platforms in terms of functionality and user experience. There are more than 20,000 online stores worldwide running on Spree Commerce. AYR, Lavazza, On Running, 20 Jeans, Rick Owens and other famous brands have implemented it in their business models. Thus, Spree Commerce can be used as a good example.

There are five key points of a modern e-commerce platform:

1. Totally Free

Spree Commerce is a completely free open source project. Anyone can do modifications to the code. It has more than 500 active contributors all over the world. The platform develops rapidly (even more rapidly than other commercial projects) and effectively utilizes the demands of ever changing market and its users. You do not need to pay for the license or give away percent of revenue. Just download, set it up and start using. The platform is especially good for the beginners or businessmen with tight budget.

2. Ruby on Rails Rules

Yes, the platform is based on the Ruby on Rails framework an elegant, fast and modern programming solution. This means that you will spend less time, efforts and resources to implement a new feature or enhance functionality, comparing to other e-commerce platforms. The core of the platform is lean and agile, prepared for advanced customization to suit any customer needs.

3. Efficient Order Management

When you launch the store, you will spend much time in its backend managing orders, customers and payments. Spree Commerce provides an easy and fast management system. You will be amazed with simplicity and functionality of the dashboard.

You can adjust payment methods, product sorting, tax rates, currencies and other vital settings in just a few clicks. With Spree Commerce you will focus on making money instead of wandering around to find the right button.

4. Advanced Tools, Features and Integration

Spree Commerce offers an impressive set of features that improve performance of your store. There are many options for SEO, such as keyword targeting, permalinks, meta-descriptions of products and much more. Spree Commerce supports all major payment methods and gateways. It also offers various extensions to the users.

Spree Commerce can be easily integrated with external services, such as Jirafe, Mandrill, Amazon, Bronto, Odoo, Shipstation, Zendesk, Netsuite, Mailchimp and many more.

5. Awesome Community

There is a huge community behind Spree Commerce. The participants actively develop the platform, add new functionality and solve challenges together. If any issue arises, feel certain that you will find the right answer and get help. There are free workshops, trainings and the famous annual SpreeConf. Spree Commerce provides a complete set of documentation as well.

In conclusion, we would like to recommend you the team of professional Ruby on Rails developers that focuses on creating robust and efficient e-commerce systems.

The RubyGarage team has already implemented and launched hundreds of successful e-commerce sites. As certified Spree Commerce Developers we're gaining popularity in both the USA and Europe.

Whether you are an e-commerce beginner or a large-scale businessman, you will get a cost-effective solution for your budget. Be smart, use Spree Commerce and boost your sales to space.

Originally published at https://rubygarage.org/blog/spree-commerce-for-your-storefront

.

What if I Tell You That Ruby on Rails Is Scalable

Ruby on Rails is a great framework for startups, but we often hear people talk about Rails scalability issues when a startup project grows too large (read: becomes very popular). One of the key events that triggered the discussion that Rails can't scale was when Twitter switched to Scala in order to handle their growing number of user requests. But as counterexamples, we would like to mention that Shopify is an advanced Rails application that has scaled quite well many years in a row. So who’s right? Do you need to ditch Rails if your app goes big?

Let's take a look at how to scale a Ruby on Rails application to find out.

What Is Rails Scalability?

A framework’s scalability is the potential for an application built with this framework to be able to grow and manage more user requests per minute (RPM) in the future. Actually, it's incorrect to talk about framework scalability or Ruby on Rails scalability, because it's not the framework that must, or can, scale, but rather the architecture of the entire server system. But we should acknowledge that, to a certain extent, Ruby on Rails application architecture does have an impact on scalability.

Let's take a look at the example below. This is what the entire server architecture looks like at the very beginning of a Rails project.

What we usually have is a single server, on which we install the following software:

• Nginx server;
• Rack application server – Puma, Passenger, Unicorn;
• Single instance of your Ruby on Rails application;
• Single instance of your database; usually, a relational database similar to MySQL.

This server computer will be able to cope with, say, 1,000 or even up to 10,000 requests per hour easily. But let’s assume that your marketing is very successful, and your Rails application becomes much more popular; your server starts getting 10 or 100 times more requests. When the load increases to a high enough level, a single server architecture cracks under pressure. That is, the Rails application becomes unresponsive to users.

That’s why we’ll explain how to resolve this scalability issue – serving data to users – with Ruby on Rails.

Let's scale your Rails application!

Vertical scalability with Rails

Scaling vertically is the simplest way to make the server handle an increased number of RPMs. Vertical scaling means adding more RAM, upgrading the server’s processor, etc. In other words, you give your server computer more power. Unfortunately, this approach doesn’t work in many situations, and here are a couple of reasons why.

Vertically scaling a server running a Rails app gives a positive effect only at the initial stage. When your traffic increases yet again, you eventually come to the point when upgrading the processor or adding more RAM is technically impossible.

But there’s another downside to this approach. When you need to scale your Ruby on Rails application, there are usually some parts that demand more computational resources than others. For example, Facebook needs servers offering different performance for updating the news feed and processing images. Image processing is used less frequently than the news feed. Therefore, Facebook installs a less powerful server for image processing than for the news feed. We’ll talk more about this architectural approach (Service-Oriented Architecture or SOA) to scaling your Rails app shortly.

When vertical scalability is no longer practical, or when we look for other scalability options right away, we scale a Rails application horizontally.

Horizontal scalability with Rails

We can scale a Rails application horizontally similarly to how we scale many other frameworks. Horizontal scaling means converting the single server architecture of your app to a three-tier architecture, where the server and load balancer (Nginx), Rails app instances, and database instances are located on different servers. In such a way, we allocate equal and smaller loads among machines.

Nginx

Nginx, a commonly used server software for Rails applications, is deployed on a single machine to serve as a load balancer and reverse-proxy. You need a medium-powered server for Nginx, because this server requires little computing power to function normally under high loads. Nginx’s sole aim is to filter and distribute the load among multiple servers.

We set up this server to receive the initial request and forward it to the first machine. The second request will be sent from Nginx to the second machine, and so on. When you have only three machines with your Rails application instances, then the fourth request from the client (browser) will be sent, naturally, to the first machine again.

Rails app instances

As we mentioned previously, you need additional servers to run Rails app instances separately from the Nginx server. From the user’s perspective, the app stays the same; they simply access different app instances thanks to Nginx.

For communication between the Rails application and Nginx, we use a special interface called Rack, which is an application server. There are many application servers for Rails apps, the best known being Unicorn, Phusion Passenger, and Puma. Application servers are responsible for input-output, letting the Rails application deal with user requests.

Although Rails application are mostly monolithic, we can extract a functional block and use it as a standalone service. This will also lessen the load on servers.

Database instances

Scaling a database is another important aspect of scaling a Rails application. We can deploy a database on the same server as the Rails application to economize, but this economization has several drawbacks. When every application instance saves and retrieves data from its own database instance, then data for the entire application is spread across many machines. This is very inconvenient for website users. If Nginx redirects a user to a different Rails app instance than where their data is stored, they can’t even sign in because their data is located on a different machine!

Another reason to separate a database from other servers is to create a fault-tolerant architecture. If our database receives too many requests and can’t manage them, it collapses. But other database instances in the data tier can accommodate this load, and the Rails app will continue to work.

That’s why, when you are ready to scale your Rails application, your database should be transferred to its own server right away. The database tier can be a single server with a database that’s used by all app instances. Or, this tier can consist of several machines each running databases. In order to update data across all databases, we use database replication. Once a database has new data to share, it informs all others about changes (which is standard procedure for multi-master relationships among databases).

In a master-slave replication variant, databases communicate with the master (or main) database, which stores important data about other databases. All other database instances receive updates only when the master database updates data. Multi-master database replication and master-slave replication are the two common approaches to making our data layer consistent across multiple databases.

When the database receives a large quantity of data, it must save it quickly, update its status quickly, and send new data back to the user. An ordinary relational MySQL database is usually replaced by PostgreSQL or MongoDB databases to accommodate large quantities of data when you scale a Rails app.

In order to further reduce the load on the database, several other techniques can be used. Caching is one important solution, although it’s indirectly related to database scalability. Caching provides cached data from a storehouse to a client more quickly. Imagine that your Rails app compiles statistics about user activity, such as user sessions. This produces a high load on the CPU. We can calculate this information once per day, and then show the cached data to the user at any time.

The other two solutions for reducing the load on a database are Redis and Memcached, which are special databases that perform read/write operations extremely fast.

Other options when scaling any Rails app

Let's say you want to spend as little money as possible on new servers. Is it possible to scale your Rails application while minimizing server costs? Indeed it is.

First, consider code optimization. Let's assume your service offers image editing, which is demanding on the the CPU. Given that your startup has evolved very quickly, it’s almost a given that your image editing algorithm wasn't optimized in its initial form, so there’s a lot of code to refactor and optimize. For example, at RubyGarage we needed to parse a huge CSV file with a user data. It took as much as 74 seconds for the algorithm to parse the file. But when our developer removed unnecessary checks and reused some resources, the algorithm took only 21 seconds to accomplish the same task. Code optimization helps you get more out of existing server resources.

Another option is to re-write computationally intensive tasks in a low-level language, such as C++. Due to low concurrency support – because of the Matz Ruby Interpreter (MRI) – Ruby isn't so great for computation compared to low-level programming languages.

It's also possible to stick with Ruby and Ruby on Rails in your project, but deploy a service-oriented architecture in order to scale your application. Imagine your project uses chat functionality (as one of our client’s apps does). The chat can be loaded with many requests from users, while the other parts of this Rails application are used infrequently. It's unnecessary to break the server structure into three tiers. But it's possible to break the Rails application into two parts!

We deployed the application part responsible for chat functionality on a separate server as a stand-alone application. Chat could then communicate with the original application and database, but the load on the main server was decreased. Further, it will be easier, faster, and less expensive to scale just this small part of your Rails application – either vertically or horizontally – should the load increase once more. The service-oriented architecture is a great solution for scaling Rails application and is used by many companies, including Facebook and Shopify.

Rails application architecture and scalability

We mentioned before that the Rails application architecture can negatively affect scalability. Scalability issues become apparent if a Rails application consists of many services that cannot run separately from other services.

Let's consider an example of a bad Rails application architecture. A Rails application can constantly save its current status when a user enters new data in a form or visits several web pages successively. If the load balancer redirects this user to the next server, this next server won't know anything about this new data. This will prevent us from scaling the Rails app horizontally. The application’s status must be saved either on the client (browser) or on the database.

If we avoid this common architectural mistake, or similar mistakes, when building a Rails application, we will be able to scale it with no trouble.

Tools that help you scale Rails apps

Proper scalability of a Rails application is only possible when you find and eliminate bottlenecks. Finding bottlenecks is a bit difficult to do manually. We can’t figure out scalability issues by just scratching our heads.

A much more effective way to locate problems when scaling Rails applications is to use dedicated software. New Relic, Flame Graphs, Splunk, StatsD, and other software programs are all great options, and they work similarly: each checks and collects statistics about your application. We must then interpret the gathered data to figure out what to change.

We can use Flame Graphs to learn about CPU or RAM loads when running our application. When the Rails app interacts with the database, we can track code paths. Learning what processes take the most time can lead us to our application’s bottleneck(s). When we’ve identified a bottleneck, we can design a solution to remove it.

In conclusion, we would like to repeat what Shopify said several years ago at a conference dedicated to Ruby on Rails scalability: “There isn't any magic formula to scaling a Rails application.”

In this article, we mentioned some problems that might appear when scaling a Rails application, and described several solutions. But Rails applications are unique. Therefore, you must know the characteristics of your particular application in order to overcome your applications specific limitations. It's important to know exactly what part of a Rails application to scale initially as we begin optimizing from crucial issues down to minor bottlenecks.

Originally published https://rubygarage.org/blog/ruby-on-rails-is-scalable

How We Retrieve Tenant Data in a Multi-Tenant App with Detectify

We often build multi-tenant applications for Software as a Service (SaaS) providers. As we know, support for multi-tenancy is imperative for a SaaS application because a single instance of the app must manage data for multiple clients. The difference between a multi-tenant and a single-tenant app chiefly concerns the database tier, or layer. Multi-tenant and single-tenant refers to how client data is stored and accessed in a database.

But this article won’t talk about how to segregate client data in a database schema (or schemas) with Ruby gems, such as Apartment and Multitenancy. Instead, we’ll explain how to work around a different challenge – retrieving specific data depending on the tenant’s domain or subdomain name. We’ll present our own solution for this task, which you can use to build your own multi-tenant SaaS application.

Identifying the Tenant in a Multi-Tenant App

We often see URLs similar to these: tenant-one.webapp.com and tenant-two.webapp.com. For example, Slack allocates the rubygarage.slack.com subdomain for our RubyGarage team, and we must enter our subdomain – rubygarage – to sign in. This approach to building a multi-tenant web application can be called partial white-labeling (i.e. we don’t get our own full domain for Slack).

We commonly retrieve a tenant’s data (an entity) from Active Record using a subdomain name in our SaaS projects.

For example, we’re working on a project called Shopperations, a SaaS application designed for shopper marketers. Shopperations allows multiple tenants (companies) to separately work on their respective marketing projects. When a Shopperations user (a company representative) wants to sign in to the Shopperations application, they have to enter their subdomain.

So what happens when we enter a subdomain name and sign in? Put simply, the application determines who we are using this subdomain name and loads our data.

The responsible code grabs this subdomain and sends a request to the database. Since database schemas are set up correctly, only our data is retrieved and we are redirected to our unique page. It’s as simple as that!

How We Identified Tenants Before

In order to send a subdomain-specific request and receive appropriate data, we’ve typically employed a Ruby gem called Houser. But several months ago we decided to switch to a custom solution for a couple of reasons.

First, Houser can look for data only using subdomain names, whereas we needed to search for data using domain names as well. Second, we wanted to be able to ignore routes when sending a URL-based request to the database, and Houser didn’t let us do this.

Before building Detectify, we had to write our own code on top of Houser to implement these two features we just mentioned. But this implementation required two requests to the database. Since we wanted to be efficient – meaning we wanted to use a single request to retrieve data – and since we needed a more flexible solution, we decided to build Detectify.

What’s Detectify?

Detectify is a simple Ruby gem, similar to Houser, that helps you retrieve an Active Record entity from a database with a URL. The URL can be either a domain name or subdomain name.

It’s easy to install and set up Detectify to meet your specific needs. Below, you’ll find an explanation of what Detectify does and how exactly the gem does it. Keep in mind that Detectify is intended for use with Rack applications.

Detectify: How It Works

To use Detectify, you must first add the following line to your project’s Gemfile:

gem 'detectify'

 

You’ll also need to install Detectify with the standard command:

Install Detectify with the help of Bundler.

$ bundle install

 

Keep in mind that Detectify only supports applications built with Ruby 2.2.2 and Rails 4.2 or higher. There’s no need to install any other gems to run Detectify.

Now, let’s take a look at the short Middleware module that our developer created for Detectify.

	module Detectify
	class Middleware
	def initialize(app)
	@app = app
	end
	def call(env)
	request = Rack::Request.new(env)
	detector = Detector.new(request.url)
	env['Detectify-Entity'] = detector.detect
	@app.call(env)
	end
	end
	end

 

Detectify’s workflow starts in the middleware.rb file. Our middleware receives a new Rack request and initializes the Detector (the main Detectify entity) with the URL returned by that Rack request. Next, Detectify sends a request to the next middleware, where the result of the initial request is actually used.

The detector.rb file is the second stop in Detectify’s workflow. The Detector class receives a URL and builds a request to the database using QueryBuilder.

	require 'uri'
	module Detectify
	class Detector
	attr_reader :request_uri
	def initialize(request_url, query_builder = QueryBuilder::SQL)
	@request_uri = URI(request_url)
	@query_builder = query_builder
	end
	def detect
	@entity ||= Detectify.entity_class.where(*query).first unless ignore?
	end
	private
	def ignore?
	@request_uri.to_s[Regexp.union(*Detectify.config.ignore_urls)]
	end
	def query
	@query_builder.new(domain, subdomain).build
	end
	def domain
	request_uri.host
	end
	def subdomain
	chunks = request_uri.host.split('.')
	chunks[0...(1 - Detectify.config.tld_length - 2)].join
	end
	end
	end

 

For now, we have a single query builder for SQL-type databases. But the query builder implementation allows you to freely add query builders to Detectify for other types of databases.

Let’s also have a look at the QueryBuilder code.

The QueryBuilder module allows us to build a more advanced request to the database than what Active Record normally does. This is why we’ve added such functions as domain_clause and subdomain_clause to this module.

	module Detectify
	module QueryBuilder
	class SQL < Base
	def build
	@query ||= begin
	query = ["#{domain_clause}#{or_operator}#{subdomain_clause}"]
	query << domain if need_domain_clause?
	query << subdomain if need_subdomain_clause?
	query.compact
	end
	end
	private
	def domain_clause
	"LOWER(#{Detectify.config.domain_column}) = ?" if need_domain_clause?
	end
	def subdomain_clause
	"LOWER(#{Detectify.config.subdomain_column}) = ?" if need_subdomain_clause?
	end
	def or_operator
	‘ OR ' if need_domain_clause? && need_subdomain_clause?
	end
	end
	end
	end

 

To finish setting up Detectify in your SaaS app, you’ll also need to specify the Active Record model that will be used for search in configs .

Detectify helps implement multi-tenancy in Software as a Service applications. Our gem is an efficient solution for retrieving tenant data with the Rack request, which is created based on the domain or subdomain name of the tenant.

Admittedly, we could simply add several lines of code to implement Detectify’s functionality in every new Software as a Service project. But we believe it’s best to use a scalable solution that can be easily modified to work with more than just SQL-type databases.

Go ahead and try out Detectify in your own projects, and extend it if necessary. And if you have any suggestions for changes, commit to Detectify on GitHub.

Originally published at rubygarage.org.

How Junior Developers Can Contribute to Open Source Projects

It's never been easy to learn programming. But despite tons of ways to learn how to code, we believe that the best way to improve your skills is by contributing to open source projects.

The open source community provides a great opportunity for aspiring programmers to distinguish themselves; and by contributing to open source projects, developers can improve their skills and get inspiration and support from like-minded people. But most importantly, they can prove that they can build fantastic experiences that people love.

Previously, we have discussed why open source is good for your business. In this article, we'll explain why you should contribute to open source projects, how to contribute, and what projects to choose. This article is geared towards developers who are just starting their career and would like to get involved with the open source community (and maybe become a coding genius).

Why contribute to open source projects?

There are a number of reasons to contribute to open source projects. Let's see what motivates developers to contribute.

First, there are a lot of enthusiasts who simply believe that code should be open. They're idealists who want to make the world a better place, and it drives them to contribute code. The desire to share can be a powerful motivator.

Second, open source projects give you a great start. Beginners might start by fixing minor things, such as a bug in a library, sending a pull request, or even writing a piece of documentation. However, beginner developers can also learn to write so-called "clean code" – code that is readable and maintainable – while contributing to open source projects. When developers realize that their code is exposed to the world, it makes them focus on making that code easy to understand and support. Programmers stick to generally accepted rules within a team, which include norms for indents, descriptions of methods and classes, variable names, and following the don't-repeat-yourself rule. In a nutshell, when contributing to open source projects you're obliged to conform to the norms of a project.

Third, you get the chance to be part of an active open source community where you can meet like-minded people and supporters. Moreover, if you're a freelancer and actively contribute to open source projects, you increase your chances of being noticed by potential employers.

The main reasons why developers go open source are to be recognized, to sharpen their programming skills, and to become part of the vibrant open source community. Now let's look at what you should consider before you start contributing.

What to consider before you go open source

Okay, so you can't wait to start your first open source project. Let's go through a few tips that might help you choose what to work on.

Programming language

The most fundamental technology behind any application is a programming language. The most popular languages on GitHub (a collaborative code hosting platform) are JavaScript, Python, Java, Ruby, and PHP. There are a multitude of projects that might suit your skills and taste.

Type of project

After you've chosen the language you want to work in, you need to choose the type of project you prefer. Github projects are categorized into folders called Showcases. Here are some examples of Showcases: "security", "virtual reality", "text editors", and "CSS preprocessors." Just choose a topic that interests you.

However, we do recommend paying extra attention to those projects that would be used by broad spectrum of people so you'll have the chance to test your code on a large real-world audience. For example, the "Emoji" Showcase contains 25 repositories that represent its popularity. Another tip on how to choose an open source project is to start working on software you already use or software you're interested in using. This will keep you motivated to keep on working.

Project volume

Large software projects like VLC Media Player or Spree – with thousands lines of code – aren't the best choice for a beginner. When you contribute to open source projects of this scale, you're expected to meet the established requirements within that team. A here's another small tip: pay attention to issue labels. Some issues are labeled as "first-timers-only", "beginner", "easy", and so on. You can also find a list on Github with collections of projects that suit newcomers.

Consider these tips when choosing a project to contribute to. And always remember to choose software you're interested in and allocate time in advance.

How to contribute to open source projects

When we speak about open source, we can't avoid talking about GitHub and related tools. Let's see what GitHub is and how it helps you to participate in open source projects.

Get to know Github

Github is the most popular platform for open source collaboration, so you'll probably use it when exploring the open source world. First, you need to create a GitHub account and read the guide that helps you get started. On GitHub, you can contribute to projects by submitting issues and contributing code. Submitting issues means sending messages about errors in applications and suggesting ways to fix them. Contributing code involves sending pull requests with your corrections and improvements.

Learn the basics

When working with GitHub, you should know how to use Git – one of the most popular version control tools (also known as revision control tools). Because developers constantly make changes to their code, they need a system that can manage those changes in a central repository. In this way, everyone involved in the development process can download a given piece of software, make changes, and submit updates.

Besides being comfortable with revision control tools, essentials skills include being able to clone a repository and send pull requests. Pull requests inform code maintainers about changes made to the code; they can then review these changes, start a discussion about them, or assign them to a further commit.

Join the community

You can easily join an open source project by subscribing to the mailing list for that project. You can find mailing lists on official websites or on Github pages. After being accepted to the list, you can communicate with team members and get support if necessary. Thanks to the vibrant communities present in nearly every open source project, you are likely to get quick replies to your questions.

All skills are welcomed

Even non-programmers can contribute to open source projects! Documentation is needed for all projects, and sometimes this is poorly written and maintained. Thus, you can help by writing, updating or even translating documentation. Also, your design skills might come in handy: every application needs an interface, after all. Finally, you can contribute by managing a community by replying to questions and guiding newcomers.

Ways to contribute to open source projects

Let's highlight the most common ways to contribute to open source projects.

1. Create your own open source project

Every project should start with an identified need. If you feel that existing projects on GitHub or Bitbucket don't offer the functionality you would like to build, then create your own open source solution. Besides an initial project draft, you should consider the following set of questions:

1. What skills do you need for your project?
2. How much time are you willing to spend on your project?
3. What problem(s) does your software solve?
4. How many potential users are there for your product?

2. Create open source alternatives to commercial software

Today's commercial projects actively engage open source solutions. Many companies base their projects on open source tools. When there's a huge selection of software, you don't need to reinvent the wheel. This is why it's useful to play around with open source software that can replace similar proprietary software, or that fixes an issue you've recently faced.

Another reason for replacing commercial solutions with open source software is eagerness for real innovation and growth. Commercial software claims to be innovative, but its final goal is turning a profit. Open source software unites best practices, great quality of code and passionate developers willing to code just because they like to.

3. Contribute to existing open source projects

You can find many projects you are free to participate in on Github – a developer-oriented platform with a simple but essential set of functionality. GitHub attracts developers with public APIs, a sleek and frequently updated UI, gists (Git repositories) that allow you to share pieces of code or even whole applications, and much more. You can contribute to open source in many ways. Developers can fork projects, make changes to code, and send pull requests. And quality assurance is always appreciated. Sometimes developers are too busy or too lazy to check the quality of their code. So go ahead and report a bug or try to fix it – your help is appreciated.

You can reach the hottest GitHub projects by following the "Trending" link. And in order to make your search more relevant, use advanced search: select the language you would like to code in and choose "best match" criteria. Best match ranks projects according to relevance, taking into account the number of forks (which represents how actively the project is updated) and stars ("likes", in the language of Facebook). Most projects have known issues (however, some don't) with labels like "bug", "discussion", "security", or "refactor", or other labels according to the level of difficulty: "easy", "medium", "hard."

Conclusion

Open source projects bring many benefits to those who participate in them, and such experience is great for your CV. By joining a community of like-minded people and polishing up your skills, you can give yourself a step up as an aspiring developer. We've listed common reasons why people contribute to open source projects, and described various ways to get started. If you would like to read more about contributing to open source projects, check out our previous articles about how open source projects penetrate the IT market and about the security of open source software.

Readmore at rubygarage.org.