DEV Community: PostCo

Solve node-gyp build error due to PYTHONPATH

Andy Chong — Fri, 07 Feb 2020 09:54:25 +0000

Update

From node-gyp@5.1.0 onwards, python3 will be used for the build, therefore please follow the steps below, but replace the last step with

PYTHONPATH=python3 && npm i

Recently, I faced the problem where node-gyp rebuild failed due to PYTHONPATH is pointing to python3. This is due to python2 is being deprecated, and python now points to python3 by default. While node-gyp requires python2 to build.

To solve this on macOS, just make sure you reinstall python 2 and python 3 and point PYTHONPATH environment variable to python2.

# Only do this if `where python2` output nothing
brew uninstall --ignore-dependencies python2 python3
brew install python2 python3 


PYTHONPATH=python2 && npm i

DONE!

References

https://github.com/nodejs/node-gyp/issues/1643#issuecomment-456011575

[TIL] Debugging external gem in Ruby

YC Yap — Tue, 04 Feb 2020 09:12:31 +0000

Sometimes there comes a time where an external gem that you installed is not behaving as expected. It was not until a week ago that i learned from my colleague that you can actually open the gems to inspect the code inside the gem and debugging it using a debugger.

Firstly, you can open the gem by running.

bundle open countries

Identify the part of the code which you wish to debug. For example i would like to understand why a method in the gem 'countries' is not returning values as expected.

Start inserting calls to debugger in places you expect it to call.

require 'byebug'

module ISO3166
  class Country
    def initialize(country_data)
      byebug
      @country_data_or_code = country_data
      reload
    end
  end
end

Using debugger allows you to better understand the code execution, so that variables which are causing the unexpected behaviours during the execution call be be inspected.

My Transition From Mechanical to Software Engineering

MarcusZ — Tue, 31 Dec 2019 02:55:27 +0000

Introduction

This post is dedicated to PostCo, a company that believes in me and offer me a full-time position as a software developer. In this blog post, I will briefly share my experiences on three different phases starting from the pre-interview preparation, the actual interview and finally on the working experience after I accepted the offer.

Pre-interview Preparation

Before I move on, allow me to briefly introduce myself. My name is Marcus, a fresh graduate mechanical engineering student from the University of Malaya. My career interest has shifted towards software engineering since my third year of mechanical study. From then on, I started teaching myself how to code through many of the online resources. Other than taking online courses, I had also gone through a 3 months internship as a software developer intern at a local startup. After the internship, I am convinced that software engineering is what I want to do as a career. Immediately after my graduation, I started firing out my resume applying for junior developer positions at many different companies while studying the book - Cracking the Coding Interview.

Actual Interview

I do not have high hope of receiving any replies from any of the companies simply for the reason that I am not a computer science student. However, the result turned out to be pretty good. Six out of the many companies I had applied to, offered me the opportunities to interview and I attended 4 of them. PostCo is the third interview that I went to and I am very happy to share my interview experience with PostCo here.

The interview was divided into 2 rounds, the first round was the CEO round and followed by the technical interview. During the CEO round, I was asked questions like how would I use technology to help solve PostCo's business problems. I did okay for the first round, not very good but not that bad.

After the CEO round, two developers from PostCo walked into the meeting room preparing for the technical interview. I was excited and nervous at the same time because that was my first interview with developers. In my previous two interviews, those sessions were conducted by HR with some paper and online coding tests. Just as they were walking in the room, in my mind, I started imagining that they would ask me to code on the whiteboard solving some difficult algorithms and data structures problems. Turned out I was wrong again, they were more interested in the reasons why I decided to switch from mechanical to software engineering. Our conversation went pretty well, I managed to explain myself and at the same time learn more about the tech stack PostCo is using and also the day to day job as a software developer there. After that, I had a pair programming session with one of the developers solving the common coding interview question - converting snake_case to camelCase. And that's all for the technical interview. At the end of the session, I was told that the result will be out in two weeks' time.

Accepting the offer

