For the past year, at A line, we had to build an ambitious project management and marketplace platform MVP from scratch. The frontend is built in TypeScript/React/Apollo (Charly Poly).

For the backend, Charly and I had three goals :

• Implementing DDD in Rails
• Implementing a GraphQL API with WebSocket subscriptions
• Having a well-tested, maintainable, and scalable codebase

FYI, today it’s all up and running in production on A Line, the Startup I work on.

The gems

Basic rails/puma/pg/sidekiq/redis. For authentication we choose to use a very pleasant API called Auth0, that provide JWT authentication. For search we use Algolia. Of course, for graphql, the graphql-ruby gem.

The core Architecture

Let’s get an example with the model Portfolio. I’ll not go into subscriptions, but it works great with ActionCable (next article ?).

app/
app/admin/                      # ActiveAdmin
app/models/                     # The models (User/Portfolio ....)
app/controllers/                # Only for the GraphQL controller
app/graphql/                    # The GraphQL code

app/graphql/aline_api_schema.rb   # Main graphql schema
app/graphql/mutation_type.rb      # Defines all mutations
app/graphql/query_type.rb         # Defines all queries
app/graphql/subscriptions_type.rb # Defines the subscriptions

app/graphql/resource_base_service.rb
# Base service object that exposes the index/show/create/update/destroy basic methods that will be called by the mutations

app/graphql/portfolios/                     # Portfolio domain
app/graphql/portfolios/type.rb              # Portfolio GraphQL type
app/graphql/portfolios/mutations/
app/graphql/portfolios/mutations/create.rb  # Create mutation
app/graphql/portfolios/mutations/update.rb  # Update mutation
app/graphql/portfolios/mutations/accept.rb  # Accept mutation
app/graphql/portfolios/mutations/input_type.rb  # Portfolio input

app/graphql/portfolios/service.rb
# Service Object that may surcharge the index/show/create... methods inherited by resource_base_service methods called by the mutations, and add the accept method.

The code

The controller

The GraphQL controller is pretty simple, just calling the graphql schema.

app/controllers/graphql_controller.rb

class GraphqlController < ApplicationController

  before_action :authenticate_user

  # GraphQL endpoint
  def execute
    result = AlineApiSchema.execute(
      params[:query],
      variables: ensure_hash(params[:variables]),
      context: { current_user: current_user },
      operation_name: params[:operationName]
    )
    render json: result
  end

  private

  def ensure_hash(ambiguous_param)
    case ambiguous_param
    when String
      ambiguous_param.present? ? ensure_hash(JSON.parse(ambiguous_param)) : {}
    when Hash, ActionController::Parameters
      ambiguous_param
    when nil
      {}
    else
      raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
    end
  end

end

The Service Object part

the ResourceBaseService (simplified) looks like that :

app/graphql/resource_base_service.rb

class ResourceBaseService

  attr_accessor :params, :object, :user

  def initialize(params: {}, object: nil, object_id: nil, user: nil)
    @params = params.to_h.symbolize_keys
    @object = object || model.find_by(id: object_id)
    @user = user
  end

  def self.graphql_call(resource, method)
    lambda { |_obj, args, ctx|
      params = args.try(:[], resource.to_sym) || args
      service = "{resource.to_s.pluralize.camelize}::Service"
      service.constantize.new(
        params: params,
        user: ctx[:current_user],
        object_id: args[:id]
      ).send(method)
    }
  end

  def index
    # Example of a index if ApplicationRecord defines the
    # self.seeable_by method
    model.seeable_by(user: user)
  end

  def show
    # Example of a show if ApplicationRecord defines the
    # self.seeable_by method
    return not_allowed unless model.seeable_by(user: user).include?(object)
    object
  end

  def create
    # Creates the record regarding params and authorizations
    model.create!(params)
  end

  def destroy
    # Destroys the record regarding authorizations
    object.destroy!
  end

  def update
    # Updates the record regarding params and authorizations
    object.update_attributes!(params)
  end

  private
  
  def singular_resource
    resource_name.singularize
  end

  def model
    singular_resource.camelize.constantize
  end

  def resource_name
   self.class.to_s.split(':').first.underscore
  end

end

Then you have the Portfolios Service

app/graphql/portfolios/service.rb

module Portfolios
  class Service < ResourceBaseService

    # Custom Mutation
    def accept
      return unless model.writable_by(user: user).include?(object)
      object.tap(&:accept!)
    end

    # Add action after create
    def create
      super
      # add fancy stuff
    end

    # Rewritten index
    def index
      model.where(visible: true).seeable_by(user: user)
    end

  end
