## What is KISS and What Does it Stand For?

"Keep It Simple, Stupid!" is a design principle which is very commonly referred to in software development, but is applicable to pretty much any system or process in any industry.

## What Does the KISS Principle Try to Achieve?

Once you know what it stands for, KISS becomes almost self-explanatory: it's often better to try and keep things simple. In principle, simpler systems work better than overly complex ones due to the massively increased scope for error in complicated systems.

It sounds kind of obvious, but you should try to avoid _unnecessary_ code complexity where possible and aim to design with simplicity in mind. I highlight the word "unnecessary" because you're never going to be able to avoid _all_ complexity, but you should try not to over-complicate things where possible.

## How Can I Keep Things Simple?

### Break It Down

Being able to break down your problems into smaller and smaller ones is one of the best ways to simplify your code. Have you ever seen a function like this?

```js
const doSomethingAndThenSomethingElse = () => { ... }
```

The "And" in the name of that function is an immediate red flag that it's got too much responsibility and needs to be broken down further. The aim is to write smaller classes and functions which only solve _one single problem_. If you have a lot of conditions in your function, break these out into smaller functions.

### Don't Solve Problems You Don't Have

It can be tempting to go overboard and try to future-proof your code to the fullest extent, catering for all future eventualities and possibilities. The problem with that is you will end up introducing complexity with no immediate value. It could result in issues coming to the surface which need complicated bug fixes, wasting time and energy on something you didn't need in the first place. This is actually a principle in itself: YAGNI (You Ain't Gonna Need It) which compliments the KISS principle rather well.

## What Are the Benefits of Keeping Things Simple?

### Speed and Flexibility

I'm going to resort to the much-loved the LEGO analogy: when you manage to have your many classes and functions which all solve their individual problems it's like having lots of different LEGO bricks. You can stack them together quickly to create something new and easily switch out one brick for another to achieve different outcomes. This ultimately results in being able to solve new problems faster as well as diagnosing and fixing existing issues more efficiently.

### Maintainability

Furthering what I've talked about above, your code should also result in being more easily readable and understandable by anyone who is new to the codebase. That is a big advantage when thinking about maintainability; lowering that mental barrier to entry means it won't take long for other developers to figure out how best fix issues or extend the codebase to add new features.

### Code Quality

You should find that by focusing writing functions with a single purpose, you will in turn be able to pay more attention to how you can perform the required task in the most efficient and concise way possible to produce the best code for the job.

Testing becomes easier too! You should be able to write bullet-proof unit tests which make sure your functions do what you need them to in all situations. The test cases are always going to be simpler when your functions don't try to do too much.

### Scalability

Going back to the LEGO analogy, the theory is that you can keep adding bricks to scale up and up as much as you need. I realise the reality is never that simple, but it goes some way to helping avoid the issues scaling up more complex systems.

### KISS Can Be Subjective

Which of the following would you describe as "simplest"?

```ts
const getWeekday = (month: number) => {
    switch (month) {
        case 1:
            return "January";
        case 2:
            return "February";
        case 3:
            return "March";
        case 4:
            return "April";
        case 5:
            return "May";
        case 6:
            return "June";
        case 7:
            return "July";
        case 8:
            return "August";
        case 9:
            return "September";
        case 10:
            return "October";
        case 11:
            return "November";
        case 12:
            return "December";
        default:
            throw new Error("month must be in range 1 - 12");
    }
};
```

```ts
const getWeekday = (month: number) => {
    if (month < 1 || month > 7)
        throw new Error("month must be in range 1 - 12");

    return [
        "January",
        "February",
        "March",
        "April",
        "May",
        "June",
        "July",
        "August",
        "September",
        "October",
        "November",
        "December",
    ][month - 1];
};
```

Whichever one you prefer, you can bet it's not going to be the same for everyone! It doesn't necessarily matter and it's not something to get too caught up in, but it's something to be aware of.

## Closing Comments

