Image for post
Image for post
Learn Elixir — chapter by chapter explanation of Programming Elixir 1.6 (by Dave Thomas)
  1. Chapter 1 and 2 — OOP, Functional Programming, and Pattern Matching
  2. Chapter 3 — Immutability
  3. Chapter 4 — Basic Elixir Types
  4. Chapter 5 — Anonymous Functions (this post)
  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 4th post in this series where I share key learnings from each chapter of Programming Elixir 1.6. If you haven’t read my previous posts yet, feel free to check those out first before continuing. …


Image for post
Image for post
Learn Elixir — chapter by chapter explanation of Programming Elixir 1.6 (by Dave Thomas)
  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. …


Image for post
Image for post
Learn Elixir — chapter by chapter explanation of Programming Elixir 1.6 (by Dave Thomas)
  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. …


Image for post
Image for post
Learn Elixir — chapter by chapter explanation of Programming Elixir 1.6 (by Dave Thomas)
  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. …


Image for post
Image for post
I’ve learned to love everything about this screen. Seriously.

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). …


Image for post
Image for post

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). …


Image for post
Image for post

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. …


Image for post
Image for post

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. …


Image for post
Image for post

Recently, I wrote a tutorial on how to get started using Typescript, ReactJS, and Webpack because I noticed there weren’t many good online resources highlighting how to integrate them together. In this post, I want to continue where I left off and add a wrinkle many people have asked for: Testing. I won’t explain why we want to write tests for our code because if you’re reading this, I’m going to assume you know how important and life-saving it can be! …

About

Willson Mock

I’m an avid learner, and I write about web technologies, personal fitness, and other fun stuff. http://willsonmock.com

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store