Implementation best practices

Question 1

What is implementation?

Answer 1

Implementation:
- Writing the source code that is needed
to realize the architecture and design
- Comes with its own set of challenges

Question 2

How to manage the implementation process

Answer 2

Version management (e.g., Git)
- Coordinate development progress
- Code changes become easily reversible
Build system (e.g., Ant)
- Automate the process of assembling the
system from its sources
Issue tracking (e.g., GitHub Issues)
- Keep track of bug reports and requests for
new system features

Question 3

What is the key implementation concepts?

Answer 3

• Understandability: A universally valid code quality measure
  Keep in mind:
  Code is read by humans!
• Code describes what a computer should do
• Yet it is still mainly read by people
• Thus it should be written with people in mind
• Testability
• Reusability
• Efficiency

Question 4

Name the understandability tips!

Answer 4

1. Use meaningful identifier names!
2. Add comments that complement the code!
   Comments explain “why” not “what”:
   - Code explains what is being done
   - Useless comments repeat what is being
   done, e.g.:
3. Follow a coding style convention!

Question 5

What is the NASA JPL coding standard for
Java?

Answer 5

Purpose:
- To help Java programmers reduce the
probability of run-time errors
- To improve readability and maintainability
of code
Contents:
- 53 rules
- Programming patterns to avoid
- Processes that are useful
- Treat as “guidelines
Process rules:
- R01: Compile with checks turned on
- R02: Apply static analysis (e.g.,
http://findbugs.cs.umd.edu/eclipse/)
- R03: Document public elements
- R04: Write unit tests
Process rules:
- R05: Use the standard naming convention
- http://www.oracle.com/technetwork/java/c
odeconventions-135099.html
- R06: Do not override field or class names
- “Hiding an entity with an entity of the
same name may lead to mistaken
assumptions about the entity being
referred to”
Field rules:
- R17: Make fields private
- R18: Do not use static mutable fields
- R19: Declare immutable fields final
- R20: Initialize fields before use

Question 6

What is a design anti-pattern?

Answer 6

Anti-patterns/“code smells”:
- Are the opposite of a design
pattern
- Identify poor solutions to
recurring design problems
- Are symptoms of poor design
choices

The Code Duplication anti-pattern
Problem description:
- Useful pieces of code are
copy-pasted throughout the
codebase
Solution description:
- Use an abstraction technique
(e.g., method, inheritance) to
refactor the code

Question 7

What is the The Schizophrenic Class
anti-pattern?

Answer 7

Problem description:
- A class that contains disjoint sets of public
methods that are used by disjoint sets of
client classes
Solution description:
- Refactor each set of methods into
individual classes

Question 8

What is the The Blob anti-pattern?

Answer 8

Problem description:
- A large class that is
lacking cohesion or
makes most of the
processing decisions
Solution description:
- Refactor Blob classes
into a series of more
cohesive classes

Question 9

What is the The Data Clump anti-pattern?

Answer 9

Problem description:
- Large group of parameters appear
together in the signature of many
operations
Solution description:
- Introduce a new class that encapsulates
the parameter group to simplify the
operations with the data clump

Question 10

What is the The Feature Envy anti-pattern?

Answer 10

Problem description:
- A method that manipulates
the data of other classes
more than its own data
Solution description:
- Method was likely misplaced
- Move to class whose data is
manipulated

Question 11

The Tradition Breaker anti-pattern

Answer 11

Problem description:
- A class breaks the API inherited from its
superclass by either overriding an inherited
method with an empty method or reducing
the visibility of a method
Solution description:
- Inheritance structure is flawed and needs
to be fixed, because subclass does not
properly substitute its superclass

Question 12

What do you need to keep in mind for testability?

Answer 12

More execution paths, more tests!
- The complexity of a method determines
how many tests are required
- More complex methods require more tests

Question 13

What are the testability tips?

Answer 13

• Follow Test-Driven Development (TDD):
  Strict TDD approach:
• New code may only be written in order to
  make a failing test case pass
• Hence, tests must exist before the code
  can be written
• Tests must be written and shown to fail
  before code can be added

Test early and test often
Invest effort in testing:
- As code is updated to add new features or
fix bugs, tests should be kept in sync
- If following strict TDD, tests should be
updated first!
Rely on your safety net!
- Get in the habit of executing tests often

Question 14

What advantages does reusibility have?

Answer 14

Code reuse simplifies maintenance:
- Bugs only need to be fixed in one common
location
Code reuse accelerates development
- Less time is spent “reinventing the wheel”

ex:
Program libraries
* Application frameworks
* Architectural patterns
* Service-oriented systems
* Design patterns
* Model-driven engineering
* Program generators

Question 15

What are the reusability tips?

Answer 15

Apply design patterns!
Why design patterns:
- Design patterns increase code reuse by
using common abstraction techniques

Follow the DRY principle!
Don’t Repeat Yourself (DRY):
- As much as possible, avoid repeating
yourself when writing code
- Instead, use abstractions (methods,
classes) to reuse solutions rather than
repeating them

Using generics
What is a generic?
- A programming construct to allow types to
vary, while code structure stays constant
- Allows the Java compiler to check for
errors that would usually leak through to
run-time

Question 16

When can programming errors appear?

Answer 16

Compile-time:
- Programming errors that an analysis of the
code can reveal
- For example, missing semi-colon
Run-time:
- Mistakes with program logic that are
discovered after the program is launched
- For example, dividing by zero

Generics help us to catch bugs at
compile time

public class Box {
private Object object;
public void set(Object object) {
this.object = object;
}
public Object get() {
return object;
}
}
vs
public class Box<T> {
private T t;
public void set(T t) {
this.t = t;
}
public T get() {
return t;
}
}</T>

Question 17

What are the naming conventions for type parameter?

Answer 17

E—Element
- Used extensively by the Java Collections
Framework
K—Key
N—Number
T—Type
V—Value

Question 18

What are the bounds of generics?

Answer 18

Generic types cannot be instantiated with
primitive types
- Box<int> // not allowed
- Box<Integer> // allowed
Instances of type parameters cannot be
created:
- E elem = new E(); // not allowed</Integer></int>

Static fields cannot be declared of the
type of a type parameters
public class Box<T> {
private static T t; //not allowed
…
}</T>

Arrays of parameterized types cannot be
created
Box<Integer>[] boxes =
new Box<Integer>[2]; // not allowed</Integer></Integer>

Question 19

What are the efficiency tips?

Answer 19

1. Avoid recursion where possible!!!