*Continue reading %Comparing Rails: Exploring WebSockets in Phoenix%*

In spring of 2013, Sam Saffron committed fast_blank to GitHub. It was a C extension that provided a fast drop-in alternative to ActiveSupport's `String#blank?`

method which returns whether a string is nothing but whitespace.

At Full Stack Fest 2015, Yehuda Katz presented a talk where he described his investigation into rewriting `fast_blank`

in Rust. His initial goal was to try a naive one-liner (excluding his implementation of `Buf`

) and see how much slower it was than the original C extension.

```
extern "C" fn fast_blank(buf: Buf) -> bool {
buf.as_slice().chars().all(|c| c.is_whitespace())
}
```

To his surprise, it was faster.

*Continue reading %Ruby Can Be Faster with a Bit of Rust%*

*Continue reading %Phoenix for Railsies: Form Helpers and Models%*

Secondly, Elixir is an interesting language because it manages to combine functional programming, OOP, and a Lisp-like conception of metaprogramming (Elixir's macros are pretty insanely powerful). Finally, Rails definitely feels a bit behind-the-curve when it comes to things like WebSockets. Phoenix comes with these right of the box. Best of all, you get most of these benefits without having to leave the niceties of Rails behind. Granted, there aren't as many packages for Phoenix as there are for Rails but the framework itself is fairly feature-complete. Let's take a look at the basics of Phoenix.

*Continue reading %Phoenix for Railsies%*

There are a lot of things I like about MATLAB. Anything to do with matrices (a simple example: creating a matrix with a bunch of zeros is just `zeros(n, n)`

) is really easy, the documentation is generally pretty good, and it's quick to get started with the language. The feature set is awesome and, especially if you're doing something in computer vision, seeing the results of standard algorithms quickly is incredibly useful.

There are also a lot of things I strongly dislike about MATLAB. In general, it feels as if MATLAB is continually trying to stop you from writing clean, readable code. Building abstractions is unnecessarily difficult and the concept of reusable libraries seems foreign to a lot of the MATLAB community. There's no direct access to threading or any sane, generalizable concurrency framework. Also, I think it's a pretty bad sign that there's a website called Undocumented MATLAB that's dedicated using "hidden" parts of MATLAB.

Julia is supposed to take the spot of MATLAB as a language quick to pick up and sketch out some algorithms, but it also feels like a solid language built by computer scientists. Of course, if you're a Rubyist, you might not care about MATLAB to begin with, so what's the point? Well, if you're doing any sort of numerical work, Julia is definitely worth a look: it gives you the feel of a dynamic, interpreted language, with performance close to that of a compiled one. Creating quick visualizations of data is also a breeze.

*Continue reading %Julia for Rubyists: Crunch Those Numbers%*