end

The GraphQL part

The Portfolio Type

app/graphql/portfolios/type.rb

Portfolios::Type = GraphQL::ObjectType.define do
  name 'Portfolio'

  field :id, types.ID # types.String for uuid mapping
  field :visible, types.Bool
  field :user_id, types.ID
  field :created_at, types.String
  field :updated_at, types.String
end

And the mutations, first the input type, you can have many :

app/graphql/portfolios/mutations/input_type.rb

Portfolios::Mutations::InputType = GraphQL::InputObjectType.define do

  name 'Portfolio input type'

  argument :visible, types.Bool
  argument :user_id, types.ID

end

and for example the update mutation :

app/graphql/portfolios/mutations/update.rb

Portfolios::Mutations::Update = GraphQL::Field.define do

  description 'Updates a Portfolio'

  type Portfolios::Type
  argument :id, !types.ID
  argument :portfolio, Portfolios::Mutations::InputType # The input type defined earlier
  resolve ResourceBaseService.graphql_call(:portfolio, :update)
end

Then simply add them to the mutations_type :

app/graphql/mutation_type.rb

MutationType = GraphQL::ObjectType.define do

  name 'Mutation'

  field :update_portfolio, Portfolios::Mutations::Update
  # ...
end

And add the queries to the query_type :

app/graphql/query_type.rb

QueryType = GraphQL::ObjectType.define do

  field :portfolio do
    type !Portfolios::Type
    description 'Return a Portfolio'
    argument :id, !types.ID
    resolve ResourceBaseService.graphql_call(:portfolios, :show)
  end

  field :portfolios do
    type !types[!Portfolios::Type]
    description 'Return the Portfolios'
    resolve ResourceBaseService.graphql_call(:portfolios, :index)
  end

  # ... Metaprog could be your friend here.

end

finally the graphql schema

app/graphql/aline_api_schema.rb

AlineApiSchema = GraphQL::Schema.define do
  mutation(MutationType)
  query(QueryType)
  use GraphQL::Subscriptions::ActionCableSubscriptions
  subscription(SubscriptionType)
end

OMG, that’s it, you have your graphql API. So fu**ing good.

Conclusion

The Service Objects part is maybe not the best thing for all projects, but here it works pretty well.

You can unit test all your services methods, and for me that’s the only real things to test.

For N+1 queries, I suggest you to tweak your index methods with model.includes() regarding the context ast nodes, or take a look tographql-batch, another wonderful gem made by Shopify ❤.

The performances are quite good for the moment. GraphQL is a wonderful tool to build APIs, and in ruby it’s pretty pleasant right now :)

Hope it helps, don’t hesitate to reach me for more details. By the way, if you are a talented freelance and look for quality projects, take a look at A line.

today I wanted to look back at a project I had to do as a student, and I struggled a LOT at the time, and found the project very boring.

Basically, I had to develop ls, with the -l -r -R and -a options, and with only malloc, free, write, stat, ctime, time, getpwuid, getgrgid, readdir, opendir and closedir.

As always, I wanted to challenge myself again to rewrite some C. At first, I told myself that it would be an easy 2 hours project as an old C developer, but holy ***, it didn’t. It took me around 5 hours to write a code I’m not proud of, with the not-allowed use of sprintf that saved me time. It still need a lot of testing, memory leak finding, and refactoring (it always need :) ).

Poilon/c_ls

But yeah, it’s a great basic project. I would suggest anyone that want to learn C development, to learn basic algorithmic and memory handling to try this one.

There is 3things at least you will learn.

1. Handling memory

Rewriting code in a language without garbage collector can be a pain in the ass. It’s hard to keep track of ALL allocated memory to free it after. But after a while, it’s really pleasant to do so. You can really go in fond of performance, and allocate just the minimum memory to your needs for the best algorithm.

GDB is a wonderful tool that will help anyone debugging C code, but it’s slow to debug C in general, so the best way to have a C program working is to really think a lot before coding.

2. Data structures

In C, with just the basic functions given, you don’t have great strings/arrays/hashes/linked-list functions. It’s wild.

I started to do all my data structuration with simple string parsing, and then sorting was a pain, so I worked on a linked-list data structure. Pretty straightforward, but add-delete-sort are basic but great to start algorithmics. It’s good to understand what is behind a sort in Ruby for example. You have a better idea of what is performance and what are the different sort you could use.

