Consider the following function signatures from master.cpp:
Nothing Master::removeSlave(const Registry::Slave& slave);
void Master::removeSlave(Slave* slave, const string& message,
Option<Counter> reason);
or these from sorter/drf/sorter.hpp:
void update(const SlaveID& slaveId, const Resources& resources);
void update(
const std::string& name,
const SlaveID& slaveId,
const Resources& oldAllocation,
const Resources& newAllocation);
void update(const std::string& name);
void update(const std::string& name, double weight);
These function names use overloading but the different variants have
*completely* different semantics. For example, the variants of
update() do the following:
(1) Set the weight associated with a role.
(2) Change the total pool of resources in the sorter.
(3) Update the fair-share associated with a sorter client.
(4) Change both the total and allocated resources in the sorter.
(For fun, the descriptions and function names are in different orders. :) )
I'd like to propose that we avoid naming functions in this style: if
two functions do fundamentally different things or should be invoked
in very different circumstances, we should avoid giving them the same
name. We should use overloading when two variants of a function do
basically the same thing but differ slightly in the parameters they
accept.
Comments welcome.
Neil
