1. Chapter 1 and 2 — OOP, Functional Programming, and Pattern Matching
2. Chapter 3 — Immutability
3. Chapter 4 — Basic Elixir Types (this post)
4. Chapter 5 — Anonymous Functions
5. Chapter 6 — Modules and Named Functions (coming soon)
6. Chapter 7 — Lists and Recursion (coming soon)
7. Chapter 8 and 9 — Maps, Structs, and Keyword Lists in Detail (coming soon)
8. Chapter 10 — Processing Collections (coming soon)
9. Chapter 11 — Strings and Binaries (coming soon)
10. Chapter 12 — Control Flow (coming soon)

Welcome back to my 3rd entry in this Programming Elixir 1.6 Chapter By Chapter series. This post will focus on Chapter 4 which discusses the basic types in Elixir. I won’t go over all the types that are mentioned but instead will highlight some of the more interesting points from the chapter. …

1. Chapter 1 and 2 — OOP, Functional Programming, and Pattern Matching
2. Chapter 3 — Immutability (this post)
3. Chapter 4 — Basic Elixir Types
4. Chapter 5 — Anonymous Functions
5. Chapter 6 — Modules and Named Functions (coming soon)
6. Chapter 7 — Lists and Recursion (coming soon)
7. Chapter 8 and 9 — Maps, Structs, and Keyword Lists in Detail (coming soon)
8. Chapter 10 — Processing Collections (coming soon)
9. Chapter 11 — Strings and Binaries (coming soon)
10. Chapter 12 — Control Flow (coming soon)

Thank you for reading my 2nd entry in this Programming Elixir 1.6 Chapter By Chapter series. In case you didn’t read the first post in this series, you can view it here. I’ll continue where I left off and summarizes my learnings from Chapter 3 of Dave Thomas’ Programming Elixir 1.6. …

1. Chapter 1 and 2 — OOP, Functional Programming, and Pattern Matching (this post)
2. Chapter 3 — Immutability
3. Chapter 4 — Basic Elixir Types
4. Chapter 5 — Anonymous Functions
5. Chapter 6 — Modules and Named Functions (coming soon)
6. Chapter 7 — Lists and Recursion (coming soon)
7. Chapter 8 and 9 — Maps, Structs, and Keyword Lists in Detail (coming soon)
8. Chapter 10 — Processing Collections (coming soon)
9. Chapter 11 — Strings and Binaries (coming soon)
10. Chapter 12 — Control Flow (coming soon)

In my day to day, I write a lot of code in both JavaScript and Ruby. I’ve always enjoyed learning new programming languages — I’m a firm believer that new languages and paradigms can really expand the way you think about code. So my goal with this new series of blog posts is to share my own learning of a programming language that I’ve heard a lot about recently: Elixir. …

As an engineer working on the web platform, Google Chrome’s Developer tools is a godsend. I seriously can’t emphasize enough how important Chrome Developer tools is to my daily routine of debugging JavaScript. Gone are the days of console.log’ing everything — thank goodness!

At the beginning of this year, I set out on a 100 day personal fitness challenge. Initially, my goal was to Instagram a photo collage of all the foods I ate each day as a way to hold myself personally accountable, eat less, and lose some weight.

However, as I pushed myself through each day of the challenge, I discovered I was getting more interested in various aspects of personal fitness. Initially, I thought getting “fit” was synonymous to just losing some weight but as I’ll describe below, that’s really not the case (at least not entirely). …

When I first started learning React, I remember reading lots of articles about the different technologies associated with it.

In particular, this one article stood out. It mentions how confusing the ecosystem is, and how developers often feel they have to know ALL of the ecosystem before using React.

And as someone who’s used React daily for the past 8 months or so, I can definitely say that I’m still barely scratching the surface in terms of understanding how the entire ecosystem works!

But my time spent using React has given me some insight into when and why it might be appropriate to use another technology — Redux (a variant of the Flux architecture). …

Many of you have probably heard of Facebook’s React library and used it in your own work or projects. It’s extremely popular and makes developing user interfaces simple and declarative.

As the title of this post suggests, React has a couple of concepts referenced throughout its documentation that might be confusing to newer React users. For example, if you look at their Glossary, Top-Level API, and Explanation on Refs, and do a quick search for “ReactElement”, “ReactComponent”, and “Component Backing Instance”, you’ll find that these terms are used everywhere and are absolutely core to React.

This post isn’t a React tutorial; it’s more of me just sharing some of what I’ve learned about React recently. Therefore, it’s targeted towards folks who have dabbled with React before, and I’ll assume that you’re familiar with some of the core React concepts and syntax. …

Lately, I’ve been trying to upgrade the code base for a personal project with some legacy code in it. Specifically, it’s a web application built with Typescript that:

1. Contains a manually injected <script> tag in the index.html file for each JavaScript file loaded (i.e. JavaScript files are not bundled using Browserify or Webpack)
2. Doesn’t leverage CommonJS modules (instead, there are globally namespaced variables)

The purpose of this post is to discuss some of the lessons I learned when transforming the code base from using legacy features to using some better Typescript features. …