While waiting for the reply from PostCo, I did not think that I hold a chance to receive an offer from them for two main reasons. The first reason is that PostCo is a startup, and usually, a startup will want to hire someone who can hit the ground running. The second reason is that the main tech stack at PostCo is Ruby on Rails which is something that I have never done before. I was expecting a No from them and started looking out for other opportunities.

However, I was very glad that my expectation was wrong again this time. I received a call from one of the developers just one week after my interview and he told me that PostCo is offering me a two months software associate program with the opportunity to turn full-time depending on my performance. With PostCo's offer, I have a total of 3 Yes out of the 4 interviews that I had attended. After careful consideration, I have decided to go with PostCo because I like the mission, colleagues, and environment at PostCo.

This month is my fourth month working as a software developer at PostCo, which means that I passed my "probation" and I am now a full-timer. To keep this short and sweet, I will not go into details on my day to day job but just listing down what new tech stacks I have learned so far and also what I like the most working at PostCo.

New Tech Stack:
- Ruby on Rails
- React
What I like the most working at PostCo:
- My opinions are heard even though I am a fresh graduate.
- I was given the trust to develop new features for the product.
- Help and guides are always there whenever I needed them.
- Colleagues who are eager to learn.

Last But Not Least

It was a very hard decision for me when I decided to switch from mechanical to software engineering. Until now, I am not sure if it was a good decision but I have no regret at all. I followed my heart, and now I am enjoying my job working as a software developer. To be honest, it was not an easy journey, I have so many new things to learn every day at work and sometimes I felt like I know nothing. I think they call it imposter syndrome. But, there is no free lunch in this world, you have to work hard for what you want to achieve. I know that my journey ahead will be filled by a lot of new challenges and new things to learn but yeah, let's bring it on! If I were to give one piece of advice to anyone out there thinking of switching into software development, I will say:

Never stop learning and have more confidence in yourself. No one knows you better than yourself.

Thanks PostCo again for this amazing opportunity!

Running a book club in PostCo

YC Yap — Mon, 30 Dec 2019 06:34:52 +0000

This article will be about our learnings running a tech book club in PostCo for the past 3 months.

Our motivation
We want to try to cultivate a strong learning culture in PostCo, book clubs are a fast way to encourage cross learning and healthy discussion among team members. We decided to start with a book that is simple enough and is on everybody’s reading list, Pragmatic Programmer by Dave Thomas and Andy Hunt.

Running the book club

Setup a recurring calendar invite
A Github wiki to keep track of the discussions.
Inform ahead to the participants which chapter will be in discussion.
We encourage everyone to go through the chapters, so that everyone is in line with the topics that will be discussed in the book club sessions. This allows conversation and discussion to flow more smoothly.

Learnings:

We would encourage active participation by encouraging questions in the middle of the session.
Create a page, in which participants can propose new books for the book club.
One person leading the talk normally does not work, participants will rely too much on the lead to delivery book’s content rather than reading the content themselves.
Active participation, where participants should bring up topics they found interesting in the chapter.
Generate follow-up discussion in Slack channel participants can post interesting blogs, videos, papars that related to the day.

Some of the books which are currently in our list.

Seven Databases in Seven weeks
99 Bottles by Sandi Metz
Structure and Interpretation of Computer Programs
Design patterns in Ruby

Conclusion
Book clubs are a great way to level up your team, and encourage healthy discussion between members.

Ruby on Rails Graphiti file attachment/file upload

Andy Chong — Sun, 29 Dec 2019 15:09:25 +0000

I have been using Graphiti gem to build the API for the upcoming product in PostCo. While it is great that it makes building JSON:API compliant API endpoints a breeze, and made API resource the first-class citizen, it still quite lacks some important features, which includes file attachment support. I will talk about Graphiti in some other time but right now lets dive into today's topic.

In this article, you will understand how to add the file attachment functionality into the Graphiti resource. I will cover 2 of the most popular file attachment libraries recently, Active Storage and Shrine, and I will be uploading the file in Base64 string format.

Assuming the User model file looks something like this, where it contains 2 attachments, an avatar photo, and an ID card photo.

