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
Lets take a example of a function that has identical behaviour but differing signatures.
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.
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.
In the next part I'll be writing about contracts and how they're related to code.