# Clean Code - 8 Boundaries
When
- Buy 3rd party packages
- Use open source
- Use components or subsystems that are created by other teams

## Using Third-Party Code
- Provider interface (3rd party packages or frameworks)
- Broad applicability for various environments and users
- User interface
- Focus on the features they need

**It will cause boundary problems in the system**


### Solution: use interfaces
> This interface is also tailored and constrained to meet the needs of the application. It results in code that is easier to understand and harder to misuse.

### Example: TypeScript Dictionary
Multiple methods can be used when using TypeScript Dictionary like:
- Add
- Update
- Remove

Using dictionary directly leads to boundary problems:

// a shared instance RoomFactory
class RoomFactory {

    public roomKeys = {
      'storage': 'storage_abc',
      'kitchen': 'kitchen_123',
      'livingroom': 'livingroom_010',
      'bathroom' : 'bathroom_456',
      'doghouse' : 'doghouse_def',
    }
}

const roomFactory = new RoomFactory();


// everyone has access to all keys
// since the return value can be:
// roomFactory.roomKeys.kitchen
// roomFactory.roomKeys.livingroom
// ...
function getRoomKey(): string {
    return roomFactory.roomKeys.storage;
    
}
console.log(getRoomKey());

Proper usage:

// a shared instance RoomFactory
class RoomFactory {

    private roomKeys = {
      'storage': 'storage_abc',
      'kitchen': 'kitchen_123',
      'livingroom': 'livingroom_010',
      'bathroom' : 'bathroom_456',
      'doghouse' : 'doghouse_def',
    }
    
    public get guestRoomKey(): string {
        return this.roomKeys.livingroom;
    }
}

const roomFactory = new RoomFactory();


// the user only has certain permissions
function getRoomKey(): string {
    return roomFactory.guestRoomKey;
}
console.log(getRoomKey());

## Exploring and Learning Boundaries
It is good to write some tests to test the 3rd party codes that we use

### Learning tests
> Could write some tests to explore our understanding of the third-party code. - Jim Newkirk

#### Other resources:
https://blog.thecodewhisperer.com/permalink/when-to-write-learning-tests
https://www.frederikbanke.com/linkedin-api-learning-tests/

## Learning log4j
Skip

## Learning Tests Are Better Than Free
- Why
- Have a better understanding of what we are using
- When
- Writing learning tests when there is a new release of the 3rd party package
- What
- To address the risks and incompatibilities

### Boundary tests
Though might not always write learning tests, should always have boundary tests for migration when the version of the 3rd package change.

## Using Code That Does Not Yet Exist
> There is another kind of boundary, one that separates the known from the unknown.


### Define our own interface
> 
> This design also gives us a very convenient seam in the code for testing. Using a suitable FakeTransmitter, we can test the CommunicationsController classes. We can also create boundary tests once we have the TransmitterAPI that make sure we are using the API correctly.

- Precondition: the real API `Communication Controller` is not ready yet
- `Trasmitter` is an interface that we wish to have
- The method `transmit` in `Trasmitter` will receive the input from the real API, and provide output to others that use `Trasmitter`
- `TransmitterAdapter` is to bridge the gap between the real API `Communication Controller` and our interface `Trasmitter`

### How `FakeTransmitter` work?
???

### Adapter Pattern
Source
https://refactoring.guru/design-patterns/book


## Clean Boundaries
> “The only thing that never changes is that everything changes.”
>
> ― Louis L'Amour

Same as boundaries. The goal is to be able to adapt to the changes without high costs such as time to rework. A good practice is to rely on what you can control, such as the interface that you design and wish to have, instead of depending on the 3rd party API, which you don't have full control of.

### Methods of managing third-party boundaries
- Wrap them up for proper access and control the usage
- Use an Adapter for communications between interfaces

###### tags: `learn` `clean code` `test automation`