Skip to main content

Simple code: Functions and methods

What makes a good function or method? I don't think it's a single thing but a combination of things where each is significant. If one the things is flawed it affects to all others and the whole function is flawed. So what are those "things"?

Have a meaningful name


Function should have a name that describes it's purpose or functionality. When a function has a meaningful name it's easy to read and understand what's it's purpose.

Let's take a example.

If function's purpose is to find a customer by it's id a good name could be findCustomerById(id: String) or it could just as well be just findCustomer(id: String) because the function signature implies that the
customer is found by it's id the word find also implies that the customer might be found or it might not be found.
If the function's name would be changed to getCustomer(id: String) it's meaning changes because now it implies that there's no fallback, the customer is either found or the function fails miserably and maybe throws a exception.
Both are valid names for a function but they have a different meaning and therefore their implementations should also be different.

Should have as few parameters as possible


I like to follow the rule of three myself what that means is that a function should have three or less parameters. When the function needs more than three parameters it should be rewritten and the parameters placed inside a data holder e.g. class, data class, JavaScript object etc. This is a easy way to reduce the number of parameters and to organize the data within the application.

Lets take a example of a function that has identical behaviour but differing signatures.


fun createCustomer(
  firstname: String,
  lastname: String,
  streetAddress: String,
  city: String,
  zipCode: String
)


vs.

data class Address(
  val street: String,
  val city: String,
  val zipCode: String,
  val streetNumber: String
)

data class Customer(
  val firstname: String,
  val lastname: String,
  val address: Address
)

fun addCustomer(customer: Customer)


Does what's expected


Function should do what's expected of it, nothing more, nothing less. If a function is named as findAddress(latitude, longitude) it should find the address in the given coordinates or if no address can be translated for the coordinates return a None, null, Empty, what ever is the appropriate type for the given language. The function should not do anything else e.g. find  adjacent addresses or building records of the coordinates or address. The function can have side effects like logging or analytics but those
are invisible to the input and to the output.

Is testable


Functions should be designed so that they're testable. In the previous code sample I defined the function addCustomer but I didn't define any return type for it so in that format it's testability is questionable. Sure it could be tested with mocks or spies depending on what the internal implementation is like but by just simply giving it a return type we can easily test it.

fun addCustomer(customer: Customer): Customer


With the given function signature we can return the added customer entity to the callee and with that addition we can test that the function does what it's supposed to do that customer entity e.g. assign it a unique id.

Four conventions for functions


Have a meaningful name, have as few parameters as possible, do what's expected of it and be testable.
Doesn't seem that hard to follow or too restricting conventions that when followed makes the code simple, easy to read, easy to reason, testable and maintainable.

Next part


In the next part I'll be writing about contracts and how they're related to code.

Popular posts from this blog

Simple code: Readability

Readability, understandability, two key incredients of great code. Easier said than done, right? What one person finds easy to read and understand another one finds incomprehensible. This is especially true when programmers have different levels of understanding on various subjects e.g. object oriented vs. functional or Node.js vs. Java. Even though there are obvious differences between paradigms and programming ecosystems there are some common conventions and ways to lower the barrier. Different approaches It's natural that in programming things happen sequentally e.g. you can have a list of objects and you need to do various things to the list like filter some values out and count a sum of the remaining objects based on some property. With the given list const stories = [   {name: "authentication", points: 43},   {name: "profile page", points: 11},   {name: "shopping cart", points: 24},   {name: "shopping history", points: 15},   {name: &qu

Simple code: Naming things

There are two hard things in programming and naming is one them. If you don't believe me ask Martin Fowler https://www.martinfowler.com/bliki/TwoHardThings.html . In this post I'll be covering some general conventions for naming things to improve readability and understandabilty of the code. There are lots of things that need a name in programming. Starting from higher abstractions to lower we need to name a project, API or library, we probably need to name the source code repository, when we get to the code we need to name our modules or packages, we give names to classes, objects, interfaces and in those we name our functions or methods and within those we name our variables. Overall a lot of things to name. TLDR; Basic rule There's a single basic convention to follow to achiveve better, more descriptive naming of things. Give it a meaningful name i.e. don't use shorthands like gen or single letter variables like a, x, z instead tell what it represents, what it does

Simple code: Simplicity

Simplest solutions are usually the best solutions. We as software developers work with hard problems and solve a lot of small problems every day. Solving a hard problem itself is a hard job. Though in my opinion it's not enough to solve a hard problem in any possible way but a hard problem should be solved with a simple solution. When a developer comes up with a simple solution to a hard problem then they can declare the problem solved. First a disclaimer. Coming up with a simple solution to a hard problems is itself a very hard problem and takes a lot of time, effort and practice. I've seen my share of "clever" solutions for hard problems and the problem with those is that usually the solution itself is so hard to understand that depending on the size of the problem it may take a developer from hours to days or even weeks to understand how that "clever" solution works. It's a rare occasion when a developer has come up with a simple solution to a hard pr