Irregularly Scheduled Programming

If you’ve read any of my past posts you know I like to program in several different languages, some of which I like more than others.

I’m getting more and more into data engineering these days and having used R for a long time, I’m seeing a lot of problems that look nail-shaped to my R-shaped hammer.

Translating things between languages reveals how each language approaches different design trade-offs, and I believe it’s a useful exercise.

I’ve been learning Haskell for a few years now and I am really liking a lot of the features, not least the strong typing and functional approach.

Learning Japanese means memorizing thousands of characters, some of which look nearly identical.

When things run slower than we’d like in R we tend to reach for another, usually compiled, language, and move our code there.

How well do you know your fundamental operators in different languages?

In which I confront the way I read code in different languages, and end up wishing that R had a feature that it doesn’t.

Python seems to be everywhere these days, and I’m really into learning languages, so it should come as no surprise that I’m learning a lot of Python.

I keep saying that the more programming languages you know, the more you will understand all the others you know - I’m now at the point where I want to solve every problem I see in a handful of different languages.

Continuing my theme of learning all the languages, I took the opportunity of a programming puzzle to try out the same approach in a handful of different languages to compare how they work.

In this post I describe a useful programming pattern that I implemented, and hopefully provide a gentle introduction to the idea of monads.

As October rolls around once more, the term Hacktoberfest might pop across your feeds; an effort aiming to encourage people to contribute to open-source software, particularly if they’re new to that.

In this post I explore some differences between R, python, julia, and APL in terms of mutability, and try to make something that probably shouldn’t exist.

Gleam vs R I thoroughly dislike ‘hot takes’ comparing programming languages based solely on a “feel” or differential familiarity (“I know this one better therefore it is better) so when I came across a blog post detailing a small learning project written…

At a recent APL-focussed Meetup someone posed a challenge to slice up the components of an IPv4 address with an APL language and it prompted me to learn a bit more about how that works in general and how I could do the processing in APL myself.

A while ago (2019 seems so long ago now) I started working on something I thought was interesting but which never really got any traction.

I’ve been using a lot of programming languages recently and they all have their quirks, differentiating features, and unique qualities, but one thing most of them have is that they handle strings as a collection of characters.

A while ago I made some plots I really liked, but I never made a blog post about them.

I heard that learning Elm is a good way to approach learning Haskell, so I gave it a go and was surprised early on about an approach to writing abstracted HTML.

Another day, another short riddle to be solved with several programming languages!

I saw a toot celebrating a short, clean implementation of a square root finding algorithm and wanted to dig a bit deeper into how it works, with a diversion into some APL.

With a serious yak shaving deviation, I have a really short “cheat” solution to one of the featured Exercism problems.

I’ve tried to get this same image transformation working at least three times now, but I can finally celebrate that it’s working!

Hyperlinks are great - they add value to a block of text by adding additional links out to more things to read - but they’re a distraction if you’re trying to read an in-depth piece of text and comprehend it linearly.

I’m solving Advent of Code this year using a relaxed criteria compared to last year in that I’m allowing myself to use packages where they’re helpful, rather than strictly base R.

In the lead up to Christmas each year, Advent of Code offers a series of 25 puzzles which start out reasonably simple, but get progressively harder, eventually requiring knowledge of algorithms and dynamic programming techniques.

Print debugging has its place.

If you’re reading this hoping that I’m done with droning on about array-languages, close the tab… it only gets worse from here.

I’m part of a local Functional Programming Meetup group which hosts talks, but also coordinates social meetings where we discuss all sorts of FP-related topics including Haskell and other languages.

I keep hearing the assertion that “writing APL/Haskell/etc… makes you think differently” and I kept wondering why I agreed with the statement but at the same time didn’t think too much of it.

One thing that has really caught my attention as I learn more programming languages is the idea of generators or infinite sequences of values.

I’ve been learning at least one new programming language per month through Exercism and the #12in23 challenge.

Your collaborator says to you “I have some code I’d like to distribute to people who will probably work in R most of the time.

With Functional Programming, we write functions which take arguments and do something with or based on those arguments.

Update: this post was discussed late March 2024 on HackerNews and lobste.rs.

I’ve been following the drama of the RustConf Keynote Fiasco (RKNF, per @fasterthanlime) from a great distance - I’m not involved in that community beyond starting to learn the language.

This might not have been difficult for a seasoned web-dev, but it was reasonably tricky to find a clear solution online (at least it was for me) so here’s how I added the neat domain hints next to all the hyperlinks on my blog.

Plotly has a nice way of making click-events available to the calling language, but it doesn’t quite work simply when using subplot().

I’ve been working my way through Exercism exercises in a variety of languages because I strongly believe every language you learn something about teaches you about all the others you know, and makes for useful comparisons between what features they offer.

I’ve just finished reading ‘Version Zero’ by David Yoon.

Don’t show me puzzles, unless you want to be responsible for me staying up too late solving them.

I’ve had the impression lately that everyone is learning Rust and there’s plenty of great material out there to make that easier.

Updated: 2022-09-04 I took a very long time to post about the last Australian Signals Directorate (then DSD) decryption, so this time I’ll be a lot more punctual.

Another ‘small learning project’ for me as I continue to learn Julia.

I’ve long been interested in exactly how R works - not quite enough for me to learn all the internals, but I was surprised that I could not find a clear guide towards exactly how vectorization works at the deepest level.

I occasionally like a round of code-golf (e.g. recently) and I try to solve these with R, but this one gave me some hope that I could make use of a really cool feature I knew about in common lisp. lisp is timeless. https://xkcd.com/297 I have occasionally…

I occasionally like to participate in an odd sport known as ‘code golf’ where the aim is to write some code to achieve a given task using the smallest number of characters.

I just finished ‘Code: The Hidden Language of Computer Hardware and Software’ by Charles Petzold which was a really well-written (in my opinion) guided journey from flashing a light in morse code through to building a whole computer, and everything needed…

I saw this post on Reddit’s r/dataisbeautiful showing this plot of streaming services market share, comparing 2020 to 2021 US Streaming Services Market Share, 2020 vs 2021 and thought it looked like a good candidate for trying out some plot improvement te…