In Emacs, company-mode (short for “complete anything”) is a framework for performing completion in buffers. It’s an alternative to the popular auto-complete-mode. company-mode supports extension via backends which provide the framework with lists of possible completions in various contexts. So, for example, there’s a backend that provides completion support for Emacs lisp and one that does the same for Python. Backends can use very different technologies as long as they conform to the backend interface specified by the mode.
You probably already know how to use Python’s super() to call base-class implementations of methods. But do you really know what it’s doing? The details of super() are elegant, interesting, and powerful, and while super() is probably more complex than you expect, it’s also surprisingly easy to understand. In this series we’ll explore super() by first uncovering a bit of a mystery. To resolve the mystery, we’ll look a bit under Python’s hood to see how super() really works.
In this series we look in detail at the behaviour of one of the simplest geometric functions, demonstrate its flawed behaviour when implemented with floating point numbers, and fix it using an exact number type provided in the Python Standard Library.
In this series we look at how software architects – or really anyone involved in creating software – can use testability to help manage other quality attributes. From modularity to performance to the SOLID principles, testability can act as a proxy and an enabler for many of the cross-cutting, interacting concerns that architects need to shepherd. Over several articles we’ll explore testability’s relationship to these qualities, and we’ll see how paying attention to testability can help simplify the job of managing them.
In this series we take an in-depth look at transducers. Transducers – a portmanteau of ‘transform reducers’ – are a new functional programming concept introduced into the Clojure programming language. Although transducers are actually pretty straightforward in retrospect, wrapping your brain around them, especially if you’re not already a competent Clojureist, can be challenging.
In this series, we introduce transducers by implementing them from scratch in everybody’s favourite executable pseudocode, Python. We’ll start with the familiar staples of functional programming, map(), filter() and reduce(), and derive transducers from first principles. We’ll work towards a set of general tools which works with eager collections, lazy ‘pull’ sequences, and ‘push’ event streams. Along the way we’ll cover stateful transducers and transducer composition, demonstrating that transducers are both more general, and more fundamental, than the functional programming tools baked into Python and many other languages.
By the end of this series, not only should transducers make sense to you, but you’ll have a recipe for implementing transducers in your own favourite programming language.