DEV Community: Arthur Vincent Simon

How to work on side projects when you are mentally fatigued?

Arthur Vincent Simon — Sat, 07 Mar 2020 09:36:49 +0000

I have been thinking of starting side projects since I see some benefits of doing it.

Helps keep off the drudgery and boredom at work. Not that my work is boring, but doing the same things for a period will eventually wear you down.
Personal development and fulfillment. You have the freedom to choose what to work on. Things that are fun and you care about.
Personal Branding. Doing side projects shows that you can manage projects and your time enough to be able to deliver. It also signals that you do the walk, not just talk.

However, the biggest problem that I encounter is fatigue. I love coding and I try to give me 100% at work. This leads me to being mentally drained after work. I usually don't have the mental energy to tackle somme hard coding problems after that.

Another problem is that there are some equally important things competing for my time. Whether it is socializing or exercise, it gets pretty hard trying to fit in time to do side projects.

So how do you guys do it? How do you get the energy and time to do side projects when you are mentally fatigued.

How to test exceptions in Jest

Arthur Vincent Simon — Sat, 07 Mar 2020 04:21:24 +0000

How to use Jest .toThrow()

I initially thought that I could do this to unit test for errors

expect(doSomething()).toThrow()

Unfortunately, this doesn’t work. We need to wrap doSomething in another function in order for this to work

expect(() => doSomething()).toThrow()

//or

expect(function() { doSomething() }).toThrow()

Typescript Utility Types

Arthur Vincent Simon — Sat, 07 Mar 2020 04:05:08 +0000

Introduction

As I was starting to get serious in learning Typescript, I came across a set of utility types the proved useful when I tried to refactor the types in the codebase of the company that we are in.

Before that point, I assumed that for reusing types code, I have to make granular types and export them to each type that need them in their fields.

For example, if I have a Person type that I am using in a Parent type or a Child type, I have to create it, export it out and use it. Of course this is just a simple example. When we get to having a lot of type sharing across the components, then we can see how it can become unwieldy to import the type every time we try to use that type.

Enter the utility types. These utilities aim to remove the problem of the redundantly defining and importing each functions. I want to go over some of them that I find useful.

Utilities

Pick

When we want to reuse or “pick” out some properties inside a type, we would us Pick. Very useful as it saves me time having to create new types just to copy the properties of existing types.

interface Workstation {
    CPU: string
    GPU: string
    RAM: string
    monitor: string
    keyboard: monitor
}

type Computer = Pick<Workstation, 'CPU' | 'GPU' | 'RAM'>

Partial

When we want to make the properties of a certain type optional, we use Partial. Useful when refactoring.

interface Car {
    wheels: string
    windshield: string
    body: string
    doors: string
}

type Car2 = Partial<Car>

Required

On the other hand, if we want to make the properties of a certain type to be required, we use Required. Useful to force your types based on external library types.

interface OptionalParams {
    a?: string
    b?: string
}

type RequiredParams = Required<OptionalParams>

Record

Very useful when constructing types for configurations.

interface Person {
    name: string
}

type Family = ‘father’ | ‘mother’ | ‘sibling’

const myFamily: <Family, Person> = {
    father: { name: ‘John’ },
    mother: { name: ‘Jane’ },
    sibling: { name: ‘Joe’ }
}

Omit

Very useful to get a cut down version of a type

interface Article {
    title: string;
    summary: string;
      text: string;

}

type ArticlePreview = Omit<Article, text>;

const todo: ArticlePreview = {
    title: ‘The misadventures of Joe’,
    summary: ‘Joe goes out of his way to explore. Will he survive?’
};

Exclude

Basically a “complement” of two sets

type Toys = Exclude<“knife” | “ball” | “xylophone”, “knife”>;  // “ball” | “xylophone”

Extract

Basically an “intersection” of two sets

type Vehicle = Extract<“skateboard” | “car” | “motorbike”, “car” | “motorbike” | “wheelchair”>;  // “car” | “motorbike”

Conclusion

In my continuous improvement of learning Typescript and trying to incorporate it to my code, I found using these utility types more. As long as I don’t go overboard with them, it helps make my code more concise and understandable. I hope you guys find them useful too.