You will need to parse strings, transform a string to a integer, transform an integer to a binary strings etc. A lot of manipulation that leads to a LOT of bugs, that will reduce over time of refactoring.

It’s important to have a big picture in C development, and not rush to the result, because you will not have any result but “Game over, your code has segfault, try again”

This part is really important for the -R (recursive) option, as if you just print as you see, it’ll be impossible to apply the algorithm to the folder inside the folders :)

3. What is ls, and what are access rights in Unix

Everyone one that had use an unix terminal in their lives know what ls is, and what it’s used for. But ls has many many options to format data and use it for your scripts.

for example, the most known ls -l will give you a string that look like

total 40
-rw-r — r — 1 poilon staff 41 22 jul 13:55 Makefile
-rwxr-xr-x 1 poilon staff 14248 22 jul 13:58 c_ls

and while coding it, you’ll have a better idea of how it works. The read-write-execute rights, the number of links, the owners: user and group etc.

It’ll for sure be useful for the people that just had a bootcamp in development and don’t use a unix-based system every day.

This project gave me a real satisfaction when I had a ls -alRr working. I took it as a speedrun of a game, and I had the ls -alRr working in 5h and 12m. Now I’m really tired !

That was really entertaining and pleasant to redo some C, and I’m sure it made me a better developer anyway !

Hope you liked the read, tell me what you think and if you want me to do maybe a streamed/youtube version of this kind of challenge, or any other format.

Speedrunning code, the 3 things I re-learnt while recoding a basic ls in C was originally published in HackerNoon.com on Medium, where people are continuing the conversation by highlighting and responding to this story.

I’m a former C developer(for 5 years), that fell in love with Ruby and it’s ecosystem 4 years ago. After few months of practicing Ruby, I had quit my old job to become a full-time RoR developer in a great company, doing a lot of website crawling and working on a big rails application.

After 2 years in that company, I started to do a lot of recruitment, mainly sourcing and tech interviews.

It’s at that point in life that I discovered CodeWars (https://www.codewars.com), and used it a lot to do my tech interviews. I trained myself often on the website, and resolved a lot of Katas.

With my colleagues, we wanted to challenge ourselves and the point was to earn the most CodeWars points in the weekend. With two kids it’s pretty hard to find focus-time, but my nights got shorter for a time !

After resolving ones of the most hard ruby katas with “normal” solutions (Brainfuck interpreter: https://www.codewars.com/kata/my-smallest-code-interpreter-aka-brainf-star-star-k, the builder of things: https://www.codewars.com/kata/the-builder-of-things and so much more…), and as a competitor in games (Super Smash Bros. Melee mainly), I had to find a way to destroy my friends at our little game :-)

The third weekend, something hit me. I was trying to understand how the katas are checked for validity and yes, I had found a way to resolve almost any kata with a same and really simple solution.

A Kata is checked this way: Does my solution is equal to theirs, or do theirs solution is equal to mine.

At first I tried to resolve it by returning nil in my method, and surcharge the == operator from NilClass this way

class NilClass

  def ==(_)
    true
  end

end

def mymethod
end

and I hit submit, and “pfiout”, I had resolved the Kata. I told myself “Oh shit, is that cheating ? Oh I don’t really care, that’s a solution, my friends will be blown !”

I then tried to make it on the biggest Kata of the website, a 1 kyu. The Three way compiler. As before I tried using a surcharge the == method on the Array or Hash classes, and again “pfiout”, I won points.

At this point, done for done, I told myself to just rekt my colleagues. I made this https://github.com/Poilon/codewars-hack, that will win codewars points for me.

I had a lot of fun finding, and then doing this. Made it to top 300 of the CodeWars power-ranking doing nothing. I did beat my friend, and successfully won our contest ! Of course I would love to have my account back, even with 0 points, just to answer comments and see the new solutions on the Kata I submitted myself.

Of course this is cheating, but if someone had done this during code interviews, I think he would have a really good chance of being hired !

Ruby is love, ruby is jazz. ❤ Paris.rb !

Hacker Noon is how hackers start their afternoons. We’re a part of the @AMIfamily. We are now accepting submissions and happy to discuss advertising & sponsorship opportunities.

To learn more, read our about page, like/message us on Facebook, or simply, tweet/DM @HackerNoon.

If you enjoyed this story, we recommend reading our latest tech stories and trending tech stories. Until next time, don’t take the realities of the world for granted!

How I got banned from CodeWars was originally published in HackerNoon.com on Medium, where people are continuing the conversation by highlighting and responding to this story.