Edd Mann

I recently had the pleasure of chatting with Adam Wathan on Full Stack Radio about PostgreSQL - a technology near and dear to my heart.

Last week, I was required to validate that a supplied integer would fit correctly into a 32-bit address space.

In a recent tweet from Adam Wathan, highlighting one of the examples in his upcoming book, he demonstrated breaking down the process of converting from binary to decimal representation using a pipeline of transformations.

Recently, I have been looking more into SQL and, in particular, how RDBMSs work under the hood.

In a recent Full Stack Radio podcast, a discussion around the application of transpose and zip on collections made me wonder how I would go about implementing such a feature in JavaScript.

In a recent SQL statement, I stumbled upon an issue regarding the handling of NULL values within a given predicate.

Following on from my discussion on Mapping, Filtering and Reducing in PHP, over the past couple of months, I have been using a little trick I would like to discuss.

Recently, a feature I was working on required me to alter a unique constraint that existed on a table column.

Over the past couple of years, I have transitioned from boilerplate-heavy, imperative code to using the more intuitive map, filter, and reduce higher-order functions.

Who doesn’t miss the blink tag that was ever-present in years past?

Sometimes, you look at a feature request and think that it may be a very tricky implementation to develop.

The next sorting algorithm I have decided to explore is the Insertion Sort.

Following on from my previous solution to implementing the Bubble Sort algorithm in Clojure, I thought it would be interesting to experiment with a different approach.

If you want to check if two arrays contain the same values, regardless of order, you will encounter some issues using the operators == and ===.

Following on with my exploration into implementing common sorting algorithms in Clojure, today we have the Bubble Sort.

I have been writing a lot about Promises in JavaScript over the past couple of weeks.

In a previous article, I demonstrated how a new feature from ES2016 (async/await functions) could be used to help coordinate promises and execution.

One tool that I use on a regular basis when compiling the notes for a Three Devs and a Maybe episode is a tool for converting a clipboard full of links into a Markdown-formatted list.

One feature of ES2015 that I feel can be a stumbling block (but is extremely useful) is Arrow Functions’ lexical scoping of this.

Whilst working today, I came across a test helper function that required a few too many parameters.

This morning, I stumbled upon an issue surrounding checking for the existence of a variable in JavaScript.

Today, I stumbled upon some code that I did not realise was possible with the array_map function in PHP.

I was recently working on a React component that complained about its state being set when it was not mounted.

Following on from my post on Binary Search Trees last week, I decided to explore how I could use types and interfaces to implement the glue required to make the Binary Tree implementation compatible with the clojure.lang.IPersistentSet interface.

Throughout the past couple of months, much of the JavaScript development I have been involved with has revolved around Promises.

Currently reading through the Joy of Clojure book, I have recently been introduced to Clojure’s multi-method support.

This weekend I was able to spend some more time exploring Clojure.

Inspired by a good friend’s recent Gist on how the functionality of the special form let could be achieved using a little Lambda trickery, I decided to write a simple macro that would do this transformation.

This lunchtime I decided to implement a solution to the balanced parentheses (brackets) problem in Clojure.

There may be a case where you need to make sure only a single row value is true in a collection of results.

This past weekend I had the opportunity to delve more deeply into Clojure’s core library.

The concept of trampolining_seems to have been a running trend throughout this week.

Following on from yesterday’s post that discussed ‘Trampolining’ in JavaScript, I thought it would be interesting to see what Clojure has to offer.

An interesting technique for managing perceived tail-call optimised algorithms in an environment that does not provide such capabilities is to use a concept called a trampoline.

Whilst currently reading through The Joy of Clojure book I was introduced to the concept of pre and post-conditionals, similar to another language called Eiffel.

Following on from my previous post, I have continued my exploration into Clojure by implementing a simple infix calculator - using the Shunting Yard algorithm and RPN evaluation.

This past Christmas break I had the chance to finally pick up The Joy of Clojure book and delve into the world of Lisp.

The Flux architecture abides by a single unidirectional data-flow throughout the entire application.

Having an hour to spare recently, I decided to solve the common problem of converting from Hindu-Arabic to Roman numerals.

This weekend I have had the chance to explore Cartesian products.

Whilst completing the Functional Programming Principles in Scala course a couple of years ago one of the exercises was in the realm of Peano numbers.

Developers who are well versed in class-based languages such as Java and C++ may find JavaScript’s prototypical and, in my heart, true object-oriented nature confusing.

The new keyword in JavaScript can sometimes slip up new and experienced programmers alike.

Following on from my recent post on implementing a small RPN parser using JavaScript, we can expand on this by handling infix expressions.

Following on from our first screencast, which touched upon how to set up a PHP extension development environment and the creation of a simple array_sum-like function.

This morning I decided to quickly write up a small Reverse Polish Notation evaluator in JavaScript.

I have always enjoyed how succinctly you are able to use commonly found operators as first-class functions in languages such as Clojure.

In the very first screencast episode of Three Devs and a Maybe, I was fortunate to chat with PHP core developer Joe Watkins, discussing PHP 5 and 7 extension development for beginners.

Recently Max Howell (creator of Homebrew) posted an interesting tweet in regard to Google’s interview process.

Throughout project development we use Jenkins to provide meaningful test feedback on each Git push event.