Paperless Adulting on Linux with Evernote and NoteSlurp

Adulting is hard. Bills come and go, taxes have to be prepared, escrows have shortages, kids have activites, FSAs need proof of medical expenses, cars need to be registered.

The list of things an adult has to do seems to only grow larger over time, and one of the fundamental things that all adults seem to have to do is to track and file paperwork. I’ve gone “paperless” in my personal life (which I seem to have interpreted it to mean: “keep digital copies of everything, even if it was paper originally”).

When it comes to adulting, barriers to doing the right thing (like actually getting stuff filed paperlessly) are bad, as you won’t do them. So, recently I decided to make that just a little bit easier on myself with a new tool. Let me walk through the research I’ve done, what my process for paperless filing is, and where I’ve historically had problems, and how this new tool has helped me out.

[Read More]

Unsigned Integers with Java and Kotlin 1.3

Something that has always been a bit of a limitation in the Java numeric type system is the lack of support for unsigned integers. It is not particularly common to have to work with unsigned types, but when it does happen, it’s usually unpleasant in some way. Libraries like Guava have provided utilities to make it cleaner, and recent updates to Java 8 also included some unsigned helper methods.

Kotlin 1.3 has an experimental feature to make unsigned types a full citizen of the type system, while still having all of the performance of primitive integer types. Let’s take a look!

[Read More]

A Semi-Deep Dive into Kotlin Inline Classes

With Kotlin 1.3, a new experimental feature called “Inline Classes” is now available. This post is a somewhat deep dive into the nature of the implementation, how it works, where the edges are, and what limitations currently exist. Let’s take a look!

[Read More]
kotlin  java  jvm 

Contracts in Kotlin 1.3

Kotlin 1.3 is bringing a new experimental feature to the compiler to help with improving program correctness via the type-system: contracts.

Contracts are a tool that allow library code (both standard library and your libraries) hint to the compiler about the constraints that are ensured on types based on the use of functions in your program. Let’s see how this can be used in practice.

[Read More]

De-Structuring in Kotlin

Recently I wrote an article about de-structuring in TypeScript, and hinted that Kotlin has a similar feature, but in more of a “strongly typed” language style. Today I want to discuss that feature. To re-cap from the previous article, de-structuring is, at the core, a syntactic sugar to easily “lift” parameters out of an object or array and declare local all in one shot. With ECMAScript and TypeScript, this comes in two forms: positional (for arrays and iterables) and by name (for objects). [Read More]
kotlin  java 

Typescript for Java Developers: Index Types

A fairly recent addition to Typescript is index types and the keyof operator. For a Java developer this is an interesting thing to learn about, as Java doesn’t have this feature, specifically due to type system inflexibility. Academically speaking, an index type is a small facet of dependent type systems (where one type in use is dependent upon the value of another input). This is also, in effect, a way to get many of the benefits of a heterogenous map. [Read More]

Typescript for Java Developers: De-Structuring of Variables

ECMAScript is all about wrangling loosely typed variables. In a compiled and strongly typed language like Java, classes have a fixed shape (aka schema) and every object follows that pattern strictly. With ECMAScript, objects are more “ad-hoc” in that any single object be comprised of any combination of properties. Prototypes help with pre-defining that combination, but you can muck around with it all you want. Consequently, there is an opportunity for language features around lifting, shifting, filtering, and moving around properties from objects. [Read More]

Typescript for Java Developers: Variable Scoping

When learning a language built on another existing platform, like TypeScript (or, for that matter Kotlin), one of the challenges you face is understanding the underlying platform or language so that you can, in turn, understand how the higher-level language is applied to meet the restrictions and features of the lower-level language. Inevitably, no amount of documentation for a language built upon another language or platform is complete without some degree of knowledge of the underlying platform. [Read More]