One thing worth noting is that you may find that principles like KISS can conflict with other principles. For example, DRY (Don't Repeat Yourself) in its most basic over-simplified definition states that you should never duplicate code, however there will be times where a little bit of code duplication actually reduces complexity and saves you headaches in the future.

"Keep It Simple, Stupid!" is a design principle which encourages you to focus on simplicity and avoid unnecessary over-complication.

Explained: What is the KISS Principle?

Following on from [my previous post about the Brave web browser](/post/brave-brilliant-browser-and-the-future-of-online-advertising "Brave: Brilliant Browser and the Future of Online Ads"), I've now become a Brave Verified Creator!

## What Does This Mean?

If you use the [Brave](https://brave.com/ "Brave browser homepage") browser and are opted-in to Brave Rewards and Auto-Contributions it means I'll get a small portion of the [Basic Attention Tokens (BAT)](https://basicattentiontoken.org/ "Basic Attention Tokens homepage") you receive for viewing ads.

As I talked about in my previous post, it's a brilliant mechanism to allow creators like me to monetize their content really easily without forcing visitors to see horrible, intrusive on-page advertisements. If you're interested in supporting small content creators like me without it costing you a penny, you should definitely give Brave a try!

## What Am I Going to Do with All My New Found Riches?

The reality is that I don't stand to earn very much, if anything at all with the small number of visitors I bring to this site. But on the off chance I earn a few pennies it'll go towards covering the cost of renewing my domain purchase, so it makes keeping this website going that little bit cheaper for me.

## Content Creator? Consider Signing Up!

If you want to take advantage of Brave Rewards, you can do so completely free of charge! Here's an overview of what you need to do:

1. [Download Brave](https://brave.com/download/ "Brave browser download page")
1. Set Up Brave Rewards
    - Brave will guide you through this process
    - You can make changes via Brave's settings at any time
1. [Connect and verify your Brave Wallet](https://support.brave.com/hc/en-us/articles/360034841711-What-is-a-verified-wallet- "Brave support article about verified wallets") with [Uphold](https://uphold.com/ "Uphold homepage")
    - The wallet gets created alongside the Brave Rewards setup
1. [Sign up as a Brave Creator](https://creators.brave.com/ "Brave Creators homepage")
1. [Verify ownership of your content](https://support.brave.com/hc/en-us/articles/360021408352 "Brave support article describing the verification process")
    - If, like me, you use the "File Upload Verification" method, you can remove the file from the `.well-known/` folder once you've completed verification
    - You have to wait up to 24 hours for the verification to take effect

I would say the whole process can be done in about 15-20 mins...though that's a bit of a guess because I've not done a straight run-through before.

And that's it! You can continue to create the content you and your readers/viewers love and check back every now and then to see how much BAT you're earning by logging into your [Brave Rewards Creators](https://creators.brave.com/ "Brave Creators homepage") account.


I've signed up as a Brave Creator so I benefit from Brave's amazing new approach to monetizing content on the web. If you're a content creator, you should sign up too!

I'm now a Brave Verified Creator

I use [Brave](https://brave.com/ "Brave browser homepage") as my primary web browser on all my devices and I absolutely love it. I want to share my favourite features of Brave and explain how its re-imagination of online advertising is beneficial for everyone and could be the future for the web that we've all been hoping for.

## Chromium-Based Browser

[Chromium](https://www.chromium.org/Home "Chromium project homepage") is the foundation for a lot of web browsers these days, including [Google Chrome](https://www.google.co.uk/chrome/ "Google Chrome browser homepage") and [Microsoft Edge](https://microsoftedgewelcome.microsoft.com/en-gb/ "Microsoft Edge browser homepage"). It's a solid option for any browser to build upon and has all the developer tools I know and love using right out of the box.

It also means that you are able to install anything available in the [Chrome Web Store](https://chrome.google.com/webstore/category/extensions "Chrome Web Store homepage"), so you can add all your favourite browser extensions.

## Brave Shields

Brave does a lot to make sure you can browse the web as securely and privately as possible. It's enabled by default but you can turn Shields off on a site-by-site basis if you like. Here's what Brave Shields does for you:

### Ad Blocking

I would imagine most, if not all of us would agree that online advertisements are horrible, distracting and invasive annoyances on a large number of the sites we visit. They detract from the content we're trying to consume and ad platforms use trackers follow us around the web wherever we go. Brave does an excellent job of removing these ads to give you a faster, safer, more private and enjoyable browsing experience.

### Cookie Removal

Brave deletes cookies from the sites you don't actually visit. It makes a lot of sense to only keep the data you need for as long as you need it. If it's not useful anymore, brave will get rid of it!

### Tracking Protection

Brave says it protects you by making your browser harder to recognize and follow without cookies. The truth is that I'm not sure how it does this, but any effort to achieve privacy and anonymity whilst browsing the web is a win in my book!

### Secure Connections

Upgrading you to secure (HTTPS) connections where possible. Websites these days should do this for you anyway, but in case they don't it's good to know that Brave has got you covered.

### Malware Protection

Effective blocking of malicious sites and code is important. It's difficult to know which sites you can trust, so Brave will let you know if it thinks you should be wary.

Having said that, it's always good to keep an eye out for anything that looks or feels suspicious and not solely rely on blockers to protect you. My advice is always "If in doubt, get out".

## Brave Rewards

This is what makes Brave _really_ special.

As well as being a top-notch browser, Brave introduces a radical new concept for controlled, less invasive advertising on the web.

### Opt-In to Ads

As I've talked about before, Brave blocks all on-page advertisements by default. Instead, via Brave Rewards, you can opt-in to privacy-respecting ads which appear to you in the form of notifications. You can click on the notifications to view the ads, if it takes your fancy.

### Why Would You Choose to See Ads?

Brave feels strongly that you should be rewarded for your precious time and attention viewing advertisements, so they have give you [Basic Attention Tokens (BAT)](https://basicattentiontoken.org/ "Basic Attention Tokens homepage") for every ad you see.

BAT is a form of cryptocurrency; it has a real monetary value, so Brave are literally paying you to look at advertisements. This reward money is a portion of the income Brave, as an advertising platform, receives from advertisers.

### So Everyone's a Winner?

Nearly...

So far we've seen that the advertisers get their ads seen, Brave makes money from the advertisers and you make money from the advertisers via Brave. But what about content creators? The people who's articles and videos you've come to see, how are they affected by all this?

Creators who use traditional advertising methods on their website will lose out on income because we're blocking the ads on their platforms. "That's hardly fair!" I hear you cry...and Brave agrees. It's part of Brave's mission to help content creators earn their money without the use of these intrusive ads.

### Putting Your Rewards to Good Use

You can, of course, keep the BAT and save it up or cash it out, but the idea is that you use it to help give back to the people who fuel the content on the web.

#### Automatic Contributions

As you browse the web, Brave will keep track of the portion of your browsing time you're spending on each website. Each month you can tell Brave to distribute a portion of your BAT to all of the content creators of the sites you've visited that month. The creators will get a percentage of your allocated BAT based on the amount of time you've spent looking at their content. What an incredible way to effectively give back, for free!

Creators will need to sign up to be a [Brave Verified Creator](https://creators.brave.com/ "brave Creators homepage") in order to receive the rewards. The process is free and easy, so there's no reason not to!

#### Tips

If particularly love someone's blog post, video, etc., you can give a one off tip! It's a lovely way to say "thank you" if you really appreciate what someone's worked hard to create. You can even tip people for things like Tweets, StackOverflow answers and GitHub comments!

## Other Features

There are other awesome features of this browser like integration with third party crypto services, Tor browsing and a built-in VPN & Firewall (paid feature) but I won't go into detail on that here. You can [check out the full list of Brave features](https://brave.com/features/ "Brave browser's features page") for yourself.

## Roundup

So there you have it: a first-rate browser on a mission to make the web a better place by re-inventing online advertising, rewarding ad consumers and enabling creators to be compensated for their contribution to the web. That sounds like a beautiful future to me!


My favourite features of Brave and an explanation of how its re-imagination of online advertising could lead to a better future for the everyone.

Brave: Brilliant Browser and the Future of Online Ads

It's been a little over 3 years since I joined the Engineering Team at Amigo Loans as a Front End Software Engineer, and it's been quite a journey for me.

I have been able to work on a range of websites, web applications, backend services and a native mobile app using some of the latest and greatest tools, libraries and frameworks the frontend world has to offer. I have also had the pleasure of working with some of the most brilliant, hard-working people who have all been incredibly supportive and helped me develop as a professional and as a person.

Despite the positives, and after much thought and deliberation, I believe that it's the right time for me to leave the company and move onto something new.

## So What's Next?

At the beginning of March I'll be starting my new job as Frontend Developer at [Pulselive](https://www.pulselive.com/ "Pulselive homepage")!

I'm incredibly excited to get started and work with new people to build amazing digital products for some of the biggest names in sport. I'm also excited to see how this new job will help me learn new things and grow into a better developer.

I'll also be working with a few ex-Redweb colleagues again which is a great bonus!

## Are You Happy in Your Work?

I have spent a lot of time going back and forth about whether I should stay at Amigo. It was never going to be an easy decision. There are lots of things to consider and always the question of "is the grass really greener on the other side?".

If you are/have been in a similar position of struggling to figure out a way of deciding what's right for you, I have one recommendation which I hope may prove useful to you. Ask yourself this one simple question:

<blockquote>
  <p class="mb-0">"Will I be <strong>happy</strong> if I stay?"</p>
</blockquote>

I highlight the word "happy" because I don't mean "happy enough", I mean would it actually bring you genuine, long term happiness?

If the answer to my question is "No" I would suggest that it's time to look for something new. Go out and find somewhere you think will bring you that missing joy.

I think it's only recently dawned on me just how important it is to really enjoy your job. It is such a big part of your life and it affects the other parts of your life more than you might realise.

I plan to write an article on this topic to go into more depth, so be sure to keep an eye out for that!

At the end of this month I'll be leaving my role at Amigo Loans and starting my new job as a Frontend Developer at Pulselive!

New Year, New Job!

Bootstrap's dependence on jQuery has been a relatively large factor in my reason to stop using it in recent years. Now, with the Bootstrap 5 alpha, they're ditching jQuery in preference of using the APIs provided by modern browsers. This is a big step, but one that I feel is beneficial and necessary to encourage developers like me to use it again on future projects.

## Lets Not Hate on jQuery

I would like to clarify that I don't hate jQuery.\* I think that jQuery has done an incredible job over the years at making front-end web development a significantly less painful endeavour. The reality these days is that it's not as relevant and necessary anymore. Browser support is far less of an issue because they are much better at keeping up with standards and other libraries and frameworks have been developed which render jQuery less useful. Nevertheless, we can still appreciate that jQuery has served it's purpose extremely well since it was first released all the way back in 2006 and I will forever be thankful for it and all the work people put in to building and maintaining it.

<p class="text-sm">*I personally don't like it when developers talk trash about older tech, languages, libraries, frameworks etc. just because it's a little dated. It's always good to be mindful that people still like use these technologies and it is a perfectly valid choice if it suits their use case.</p>

## Light as a Feather

So lets take a look and see what impact dropping jQuery has on Bootstrap's file size:

<div class="overflow-scroll w-full mt-4 mb-8">
    <table>
        <thead>
            <tr>
                <th>Bootstrap Version</th>
                <th>Files</th>
                <th>Size (Original)</th>
                <th>Size (Gzip)</th>
                <th>Total (Gzip)</th>
            </tr>
        </thead>
        <tbody>
            
            <tr>
                <td rowspan="2">v4.5 (latest)</td>
                <td>Bootstrap</td>
                <td>60.0 kB</td>
                <td>14.9 kB</td>
                <td rowspan="2">39.8 kB</td>
            </tr>
            <tr>
                <td>jQuery</td>
                <td>72.4 kB</td>
                <td>24.9 kB</td>
            </tr>
            
            <tr>
                <td rowspan="2">v5 (alpha)</td>
                <td>Bootstrap</td>
                <td>63.5 kB</td>
                <td>16.2 kB</td>
                <td rowspan="2">16.2 kB</td>
            </tr>
            <tr>
                <td>jQuery</td>
                <td>-</td>
                <td>-</td>
            </tr>
        </tbody>
    </table>
</div>

<p class="text-sm">Note: I've excluded Popper.js from this because it is the same for both versions of Bootstrap.</p>

We can see that there's only a very small increase (1.3 mB Gzipped) in Bootstrap's file size to compensate for completely removing jQuery!\*\* Less data down the wire means faster page loads which is great for improved SEO and user experiences.

<p class="text-sm">**This file size will also be affected by changes other than dealing with the removal of jQuery, i.e. new features, so in reality removing jQuery made even less of a difference in Bootstrap's size!</p>

## What Else is New?

There are some other new features of Bootstrap 5 which include:

-   New CSS custom properties
-   Updated forms & form controls
-   New utilities API
-   Enhanced grid system with a new XXL tier for really large screens

I won't go into detail about any of these, but if you're interested you can [head over to the Bootstrap blog to read all about the new features](https://blog.getbootstrap.com/2020/06/16/bootstrap-5-alpha/ "What's new in Bootstrap v5").

## Bootstrap Icons

Whilst on the subject of Bootstrap I thought I should mention that they have recently released a great set of over 1,000 SVG icons which you can use on any project (you don't need to be using Bootstrap to use them). [Take a look at Bootstrap Icons](https://icons.getbootstrap.com/ "Bootstrap Icons") and see what you think!

I definitely feel that it's the right time for Bootstrap to say goodbye to jQuery and move to rely solely on the powerful capabilities of modern web browsers.

Bootstrap is Dropping its jQuery Dependency


## Defining Abstraction

Programmers often use the word "abstraction" when talking about their code but it's not a term new programmers are likely to have come across and understand.

### The Dictionary Definition

<blockquote>
    "The act of considering something as a general quality or characteristic, apart from concrete realities, specific objects, or actual instances."
    <footer><cite>
      <a href="https://www.dictionary.com/browse/abstraction" rel="noopener" target="_blank" title="Dictionary.com definition of abstraction">dictionary.com</a>
      </cite></footer>
</blockquote>

I don't know about you, but I don't find this definition particularly helpful. Let's try and make it a bit easier to digest.

### My Alternative Definition

Here's my attempt to redefine "abstraction" to make it simpler and more directly applicable to our use case: programming.

<blockquote>
    "Providing a label to a piece of code that accurately describes the purpose and actions of that logic."
</blockquote>

I think that's a much easier to understand. The first thing you might think to yourself is "That just sounds like a description of variables, functions, and classes"...and you would be right! These can all be forms of abstraction. We'll have a look at each of these a bit later.

## Why Do We Want/Need to Abstract Anything?

Breaking-up code into smaller labelled chunks helps us write clean code which is easy to read, maintain and re-use.

### Focusing on What We Care About

Abstraction helps us focus on results; we don't have to worry about _how_ something is done, we only care about _what_ the result is.

### Readable Code

We reduce complexity by placing logic behind layered abstractions. This means at the top-level we only see the top-level abstractions, which ultimately makes the code much easier to read. This should become a little clearer when we look at some examples.

### Reusable Code

Once code has been abstracted we can use it throughout a project again and again. It means that we only have to write the code once instead of repeating ourselves which has a lot of benefits (which is a topic for another time).

## Examples

I'm going to use "making a BLT sandwich" as a contrived example.

### Variables

We have a bunch of variables containing a bunch of values, like this:

```js
const breadState = "buttered";
const baconState = "raw";
const lettuceState = "washed";
const tomatoState = "washed";
```

We can see all of the states of all the necessary ingredients for our sandwich. Now we want to know whether we can assemble it:

```js
const isReadyToAssemble =
    breadState === "buttered" &&
    baconState === "cooked" &&
    lettuceState === "washed" &&
    tomatoState === "sliced";
```

`isReadyToAssemble` is an abstraction. Referring back to my earlier definition, `isReadyToAssemble` is the _label_ which describes of whether all of ingredients are ready for sandwich assembly. Now, further down in our code, we don't have to concern ourselves with _how_ we know it's ready, we just know that `isReadyToAssemble` will tell us; that's the beauty of abstraction - overlaying more complex logic with a simple label.

If it helps you can relate this to the real-life equivalent situation. Which of the following questions are you more likely to ask?

1. "Is the bread buttered and the bacon cooked and the lettuce washed and the tomato sliced for me to assemble the sandwich?"
2. "Are all of the ingredients ready for me to assemble the sandwich?"

My guess is that you're a bit more in-line with number 2. So you see, you abstract everyday without even realising!

```js
if (isReadyToAssemble) {
    const sandwich = assembleBltSandwich(ingredients);
}
```

And this leads us nicely on to our next example...

### Functions

Similar to variables but containing more complex logic.

We can use `assembleBltSandwich()` as our example here. We know that we can call this function and it will return us an assembled sandwich. All of the logic describing _how_ the sandwich is made is hidden away inside that function.

We could imagine that the contents of `assembleBltSandwich()` looks something like this:

```js
function assembleBltSandwich(ingredients) {
    return layBreadButterSideUp(ingredients.bread.sliceOne)
        .then(() => addMayo(ingredients.mayo))
        .then(() => addBacon(ingredients.bacon))
        .then(() => addTomato(ingredients.tomato)) // <-- Tip: never let the tomato touch the bread, it makes it soggy and horrible
        .then(() => addLettuce(ingredients.lettuce))
        .then(() => addMayo(ingredients.mayo))
        .then(() => layBreadButterSideDown(ingredients.bread.sliceTwo));
}
```

Here we can once again see that some of the logic is abstracted further into functions like `addBacon()`. The result is layer upon layer of abstraction, with the bottom layers doing the heavy logic and the top layers basically just acting as labelled wrappers to make things easier.

### Classes

I won't go too in-depth with this because I think you're getting the idea by now. You can abstract details and actions of a sandwich into a `BltSandwich` class like so:

```js
class BltSandwich extends Sandwich { // <-- You don't have to worry about what's in the base Sandwich class for this example.
    public ingredients;

    constructor(ingredients) {
        super(ingredients);
    }

    public prepare() {
        ...

        return this;
    }

    public assemble() {
        ...

        return this;
    }
}
```

This is a further abstraction on top of everything we've already covered. So when we want to prepare and assemble a sandwich now, all we have to do is this:

```js
const ingredients = {
    bread,
    butter,
    bacon,
    lettuce,
    tomato,
    mayo,
};

const sandwich = new BltSandwich(ingredients).prepare().assemble();
```

All of the logic is nicely contained inside the class' public methods and we can just enjoy our lovely sandwich.

## Abstract with Caution!

There are a couple of things to be aware of when thinking about introducing a new abstraction into your code.

### Over-Abstraction

So abstraction is great, we should use it all the time for everything, right!? Well...not exactly.

It's easy to go overboard and over-abstract in an attempt to make code super generic and re-usable. You end up losing clarity on the feature you're building because you try to make it work for every possible use case and not the one(s) that you've been presented with. It makes it difficult for anyone else to understand what you've done and why.

This topic could easily be a whole blog post in itself, which I hope I'll be able to write someday.

### The Wrong Abstraction

Creating the wrong abstractions results in code which is difficult to understand and even more difficult to work with.

The common scenario is that you have two pieces of code which are doing similar things in multiple different places and, because you want clean code, you merge them together into a generic method which takes a bunch of arguments to make sure it does the right thing depending on there the method is called.

Abstraction complete. Sounds fine, right? But now one of a few things could happen:

1. New requirement: do something exactly the same in a different place
2. New requirement: do something mostly similar in a different place
3. New requirement: change the way it works for some of the places but not others

Now you might be able to spot some problems:

1. There's no problem here, but in my experience it's not often you'll get asked to do something which is a carbon copy of something else.
2. So you need to modify your abstraction and pass it more arguments so that it'll do what you need it to do in this new case. That's going to make it look messy and confusing as you keep adding things into that method.
3. So you need to modify your abstraction whilst making sure you don't introduce any issues with the other existing code. That's always easier said than done.

So there is an argument here that the logic should not have been abstracted together in the first place, it would have been better to have isolated duplicate code which means it's easy to modify without causing issues with existing code.

It's almost impossible to foresee changes in the future so you can't plan for everything, but just try to ask yourself whether the abstraction makes logical sense - don't just do it to keep your code [DRY](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself "Don't Repeat Yourself: Wikipedia").

<br />
<hr />
<br />

**Update (27/07/2020):** I recently came across [The WET Codebase](https://www.deconstructconf.com/2019/dan-abramov-the-wet-codebase "The WET Codebase: A talk by Dan Abramov"): a talk by [Dan Abramov](https://twitter.com/dan_abramov "Dan Abramov on Twitter") via [a post on his blog](https://overreacted.io/the-wet-codebase/ "The WET Codebase: A blog post by Dan Abramov"). The talk explains a lot if what I've written above very well with some nice clear visuals; it's worth a watch! Also, if you're a fan of [React](https://reactjs.org/ "React JS") you'll love the rest of his blog!


Abstraction is not as complicated as you might first think, especially because you already abstract every day without even thinking about it!

Explained: What Is Abstraction?

It makes sense to kick off this blog by explaining why I want to start a blog at all!

I spend quite a lot of time reading articles that I think might be interesting and/or useful for my career; it's part of how many of us keep up to date with everything that's happening in the industry. Reading content written by other developers makes me feel proud and grateful that there are a large number of people who are open and happy to share their knowledge and experiences so freely. It has inspired me to start doing the same.

## I'm Doing This for You

You're welcome ;)

But seriously, I want to be able to give a little back to an industry which has given me so much support over my career so far.

### Offering Help & Support

I can't even begin to tell you the number of times I’ve been saved by a blog post. I think we've all been in the position of frantically scrambling through search results praying that you'll find a fix to whatever problem you're having at the time. And then...magic! You stumble across an article on a stranger's blog that completely saves the day.

Or maybe it's just that you're trying to get your head around a piece of technology or a programming concept that confuses the heck out of you. You've read the official docs and some of the high profile blog posts and it's still not sinking in. Then, all of a sudden, you find someone who's written about it in a way that makes it all make sense!

My point is that I hope to be the one providing that kind of support and relief to someone else for a change.

### Sharing Insight and Experience

This is particularly applicable/useful if you are a developer who is early on in their career or a student working your way towards a certification in software development. I got my first job as a developer back in 2015 and I've learned a heck of a lot over those five years which I'd love to be able to share with the world. I hope that you can use some of the knowledge that I have to share to help you learn and grow in your own career.

### Creating Enjoyment and Interest

I really want you to enjoy reading my work. There would be little point in creating content if I didn't think people might enjoy reading it!

## I'm Doing This for Me Too

As much as all the above is completely true, I can’t pretend like there aren’t a few benefits for me too.

### Learning and Growth

I'm a strong believer that a great way to learn something is to try to teach it. Having the ability to teach a subject requires you to understand it well enough to be able to communicate the details effectively to a learner. This blog is my teaching platform and I intend on taking advantage of it in order to help me grow my own knowledge and experience.

### Communication

Good written and verbal communication are skills that I somewhat pride myself on. It takes consideration and practice to be an effective communicator and this platform will definitely provide me with plenty of practice!

## Final Words

I really hope this blog lives up to all of my hopes and expectations. It’s going to take some time and effort to build but I’m really excited to get creating and seeing how it all turns out!


My rationale behind wanting to create and write on my very own blog, with an outline of what I want to achieve for myself and anyone who reads my posts.

Posts