Code

In this blog, I post about my coding interests and projects. In particular, I feature my own libraries and packages. Some of these have been created from scratch, and others are extensions of others' libraries. Scroll down, and click on one of the below blog posts to read more!

Programming philosophy

My strength is writing highly-efficient code that leverages cutting-edge results from the algorithms literature. Highly-performant, industrial-strength code demands a thorough understanding of algorithms and data structures. As we operate in big data settings, the efficiency with which algorithms and data structures scale with large data sets is of the utmost concern. That is, a sturdy theoretical foundation is essential for the modern, elite programmer. Equally important is a deep understanding of programming paradigms and a few use-case-orthogonal languages. When writing my own code, I subscribe to the concepts emphasized in generic programming and object-oriented programming, in particular. I use the scripting languages, Python and Julia, for high-level tasks, and I employ the systems language, Rust, for performance-critical code.

Languages

Presently, I write code in several languages: mostly Rust, Python, and Julia. In the past, I've used C, C++, R, and Mathematica as well.

Rust

Rust, my favorite language, is a powerful, safe, modern systems language. Coarsely, Rust is a modern improvement on C++. While C and C++ still enjoy popularity within the set of systems languages, Rust was designed with concurrency and memory-safe code in mind. Dangling pointers, data races, and segmentation faults are a thing of the past provided that one understands Rust's borrowing concept. Originating some 25 years after C++'s first release, Rust's design incorporates paradigms and techniques that have proven important in modern settings. Yes, new editions of C++ and its important libraries are released frequently. As such, C++ has been morphed to accomodate modern concerns. However, there is something to be said about a language being designed, from its very beginning, to achieve modern objectives (e.g., safe concurrency). This is one of Rust's net-positives over C++. Plus, Cargo is incredibly slick!

Python

Python is a beautiful language with an unparalleled package ecosystem. Its elegance makes development and prototyping quick and intuitive. I use Python for quick-and-dirty solutions, or when I need to use a particularly clever Python package. Pure Python is relatively slow. However, idiomatic use of the right packages, e.g., NumPy, PyTorch, Cython, etc., yields performant code. Moreover, Python's vast package ecosystem is second to none. In addition to those mentioned above, some of my favorite packages include graph-tool (which I consider superior to the quality, well-known package NetworkX), pandas, scikit-learn, HoloViews, and Bokeh.

Julia

Roughly-speaking, Julia is a modern, better-designed Python with just-in-time compilation, multiple dispatch, and a type-system that, when understood, can offer substantial performance improvements. Julia offers C-like performance with Python-like development ease; it truly is the cutting edge for scientific computing. For scientific-computing users, perhaps Julia's only noteworthy con is that the Julia community is relatively small. However, enthusiasm for Julia has enjoyed persistent, meteoric growth, dissapating the language's biggest con. Look for Julia to be Python's biggest competitor within the scientific computing community in a few years (it's roughly there already). In particular, Julia is attractive for those who value efficient code without needing to employ package-specific tricks (e.g., NumPy vectorization) or a two-language solution (e.g., Cython).

Please bear with me as I begin making my private GitHub repos public and writing up introductory blog posts

2012

2013

2014

2015

2199