Presentation about Connascence.

1. Connascence
Viernes técnico 25/11/2016

2. Definición lingüística

3. Definición técnica
Connascence ⇝ Acoplamiento
Conjunto de patrones, “métricas” para poder razonar mejor cómo de acoplado está tu
código (no sólo hablar en base a “sensaciones”).
Ofrece un vocabulario común para hablar sobre los diferentes tipos de acoplamiento.
Dos entes son “connascents” cuando deben cambiar de manera conjunta para que el
sistema siga siendo válido: Si A cambia, entonces B debe cambiar.

4. Tipos de connascence
● Estático
○ CoN: de nombre
○ CoT: de tipo
○ CoM / CoC: de significado o convención
○ CoP: de posición
○ CoA: de algoritmo
● Dinámico
○ CoE: de ejecución
○ CoT: de tiempos
○ CoV: de valores
○ CoI: de identidad

5. Properties
● Strength
● Locality
● Degree

6. Static Connascence

7. Connascence of Name (CoN)
Multiple components must agree on the name of an entity.
Method names are an example of this form of connascence: if the name of a method changes, callers of that
method must be changed to use the new name.

8. Connascence of Type (CoT)
Connascence of type is when multiple components must agree on the type of an entity.
Static languages: the compiler does your job.
Dynamic languages: you’re f** up

9. Connascence of Meaning (CoM)
Connascence of meaning is when multiple components must agree on the interpretation of data values.
Basically: magic number, magic strings, null/None, booleans, etc.
Solution: use of constants, Enums, etc.

10. Connascence of Position (CoP)
Connascence of position is when multiple entities must agree on the order of values.
Example 1: positional parameters in functions/methods
Solution: named parameters or an object

11. Connascence of Position (II)
Example 2: returning tuples or lists
Solution: object or dictionary/map

12. Connascence of Algorithm (CoA)
Connascence of algorithm is when multiple components must agree on a particular algorithm (on how to
process something).
● Transmisión de datos
○ Emisor y receptor deben consensuarlo
● Validaciones
○ Validación del email (JS, Controller, Model): en varios sitios, ¿de varias maneras?
● Codificaciones/Encriptaciones
● Algoritmos de compresión
● Testing:
○ Bad smell: verificar que un algoritmo funciona según lo esperado (se duplica en el test)

13. Dynamic Connascence

14. Connascence of Execution (CoE)
The order of execution of multiple components is important.
Example:
● objects encapsulating state machine

15. Connascence of Time (CoT)
The timing of the execution of multiple components is important.
Examples:
● Multithreading
● race conditions

16. Connascence of Time (II)
Java 1.5: AtomicInteger, e.g. para contadores accedidos por varios threads
(lectura + escritura no separada)

17. Connascence of Value (CoV)
Several values must change together (a.k.a the values of two components are related).
It’s a runtime problem.
Ejemplo: http://connascence.io/value.html

18. Connascence of Value (CoV)

19. Connascence of Identity (CoI)
Two components must reference the same entity/object.
Ejemplo en nuestros tests: mismo repo para leer y escribir.

20. Properties / Axes of Connescence

21. Properties
● Strength
● Locality
● Degree

22. Axe: Strength
The strength of a form of connascence is determined by the ease with which that type of coupling can be
refactored.
Stronger connascences are harder to discover or harder to refactor.
For example, connascence of name is a weak form of connascence because renaming entities across a codebase
is usually reasonably trivial. However, connascence of meaning is considered a stronger form of connascence
since semantic meaning is harder to find across an entire codebase.
Static connascences are considered to be weaker than dynamic connascences, since static connascences can be
determined simply by examining the source code.

23. Axe: Locality
The locality of an instance of connascence is how close the two entities are to each other.
Code that is close together (in the same module, class, or function) should typically have more, and higher
forms of connascence than code that is far apart (in separate modules, or even codebases).

24. Axe: Degree
An entity which is connascent with thousands of other entities is likely to be a larger issue than one is
connascent with only a few.
Connascence might be acceptable in limited degree but unacceptable in large degree.

25. Recursos
● https://en.wikipedia.org/wiki/Connascence_(computer_programming)
● http://connascence.io/
● Connascence en Python: https://www.youtube.com/watch?v=iwADIlIgDNA
● Connascence Examined: https://www.youtube.com/watch?v=HQXVKHoUQxY
● How to measure coupling: https://www.youtube.com/watch?v=L727roWRfFg