Nothing new
book from 1995
More resources
- Talk "Gran unified theory of sofware development" by Jim Weirich (https://vimeo.com/10837903)
- Kevin Rutherford Articles (https://silkandspinach.net/tag/connascence/)
- Connascence.io
How we take design decissions?
- OO patterns?
- SOLID principles?
- 4 rules of simple design?
- Code smells?
- OO basic principles?
Cohesion
Degree to which the elements of a module belong together.
Kent Beck
“Cohesion of an element A is defined as "if I change subelement A.1, do I have to change all the other subelements A.2-n?". So, cohesion is coupling within an element”
Coupling
Degree of interdependence between software modules.
Kent Beck
“Coupling between A and B is defined as "if I change element A I also have to change element B"”
Connascence
Connascence between 2 software components A and B means either
That you can postulate some change to A that would require B to be changed (or at least carefully checked) in order to preserve overall correcteness, or
That you can postulate some change that would require both A and B to be changed together in order to preserve overall correcteness.
A more simple definition
Connasnence is a vocabulary to talk about coupling
Three separate axes
- Degree
- Locality
- Strenght
Degree
Number of elements affected by the connascence
Locality
-
In the same function?
-
in the same class?
-
in the same package/namespace?
-
in the same bounded context?
-
in the same application?
Connascence of name
public class Test {
...
var ob1 = new Ob1();
ob1.doSomething();
...
}
public class Ob1 {
public void doSomething(){ //code }
}
Connascence of name
public class User {
public string Name { get; set; }
}
...
var user = connection.Query<User>("select name from users where id=1");
...
Console.WriteLine("Username is: " + user.name);
Connascence of Type
when multiple components must agree on the type of an entity
public class Credentials {
...
}
public class LoginService {
public bool login(Credentials credentials) {
...
}
}
loginService.login(new Credentials(...));
Connascence of Type
In dynamically typed langauages can be more dangerous
def calculate_age(birth_day, birth_month, birth_year):
...
// How call this method?
calculate_age(1, 9, 1984)
calculate_age(1, 9, 84)
calculate_age('1', '9', '1984')
calculate_age('1', 'September', '1984')
Connascence Meaning
when multiple components must agree on the meaning of particular values
// Java comparable
a.compareTo(b)
// return 0 if are equal
// return positive number if a > b
// return negative number if b > a
Connascence Meaning
public User getUser(string userId) { ... }
User user = obj.getUser("id");
if (user != null) {
// do something
}
// refactor to convert from CoMeaning to CoType
public Maybe<User> getUser(string userId) { ... }
Maybe<User> user = obj.getUser("id");
if (user.exits()) {
// do something
}
Connascence of Algorithm
// when the server receives the book request
public class BookTaxi {
public void Book(Date reservationDate,...) {
if (!isInTheNextFiveDays(date)) {
return throw BookException(...)
}
}
}
// in client code, js for example
function BookTaxi(date,...) {
if (!isInTheNextFiveDays(date)) {
// show a message to the user
}
}
when multiple components must agree on a particular algorithm
Connascence of Algorithm
def write_data_to_cache(data_string):
with open('/path/to/cache', 'wb') as cache_file:
cache_file.write(data_string.encode('utf8'))
def read_data_from_cache():
with open('/path/to/cache', 'rb') as cache_file:
return cache_file.read().decode('utf8')
// using a object that encapsulates the encoding/decoding algorithm
def write_data_to_cache(data_string):
with open('/path/to/cache', 'wb') as cache_file:
cache_file.write(self.Algorithm.encode(data_string)
def read_data_from_cache(codificationAlgorithm):
with open('/path/to/cache', 'rb') as cache_file:
return self.Algorithm.decode(cache_file.read())
Connascence of Position
// connascence of position
function serverCall(url, method, data, okCallback, errorCallback) {
....
}
serverCall("/endpoint", "post", {foo: 'foo'}, ()=> {
// do something
}, ()=> {
// handle error
});
when multiple entities must agree on the order of values.
Connascence of Position
// CoP -> CoN
function serverCall({url, method, data, ok, error})
serverCall({
url: '/endpoint',
method: 'post',
data: {foo: 'foo'},
ok: ()=>{// do somehting},
error: ()=>{// handle error}
});
Connascence of Position
def calculateImageSize(url):
width = ...
height = ...
return (width, height)
(width, height) = calculateImageSize('/url/img.png')
print(width)
ImageSize = namedtuple('ImageSize', 'width height')
def calculateImageSize(url):
width = ...
height = ...
return ImageSize(width, height)
imageSize = calculateImageSize('/url/img.png')
print(imageSize.width)
Connascence of Position
>>> calculateImageSize('...')
(320, 560)
>>> calculateImageSize('...')
ImageSize(width=320, height=560)
VS
ImageSize(width=320, height=560)
¿What is the meaning of "320"?, ¿pixels?, ¿centimeters?
Connascence of meaning!
ImageSize(
width=320,
height=560,
unit=pixels
)
An example of Primitive Obsession, a good solution can be a ValueObject
Connascence of Execution
Configurator configurator = new Configurator();
configurator.setModel("Ferrari F40");
List<Equipments> availableEquipments = configurator.getEquipmentsResultSet();
// refactor to reduce from CoExecution to CoType
Configurator configurator = new Configurator();
Model model = configurator.getModel("Ferrari F40");
List<Equipments> availableEquipments = model.getEquipmentsResultSet();
when the order of execution of multiple components is important.
Connascence of Execution
The general workflow is something like this
- Instanciate a Configurator object
- Set the required attributes by calling the set methods e.g. setModel(String)
- Call one of the get methods e.g. getEquipmentResultSet().
- Iterate over the returned result ...
Coupled with documentation!
from javadoc:
Connascence of Execution
RepositoryItemReader<Vehicle> reader = new RepositoryItemReader();
reader.setRepository(vehicleRepository);
reader.setMethodName("findAll");
...
reader.read();
API spring batch
RepositoryItemReader<Vehicle> reader = new RepositoryItemReader(
vehicleRepository, "findAll"
);
reader.read();
Removing CoE
Connascence of Timing
// using bootstrap modal
$(element).modal('hide')
$(element).modal('show') // Error!
// hiding a modal has an animation of aprox 500ms, if you call 'show' during
// this animation the component breaks in unexpected ways
// we need to do something like this
$(element).modal('hide')
$(element).on('hidden.bs.modal', () => {
$(element).modal('show') // ok
})
when the timing of the execution of multiple components is important
https://github.com/twbs/bootstrap/issues/3902
Connascence of Value
when several values must change together.
[Test]
public void total_price_for_scaned_products_with_discount() {
var productScanner = new ProductScanner();
productScanner.Scan("productA");
productScanner.Scan("productB");
productScanner.Total.Should().Be(150);
}
class ProductScanner {
public int Total {get; private set;}
public void Scan(String productName) {
Total += priceFor[productName];
}
private int priceFor(string productName) {
// go to persistence and get the product price
}
}
Test need to know about a value in the database
private readonly HashMap<string, int> product_prices = new HashMap<string, int> {
{"productA", 100},{"productB", 50}
}
[Test]
public void total_price_for_scaned_products_with_discount() {
var productScanner = new ProductScanner(product_prices);
productScanner.Scan("productA");
productScanner.Scan("productB");
productScanner.Total.Should().Be(150);
}
class ProductScanner {
private readonly HashMap<string, int> product_prices;
public ProductScanner(HashMap<string,int> product_prices) {
this.product_prices = product_prices;
}
public int Total {get; private set;}
public void Scan(String productName) {
Total += product_prices[productName];
}
}
Reduce locality
productScanner.Total.Should()
.Be(product_prices["productA"] + product_prices["productB"]);
We can eliminate CoV with this change:
productScanner.Total.Should().Be(150);
instead of:
Now we have CoAlgorithm, less connascence strength
but... is really a best solution?
Connascence of Identity
when multiple components must reference the same entity
Connascence of Identity
const eventBus = EventBus();
const mainComponent = MainComponent(eventBus);
const component1 = Component1(eventBus)
const component2 = Component2(eventBus)
const component3 = Component3(eventBus)
Connascence
By Alfredo Casado
Connascence
- 2,879