However, a common gotcha that impacts all Rails developers is the differences between the standard Ruby library and Rails provided behaviors such as ActiveSupport. This can derail (pun intended) this use case. However, there’s an easy work around to that! Simply require ActiveSupport.

require 'active_support/all'

# Can also selectively load only the parts of ActiveSupport you need.
# For example string extensions:
require 'active_support/core_ext/string'

If you’d like to make this behavior optional you could always define it in a method and call it when you need it.

On Demand ActiveSupport Example

def load_active_support
  require 'active_support/all'
end

load_active_support

On Demand ActiveModel Example

This could extend to other Rails provided as well.

def load_active_model
  require 'active_model'

  # Most parts of rails provide `eager_load!` method to load eager loaded classes.
  # May or may not be  necessary depending on your use case.
  ActiveModel.eager_load!
end

load_active_model

The “.irbrc” file

To make these methods always available create a .irbrc file in your home directory (for example run touch ~/.irbrc) and include the examples above. Your irb session will now have these methods available automatically!

Benchmark

As you can see Set#include? is quite fast. The reason is Set maintains a hash object representing the Set. It checks against it for inclusion, making the operation constant.

irb(main):014:0> Set.new([1,2,3,4]).instance_variable_get('@hash')
=> {1=>true, 2=>true, 3=>true, 4=>true}

While I’m primarily interested in understanding the practice of Data Science, some of the tools I saw showed promise for delivering value quickly/reducing the effort required by some of the more menial tasks related to large data sets.

Azure ML Studio

The first thing you’ll notice once you’ve setup an account with Azure ML Studio is that it has a somewhat daunting GUI interface with many options depending on what you are trying to accomplish (much like it’s other Azure counterparts). Fortunately Microsoft saw fit to equip it with a robust tutorial and many example projects.

Its most useful feature provides a GUI tool to construct a flow chart of models and data transformations (called an experiment) to solve various problems and build a practical machine learning solution. You are also able to drop down into Python or R to solve various tasks if you so choose. Additionally, it has support for notebooks if that is your preference. What I wanted to focus on in this post was the ability to setup a web service based on a model built in ML Studio.

Through the interface you can setup a web service that exposes your model via a http endpoint accepting a JSON payload. Below is an example of an API call to the above model using ruby and the HTTParty gem!

Ruby API Call Example

That’s all you need to make a valid API call. Additionally there is an API for batch calls. Still learning the ropes of the platform but so far it seems to ease the delivery of useful Data Science. There are quite a few things I’d desire before using this concept in a production environment, but for quick experimentation it’s hard to beat!

After all, who looks at them these days? Most everyone who writes content regularly seems to be using services like Medium, and if your audience is friends and co-workers, why not just write content on a platform they’re familiar with such as Facebook, Twitter, etc. I think the mistake in this thought process is approaching the task as creating content for others; the chief audience should be yourself.

Well why should I be the audience?

I currently work at CoverMyMeds as a Rails Developer. In my day to day, I cover a wide spectrum of languages, frameworks, and concepts. I write front end React components, Rails/web app constructs (Controllers, models, and views), some SQL now and then, and even some meta programming from time to time. With so many different concepts, rarely do I get time to hone the basic tools that the web is built on.

When working on a personal project as straight forward as a static web site, all the usual things that take precedence disappear. Is this or that bit of code performant? Am I making the right abstractions? How do I solve this weird edge case that might break X for user Y on browser Z, 3 years from now? In the context of a simple static web site, you get the freedom to focus on your own needs.

When I first wrote my website, it was inspired by a bad interview. I rambled on and on trying to explain why I was qualified for a position centered on front end web development. The important detail being I had never written a single line of Javascript, and at best 50 lines of CSS. Unsurprisingly, I went home without a job.

From that experience I started a simple site hosted on Github pages. I was able to learn the basics of Javascript, making some JQuery soup, and construct a passable site. Eventually these skills helped me in my first development role (luckily for me a way better deal than the interview I messed up), my senior capstone project at Ohio State, and finally in my current position at CoverMyMeds.

In this latest iteration, I’ve gotten to learn about Jekyll, mess around with Gem development (Jekyll theme), play with some SCSS (vs. the older SASS standard I have used in the past), and mess around with Heroku configuration because Github Pages do not support custom Jekyll themes and I needed a new host :(.

Okay, I get the idea. Why does this only apply to personal sites?

Well, it doesn’t. Any personal project is a great way to learn and become familiar with new ideas. A personal site is just my favorite kind! If you are a web developer, having a small space on the web somewhere to call your own is a great way to establish an identity. It can be a simple static page with some contact info, a blog like the one I have now, or even a full blown web app. At the end of the day, hopefully you’ll have practiced some old skills, learned something new, and most importantly had some fun!

And if you did a good job, others might enjoy it too!