Part II - Code Quality

Question 1

What is code maintainability?

Answer 1

Defined as a degree of effectiveness and efficiency a codebase can be maintained over time

Sub-characteristics:
- modularity
- reusability
- analysability
- modifiability
- testability

Question 2

What are dimensions of clean code?

Answer 2

Readable
Focused (does one thing well)
Efficient (reliable, fast)
Expressive (meaningful names)

Question 3

What is meant by meaningful names?

Answer 3

Avoid Disinformation -> e.g. don’t refer to something as a list if it is not a list

Make meaningful differences -> don’t use two terms that mean the same thing

Use pronounceable names

Use searchable names

Avoid encodings -> do not encode the type of the variable into the name e.g. phoneString

Be consistent -> pick one word per concept

Solution Domain Names vs Problem Domain Names -> pick words based on who will be reading your code

Classes/Objects -> Nouns
Methods -> verbs
Booleans -> is_____

Question 4

What is meant by polite code?

Answer 4

Abstract the details into functions/methods

Stepdown rule

Question 5

What are features of well written functions?

Answer 5

Small
Do one thing
One level of abstraction

Question 6

What are code smells?

Answer 6

Symptom of a problem in the code
Smells do not always indicate problems

Question 7

What are the different types of code smells?

Answer 7

Bloaters
Abusers
Couplers
Preventers
Dispensables
Others

Question 8

What are bloaters?

Answer 8

Long method
Large class
Long parameter list
Data clumps -> multiple method calls take same set of parameters
Primitive obsession -> use of primitives (e.g. String, int) instead of small objects)

Question 9

What are abusers?

Answer 9

Code smells that violate object-orientation principles

Alternative classes with different interfaces
Temporary field
Switch statements -> complex switch statements should be avoided
Refused bequest -> subclass does not want or need behaviour from base class (wrong class hierarchy)

Question 10

What are couplers?

Answer 10

Message changes (e.g. a().b().c().d())
Feature envy -> method uses many attributes of another class
Middle man -> class or method only delegates to another class (adds overhead with no value)

Question 11

What are dispensables?

Answer 11

Lazy class
Data class
Duplicated code -> similar blocks of code (do not repeat yourself!)

Question 12

What are preventers?

Answer 12

Code smells that prevent change

Divergent change
Shotgun surgery
Parallel inheritance hierarchies

Question 13

What is code refactoring?

Answer 13

Changing a software system in such a way that it does not alter external behavior yet improves internal structure

Code refactoring requires a set of well made tests!

Question 14

What is technical debt?

Answer 14

A design or implementation construct that is expedient in the short term, but sets up a technical context that can make a future change more costly or impossible

Question 15

What is the TDD process?

Answer 15

Ensure all tests are passing after code refactoring

Refactor -> RED -> GREEN -> Refactor

Question 16

What are refactoring techniques?

Answer 16

Composing methods -> extract method

Moving between objects -> move method, extract class, remove class

Organising data -> replace data value with object

Simplifying conditional expressions -> replace conditional with polymorphism

Simplifying method calls -> introduce parameter object, rename method

Dealing with generalisation -> extra subclass

Question 17

What is code readability?

Answer 17

Clearly conveys intent
Easy to understand

Question 18

What makes code more readable?

Answer 18

Clean code is readable (avoid code smells)
Refactoring improves readability
Comments - well made ones that add value make code more readable

**Comments can be code smells if they add no value

Question 19

What causes comments to be a code smell?

Answer 19

Add clutter
Misinformation (outdated or incorrect)
Add to maintenance overhead

Question 20

What do good comments do?

Answer 20

Give legal information (copyright notices, license information)

Reveals intent - explain why not what

Clarifications, design rationale, workarounds

Basically - anything that cannot be said by writing better code

Question 21

What are java code conventions?

Answer 21

Braces are used where optional

Naming conventions

No wildcard imports

One class per file

Use grouping brackets when optional

Declare variables close to where they are used

Dependent methods next to each other (people read from top to bottom)

Question 22

What is a metric and a construct?

Answer 22

Construct -> cannot be directly observed or measured

Metric -> can be directly measured

We correlate metrics with a construct

Question 23

What are the uses of LOC?

Answer 23

Measure productivity/developer performance

Estimate effort/time/cost

Question 23

What is a size metric for code?

Answer 23

Lines of code

Question 24

What is comment density?

Answer 24

LOC can be split into non-commented LOC and commented LOC

Comment density = CLOC / LOC

Question 24

What are the limitations of LOC?

Answer 24

Have to define what counts as a line of code - blank lines, comments, closing branches, auto-generated code?

Programming language differences - java vs python

Noise in code e.g. duplicate code

based on how you define this estimations of effort time and cost can be incorrect

Question 25

What are examples of noise in LOC?

Answer 25

C/P - copy and pasted code
Comment
Moved
Language keywords - {,},else

All add to LOC but do not mean more effort, time and cost was required

Question 26

What is a flowgraph?

Answer 26

A visual representation of code logic

• vertices are statements (lines of code that are executed)
• edges show potential flow between different lines of code

Question 26

What does code complexity mean?

Answer 26

More complex code is harder to maintain, reduces productivity

Adds risks (bugs could be added by mistake)

Question 26

What are complexity metrics?

Answer 26

Number of Linearly Independent Paths (NLIP)

Halstead’s Measure

Cognitive Complexity

Question 27

What is NLIP?

Answer 27

A path starts at enter and follows edges until exit is reached

A set of paths are linearly independent if none of them can be created by combining others in some way

Question 27

How do you calculate NLIP?

Answer 27

Using flowgraph

e - n + 2
e = number of edges
v = number of vertices

NLIP = d + l
d = number of decision vertices (a cond. statement in the code such as if or while)

Question 27

What does NLIP tell you?

Answer 27

The large the number of paths, the more complex the code

Lower NLIP is better (can be achieved by breaking up large, complex methods)

Question 28

What are limitations?

Answer 28

Two pieces of code can have the same NLIP but different amount of complexity

Question 29

What are modularity metrics?

Answer 29

Coupling
Cohesion

Question 30

What is modularity?

Answer 30

The concept in which software should be broken in to modules

Information hiding principle:
- modules should expose only stable interfaces
- hide anything that is likely to change
- change in one module should not affect another module

Allows modules to be developed independently and in parallel

Question 31

What is coupling?

Answer 31

Considers the number of dependencies between modules
- higher coupling = many dependencies between modules

Question 32

What is cohesion?

Answer 32

Considers the number of dependencies within a module
- higher cohesion means elements within a module are related