Posts

  • Visualizing TensorFlow Graphs in Jupyter Notebooks

    TensorFlow operations form a computation graph. And while for small examples you might be able to look at the code and immediately see what is going on, larger computation graphs might not be so obvious. Visualizing the graph can help both in diagnosing issues with the computation itself, but also in understanding how certain operations in TensorFlow work and how are things put together.
  • Fibonacci Numbers

    We'll take a look at different ways of calculating fibonacci numbers in JavaScript. Starting from simple recursive implementation, followed by dynamic programming and an iterative approach.
  • Thoughts on OS X Yosemite, Arch Linux and xmonad

    I’ve been using OS X as my main machine for quite a while now, mainly because I got into Ruby development, and having a Mac is just the thing you do when you write Ruby (at least that’s what I thought back then.) One of the main reasons why I really fell in love with the Mac is that things just work. There is no hassle in setting up your drivers, or connecting a printer, or getting your favorite app to work. Everything works out of the box.

  • Parsing CSS with Parsec

    This article is a small introduction to Parsec, the Haskell parser combinator library for Haskell. We’ll use it to parse simple CSS file such as the following.

  • Lens Tutorial - Stab & Traversal (Part 2)

    In the first article in the series about lenses, we’ve looked at the motivation behind the lens library, and we also derived the basic type of Lens s a.

  • Foldable and Traversable

    Before we can get into the more advanced topics on Lenses, it is important to really understand both Foldable and Traversable, which is the motivation behind this article.

  • Building Monad Transformers - Part 1

    In this article we’ll focus on building our own monad transformers. We’ll start out with an example code and improve it by building a simple wrapper over IO (Maybe a).

  • Mutable State in Haskell

    Haskell is a purely functional language, which means there are no side-effects and all variables are immutable. But as you probably know this isn't completely true. All variables are indeed immutable, but there are ways to construct mutable references where we can change what the reference points to.

  • Lens Tutorial - Introduction (part 1)

    This article is the first in the upcoming series that aims to explain the Haskell’s lens library and the ideas behind it in an approachable way. Don’t worry if you’re new to Haskell, the only prerequisites here should be understanding of the Functor type class, and understanding how records and algebraic data types work in Haskell.

  • Using Phantom Types in Haskell for Extra Safety - Part 2

    I’ve received a lot of reactions to the previous blog post about Phantom Types over the past two days, which is why I’ve decided to summarize what I’ve learned in another blog post.

  • Using Phantom Types for Extra Safety

    If you’ve been programming in a dynamic language, you’ve probably heard that type systems can catch more errors before your application even gets run. The more powerful the type system is, the more you can express in it. And because we’re talking about Haskell, we have a great number of tools at our disposal when trying to express things in terms of the types.

  • Evil Mode: How I Switched From VIM to Emacs

    I’ve been a long time VIM user. I use it every day for all of my work and side projects, writing blog posts, writing other content, sometimes even for writing emails if the text is long enough. VIM is like my home and I’m deeply in love with it.

  • Yesod is Fun

    I’ve been trying many Haskell web frameworks over the past few weeks. I wrote one small app with Simple, almost wrote another one with Scotty. Then decided it’s time to take a look at the big guys, Happstack, Snap and Yesod.

  • Duplication in Tests Is Sometimes Good

    Having powerful tools like RSpec gives us so much power, that what was once a nice suite of readable specs becomes a huge bunch of unreadable mess, just because someone tried to DRY it up.

  • Light Table Plugin Tutorial

    I’ve been playing around with Light Table since the day its source code was released (even made a tiny Ruby plugin).

subscribe via RSS