Type Safe Heterogenous Containers in Java

As someone who has shifted from Python to Java, this article discusses two of the problems I’ve faced in Java that don’t exist in Python:

  1. Java’s type system cannot represent containers or maps with heterogenous value types. Python dicts can hold anything.
  2. Java’s methods lack named and optional parameters. Coming from Python this is maddening.

As a response to these problems, this article presents a small library that makes them a bit less painful. We build on Effective Java’s item #29: consider typesafe heterogeneous containers. The library code is available at https://github.com/stevewedig/blog and is published to Maven for easy usage as a dependency. This is the second in a series of Java libraries I’m sharing on this blog (the first was Value Objects in Java & Python).

Continue reading

Value Objects in Java & Python

So far I’ve posted a Software Developer’s Reading List and Why & How I Write Java. After all that high-level jabbering it’s time for something concrete with actual code. This article discusses value objects: what they are, how to implement them, and when to use them.

I think object-oriented languages should have value objects built-in, like structs in C# (with caveats). Unfortunately they aren’t built into Python or Java (yet). However we can implement value objects on our own, and this article includes small libraries to make it easy for Java and Python.

Continue reading

Why & How I Write Java

A few weeks ago I posted a software developer’s reading list. An important criterion for this list was technology independence because most software development skills transcend whatever tools we are currently using. That being said, our choice of tools is quite important. This article explains why I currently build software using Java (and its platform). I also describe how I write Java: techniques, conventions, and practices.

I’m no Java evangelist. I am frustrated by the gap between established languages and what I believe our profession is capable of designing. (One cause is the momentum of standards which makes them expensive to replace.) For me the goal of software development is to evolve valuable software with a team. I think Java, with its platform & ecosystem, is currently the best tool to support this multi-faceted goal. (This applies to general application programming, not to programming requiring the ability to explicitly manage memory.)

I recognize that using Java isn’t an interesting or exhilarating choice. I am going to be posting some open-source Java code, and I think it is useful and perhaps helpful to present the rationale for why I choose to use Java professionally. Also my perspective is informed and biased by my background, which is 7+ years of delivering web applications and services, starting with Python + JavaScript and then shifting towards Java. The right decision for my needs may not be the right one for yours.

Related Article: Teach yourself programming in 10 years

Continue reading

A Software Developer’s Reading List

“An investment in knowledge always pays the best interest.” – Benjamin Franklin

Many of the best software developers have T-Shaped Skills: Deep expertise in programming and software development, and broad knowledge of diverse areas including testing, DevOps, UX design, team organization, customer interaction, and their domain areas. While there is unfortunately no substitute for experience, reading is probably the next best thing. Over the past 10 years I’ve read a lot in an effort to deepen and broaden my knowledge as a software developer. Along the way I’ve been organizing books and concepts into the reading list I share below. I have been trying to design a core curriculum for “modern” software development by asking myself:

  • What core concepts are required to be a world class software developer?
  • What is the best book for introducing and teaching each concept?

The result is a list of 16 essential software development concepts presented by 16 excellent books…

Continue reading

Relationships Between Component Design Principles

Component Design is one of the concepts on my software developer’s reading list. There are a lot of component design principles (heuristics), so to help me keep them straight, I’ve organized them into this (imperfect) mental model for how they relate to each other:

If I had to summarize component design into one sentence, I might say something like: Manage complexity by using interfaces (information hiding and abstraction) to decouple the components in your system.

A Few Python Tricks

(Edit: This is a fairly old library. If you are interested in @once, frozendict, and Opt, these are included as part of the newer value objects library.)

A while ago I gave a talk to the LA Python user group about a few Python tricks we use at my company Lingospot. Three years later we’re still using all of these techniques. There isn’t any particular theme, it’s just a mix of tricks that are simple and widely applicable. You can find the slides and sample code here.

If I recall, the talk was generally well received. Interestingly some audience members didn’t find Option Types to be “Pythonic”, which very well may be true. Nowadays I prefer to use Java for reasons I describe in Why & How I Write Java.  For Option Types in Java I use Google Guava’s Optional. I certainly don’t miss the errors caused by null/None.