class User < ApplicationRecord
  # some other codes
  User::ATTACHMENT_ATTRS = [:avatar, :id_card].freeze

  ## Active Storage
  User::ATTACHMENT_ATTRS.each do |attachment_attr|  
    has_one_attached :"#{attachment_attr}"
  end
  # or
  # has_one_attached :avatar
  # has_one_attached :id_card

  ## Shrine
  include ImageUploader::Attachment(:avatar)
  include ImageUploader::Attachment(:id_card)

  # some more codes
end


## Shrine
class ImageUploader < Shrine
  plugin :data_uri
end

Write

During POST and PUT API call, the Graphiti Resource will assign all the submitted attributes and save it. But both file attachment libraries do not support attaching files by assigning the attribute.

Therefore, we need to extract the attachment data out from the submitted attributes and attach them separately. Luckily, Graphiti exposes the persistence lifecycle hooks to allow developers to add in additional logic during persisting the data.

To achieve the goal, we overwrite the assign_attributes to do exactly what we need to, extract the attachment data and assign them separately!

class UserResource < ApplicationResource

  # some other codes...

  def assign_attributes(model_instance, attributes)
    attachments = extract_attributes(attributes)
    attach_data(model_instance, attachments)

    attributes.each_pair { |key, value| model_instance.send(:"#{key}=", value) }
  end

  private

  def attach_data(model_instance, attachments)
    attachments.each do |attribute, data|
      ## Active Storage
      model_instance.send(:"#{attribute}").attach(data: data)

      ## Shrine
      model_instance.send(:"#{attribute}_data_uri=", data)
    end
  end

  def extract_attachments(attrs)
    attachments = {}
    User::ATTACHMENT_ATTRS.each do |attachment_attr|
      attachment = attrs.delete(attachment_attr)
      attachments[attachment_attr] = attachment if attachment.present?
    end
    attachments
  end

  # some more codes

end

Read

To return the attachment's URL when reading, we simply check each attachment and return the URL if it is available.

class UserResource < ApplicationResource

  User::ATTACHMENT_ATTRS.each do |attachment_attr|
    attribute attachment_attr, :string do
      ## Active Storage
      attachment = @object.send(:"#{attachment_attr}")
      attachment.attached? ? rails_blob_path(attachment, only_path: true) : ''

      ## Shrine
      @object.send(:"#{attachment_attr}_url") || ''
    end
  end
  # other attributes...
  attribute :created_at, :datetime, writable: false
  attribute :updated_at, :datetime, writable: false

  # some other codes...

end

Here's what the final Resource code will look like:

class UserResource < ApplicationResource

  User::ATTACHMENT_ATTRS.each do |attachment_attr|
    attribute attachment_attr, :string do
      ## Active Storage
      attachment = @object.send(:"#{attachment_attr}")
      attachment.attached? ? rails_blob_path(attachment, only_path: true) : ''

      ## Shrine
      @object.send(:"#{attachment_attr}_url") || ''
    end
  end
  # other attributes...
  attribute :created_at, :datetime, writable: false
  attribute :updated_at, :datetime, writable: false

  def assign_attributes(model_instance, attributes)
    attachments = extract_attributes(attributes)
    attach_data(model_instance, attachments)

    attributes.each_pair { |key, value| model_instance.send(:"#{key}=", value) }
  end

  private

  def attach_data(model_instance, attachments)
    attachments.each do |attribute, data|
      ## Active Storage
      model_instance.send(:"#{attribute}").attach(data: data)

      ## Shrine
      model_instance.send(:"#{attribute}_data_uri=", data)
    end
  end

  def extract_attachments(attrs)
    attachments = {}
    User::ATTACHMENT_ATTRS.each do |attachment_attr|
      attachment = attrs.delete(attachment_attr)
      attachments[attachment_attr] = attachment if attachment.present?
    end
    attachments
  end
end

And Voilà! Now you can upload attachments through the Graphiti API!

If you find this article is useful, please do give a ❤️! If you have any questions or suggestions, please do comment in the discussion area below!