Is HTML a programming language? I could express a bit of shock, even dismay, at the question, but instead, I’ll try a more polished approach. In some sense, it may be a […]
Of course HTML is a programming language
We don’t need a ternary operator
A staple of compact code, the ternary operator ?: feels like it’s earned a place any programming language. I use it often; you should use it often. However, I don’t like the […]
How I use `variant` in the Leaf compiler
Variants are data types that can store different types of values in them, as opposed to one fixed type. In contrast to a generic object or an untyped variable, there is a […]
Should function arguments be reassignable or mutable?
Working on a defect in Leaf I had a question: should function arguments be reassignable within a function? Are they just like local variables, or should they be treated specially? It would […]
What is a closure?
You’ve heard the term, you’ve probably even used them, but what exactly is a closure? It’s a combination of data and code that have become a staple of modern programming. They offer […]
Adding += and friends to Leaf
Yesterday I finished a rather simple Kata from Codewars: the sum of a sequence of numbers. It was straight forward to implement, but I felt like it was missing something. It looked […]
What is functional programming?
Three key concepts comprise the essence of functional programming: first-class functions, pure functions, and immutable data. Together they express a fundamental architectural paradigm on how units of code interact with each other. […]
Sorting a file: A real program in Leaf
Finally, a big step for Leaf: something that could be called an actual program. Over the weekend I finished a program that loads a file, sorts the lines, and writes it to […]
Working with types and named constructors in Leaf
As types are a keystone in Leaf, working with them must be fluid and simple. I recently improved this area by adding named constructors and bare type names. The results are interesting. […]
The agonizing necessity of cached calculations
Language support for caching sucks. Despite an ever present need to cache data and calculations most languages require the programmer to do all the work. There’s no way to track dependencies, no […]
The meta-field dilemma: `a.size` or `size(a)`
I can’t decide whether a.size or size(a) is more correct when getting the length of an array. While writing Leaf I have a recurrent feeling that perhaps a.size is wrong. What is […]
The bitwise complement, or not operator, is unsafe
I came upon a problem with bitwise complement (logical not): it isn’t safe. It’s nothing new, but it really registered while implementing the logical operations in Leaf. The issue is the result […]
Optional Types and Leaf: Removing automatic dereference
Optional values are one of the fundamental extrinsic types in Leaf, as are shared values. Originally optional values were used just like regular values, dereferenced automatically. I was always uncertain of that. […]
The hard part of error handling is not the error itself
Are our discussions about errors focusing on the right part of the problem? We tend to argue about what exceptions mean, or how return values are messy. But if I look at […]
