Forem: George Hanson

Are Web Development Bootcamps Worth It?

George Hanson — Thu, 08 Aug 2019 08:10:45 +0000

Over the past couple of years, web development bootcamps have sprung up all over the place. It now seems to be the goto place for would-be developers to get started within the industry. There are some pro's and con's to going through a bootcamp, so is it worth it?

Well the answer to that (like most code related questions) - it depends.

Benefits of Web Development Bootcamps

The main reason in my opinion for the rise of bootcamps is undoubtedly the support they offer. Now not all bootcamps are equal and some are just plain terrible. But I'm just talking about the reputable ones here.

You have the support and guidance of not just the tutors, but the other students who are going through the same bootcamp. If you are someone who has difficulty self-teaching then this is a massive benefit.

Another key benefit of enrolling in a web development bootcamp is the top-quality learning resources. Whether these are videos, textbooks or codelabs you have the re-assurance that you are learning from high quality resource material that has already been vetted for accuracy and completeness. When you are self-teaching, you have to do this research yourself.

One thing I hear bootcamp students mention all of the time is just how much they learn within a short space of time. These courses can be intensive and you have to put a lot of work into them. But because of the high quality curated content you are consuming, you do learn lots within a short period of time. But it is worth bearing in mind that this can be seen as both a pro and a con. You still need to have enough experience working with something for it to fully stick in your head, you can't just quickly glaze over something and remember it all perfectly.

Cons of Web Development Bootcamps

The first con I'd like to mention about web development bootcamps is the price. These bootcamps can get very expensive very quickly. They often range from $5000 to $25000+ which unless you have a bunch of cash in the bank means borrowing or financing. Straight away you are putting yourself into debt before you get a job. Which leads me nicely onto my second point.

You do not have a guaranteed job afterwards.

A lot of bootcamps like to highlight how much earning potential there is as a web developer, but in reality you still have to go out and find the job. You don't get it handed to you on a silver platter and unless you continue to put hard work and teach yourself after you have finished you will find progression to be extremely difficult.

It is important to remember that web development bootcamps are not a "magic bullet".

So, are they worth it?

Well, as I said at the start of the post it depends. For some people it works as an excellent way to get into the industry, but it is important that you manage your expectations. While there are some people who do go through bootcamps and land the well-paying job straight away; a lot of people don't. So just be prepared to put work in, especially if you want to progress your career further. Technology is changing at such a rapid rate.

In my personal opinion if you feel like you are able to self-teach and you are able to take your time, there are plenty of free resources that teach you everything you need to know. But if you are comfortable with bootcamps, go right ahead.

Whichever route you chose to go down, just have fun!

This article was originally posted on my blog at https://www.georgehanson.co.uk/blog/are-web-development-bootcamps-worth-it

3 reasons why you SHOULD write tests

George Hanson — Mon, 08 Jul 2019 11:00:50 +0000

Writing tests is something that I think a lot of developers come to later on. It's quite often that when developers are learning to code, whether that is self taught, through bootcamps or at university; testing is often overlooked.

I don't get it, why is testing not focused on enough? When you start working on production projects and in teams you often find that testing is something you simply have to do.

I think part of it comes down to the case for writing tests not being clear enough. It's like the developers version of office paperwork - nobody seems to want to do it. Let me go through why you should be writing automated tests.

Typical Scenario

In most workplaces, a typical scenario is this. You're working on a REST endpoint for an API. It starts off fairly simple but over time it gets more and more complicated. Before long you are using repositories, caching and the whole thing becomes a bit daunting to touch. Because you become worried about breaking things you don't refactor the code and over time it becomes this spaghetti code that people don't want to work with.

Testing makes this better.

What is automated testing?

Put simply, automated testing is making sure that your code does what it is supposed to do. You interact with your API you have created and assert that the correct actions have occurred. Whether that is a HTTP response code, checking that a record exists in the database or just something else.

It's also worth mentioning that testing is not a magic bullet. It follows the same principles as most things GiGo (Garbage in, Garbage out). You have to make sure that the tests you write are meaningful and useful otherwise they serve no purpose.

Common Testing Frameworks

For testing the easiest way of getting started is to use one the many frameworks available for your language of choice. Here are some common testing frameworks used for PHP and JavaScript.

PHP

PHPUnit
Codeception
Behat

JavaScript

Jest
Jasmine
Mocha

Why you should write automated tests?

So I have already covered a couple of reasons why automated tests are useful. But let me dive in a little deeper on why you should be writing automated tests.

1. Developer confidence

As I mentioned above, it doesn't take long to create these large classes that are unwieldy. One of the best benefits that testing gives you is this confidence as a developer. You can make any change you want, simply run the test suite and know straight away if you have broken anything.

This gives you a lot of flexibility. You can not only refactor code worry-free, but you can also experiment with solutions without the fear of breaking the code.

2. Thinking as a consumer

Testing often requires you to think from a different perspective. You have to take your developer hat off and put on your consumer hat. Whether this is how someone will consume a HTTP API or a package, you can design your system in a way that is best for the consumer.

Because of this, it allows you to easily think of edge cases in how the user might choose to interact with your application. How many times have users used an app in a way you hadn't anticipated?

3. Time saving

Contrary to what a lot of people think, testing does save you time. How can this be when you are writing the test as well as the implementation you ask? Well because it allows you to spot bugs easier you are less likely to spend time debugging for a start. If a bug gets reported in your system, write a test to reproduce the bug and then you can interact with the application in isolation to find the root cause.

Testing is something that you are spending time writing as an investment in the future.

Is there a time you shouldn't write automated tests?

Generally speaking no. But remember this is not a law, use your best judgement. If you are writing a small app just to play around with an idea and you are not planning on releasing it to the outside world then there is no harm in not writing any tests. That being said, it is a really good habit to get into and the more you do it the easier it will become.

Simple PHP Control Structure Refactoring

George Hanson — Thu, 02 May 2019 15:02:06 +0000

This article was originally posted on my blog - Simple PHP Control Structure Refactoring

Before we get into it, I posted all three of these little refactors on my Instagram and Twitter pages. Be sure to check those out as there is a handy little image you can save.

One common thing I see when looking at code is some simple refactors that can make it slightly more readable. One of these "code smells" are if control structures. There are some occasions where these can be made much simpler and even reduced to just one line.

In this article I'll go through three simple refactoring tips to help tidy up your code. I hope you find them useful so let's begin.

Ternary Operator

The ternary operator is a simple but powerful operator that I find myself using throughout my code-base. This operator allows us to easily check a condition and return a value in just one line.

Let's take a look at an example. Here we are looking at a five line control structure. We are checking if the user is logged in or not and changing the value of the welcome variable accordingly.

if ($user->isLoggedIn()) {
  $welcome = 'Welcome '.$user->firstName;
} else {
  $welcome = 'Welcome Guest';
}

Simple enough right?

Well we can make it even simpler using the Ternary operator. Here is an example of how we could refactor this control structure.

$welcome = 'Welcome '.($user->isLoggedIn() ? $user->firstName : 'Guest');

And there we go. We have refactored the control structure into just one line. But how does this work? Let's break it down. The first thing we are doing is concatenating the result of the conditional to the string Welcome. With me so far?

Great. So let's take a look at the conditional itself. We are checking if the user is currently logged in, if they are it returns the value after the ? which in this case is the users first name. If not it returns the value after the : which is "Guest".

As you can see this is a really simple, yet powerful shortcut to clean up control structures.

'Elvis' Operator

Ok, ok. This isn't actually called the Elvis operator, but it does look like a little guy with Elvis' hair style - so it has been dubbed as such.

This instead is actually the Ternary operator, but a short-hand version of it. There are some cases where we want to return the value of what we are evaluating rather than a separate value. In which case we can use the Elvis operator.

Sounds a little confusing? Don't worry, let's take a look at an example and it will all become clear.

Here we want to get the url for the avatar that should be displayed. If the user has an avatar url we will use that, otherwise we want to use the default.

if ($user->avatarUrl) {
  $url = $user->avatarUrl;
} else {
  $url = '/default.jpg';
}

Take a look at how we can make it simpler. Here is an example of how we could refactor this control structure.

$url = $user->avatarUrl ?: '/default.jpg';

Can you see why it has been dubbed the Elvis operator?

You can see that this is very similar to using the long-form Ternary operator. But it is slightly different. If the avatarUrl is truthy it will return that value, otherwise it will return the string. This is the same as writing the following:

$url = $user->avatarUrl ? $user->avatarUrl : '/default.jpg';

Null Coalescing Operator

This is the final operator I'm going to talk about. This operator strictly checks if the left operand is not null or if it exists as a variable, array index or object property. This is another awesome little feature that was added in PHP 7.

This operator acts similarly to the PHPs isset function as well as the 'Elvis' operator.

The most common use case I find for these is checking if an item exists in an array and if it does setting that value to a variable, otherwise setting it to a default. That way we avoid errors where the index does not exist.

Let's take a look at an example.

Here I am checking the data in a POST request to see if the user has provided a slug for the post. If one has been provided we will set the slug variable to that value, otherwise I want to call a generateSlug function.

$slug = isset($_POST['slug']) ? $_POST['slug'] : generateSlug();

As you can see we are already using the Ternary operator but we can make this even simpler by using the Null Coalescing operator.

To use this operator we simply use ?? with the default value as the right operand. Here is how we can refactor the code above to make it easier to read.

$slug = $_POST['slug'] ?? generateSlug();

Much nicer, using the Null Coalescing operator we have simplified it massively. It checks if the $_POST['slug'] value exists and if it does, assigns it to the slug variable. Otherwise we call the function.

I hope that you found this post useful. I know that I use all three of these techniques throughout my code-base to clean it up and I hope you do to. Be sure to check out my Twitter and Instagram pages for handy little images you can save.

Building Vue.js Applications With TypeScript - Part Two

George Hanson — Tue, 23 Apr 2019 13:09:29 +0000

This article was originally posted on my blog here - https://www.georgehanson.co.uk/blog/building-vuejs-applications-with-typescript-part-two

A while ago, I posted an article titled "Building VueJS Applications with TypeScript". If you haven't seen that yet, make sure you take a look. You can find it by clicking here.

At the end of that post, I noted that I would be writing a follow-up article explaining methods, props, child components, etc. While it has been a while since I posted that, this is the second post in the series.

In this article, we will carry on where we left off. But we are going to create a very simple to-do list application to demonstrate a variety of concepts. Let's get started.

Setting Up

The first thing that we need to do is to create a new component for our to-do list. Within your src/components folder, create a new file called ToDo.ts and add the following boilerplate.

import { Component, Vue } from 'vue-property-decorator';
import WithRender from './to-do.html';

@WithRender
@Component
export default class ToDo extends Vue {

}

Also, create a new file in the same directory called to-do.html. Here is some very basic HTML to get us started.

<div>
    <h1>My To-Do App!</h1>
    <form>
        <input type="text" placeholder="Enter task...">
        <button type="submit">Add Task</button>
    </form>
</div>

Finally, we need to update our Home.vue file within the views directory so that it loads our new ToDo.ts component. Update the component to look like this.

<template>
  <div class="home">
    <img alt="Vue logo" src="../assets/logo.png">
    <ToDo />
  </div>
</template>

<script lang="ts">
import { Component, Vue } from 'vue-property-decorator';
import ToDo from '@/components/ToDo.ts';

@Component({
  components: {
    ToDo,
  },
})
export default class Home extends Vue {}
</script>

Our First Component

The first thing I would like to do is abstract our form to its own component. Let's create a new component called ToDoForm.ts and copy the HTML template also. We should have two new files that look like this.

ToDoForm.ts

import { Component, Vue } from 'vue-property-decorator';
import WithRender from './to-do-form.html';

@WithRender
@Component
export default class ToDoForm extends Vue {

}

to-do-form.html

<form>
    <input type="text" placeholder="Enter task...">
    <button type="submit">Add Task</button>
</form>

Now that we have abstracted the component, we need to include this child component within our parent. In order to do this, we need to import the component into the TypeScript file, register it and then update the template to display it. Let's go through that now. To get started, import the ToDoForm.ts component into the ToDo.ts component.

import ToDoForm from './ToDoForm';

Next, we need to register the component. We can do this by passing an object to our @Component decorator. Here we can configure the component like we would any normal Vue component.

@Component({
  components: {
    'to-do-form': ToDoForm
  }
})

Our ToDo.ts file should now look like this:

import { Component, Vue } from 'vue-property-decorator';
import WithRender from './to-do.html';
import ToDoForm from './ToDoForm';

@WithRender
@Component({
  components: {
    'to-do-form': ToDoForm
  }
})
export default class ToDo extends Vue {

}

The final step is to now update our to-do.html template so that we are referencing the child component. Simply remove the form and replace it with a <to-do-form /> tag. Once done, our template file should look like this.

<div>
    <h1>My To-Do App!</h1>
    <to-do-form />
</div>

You should now see that the form is being displayed on our page.

Showing The Tasks

The next thing we are going to tackle is showing the tasks to the user. To start with we need to store the tasks as an array. In our ToDo.ts component, we will add a new property. This is essentially the same as adding any data property in a standard .vue component.

Let's define a type for a task. Create a types folder within src and then create a file called Task.ts. Our task is going to be relatively simple. Each task will consist of a description and a completion status. Here is our type definition.

type Task {
  completed: boolean;
  description: string;
}

export default Task;

Now we can create our data property in our ToDo.ts component. Import the type into our component...

import Task from '@/types/Task';

...and then add the following property to the class.

public tasks: Task[] = [];

In order to see the results on the page, we need to render them using a v-for loop. Here you can see I have updated the template within the to-do.html template to output each task item in an unordered list.

<div>
    <h1>My To-Do App!</h1>
    <to-do-form></to-do-form>
    <ul>
        <li v-for="task in tasks"><input type="checkbox" :checked="task.completed"> {{ task.description }}</li>
    </ul>
</div>

For now, let's hard-code some tasks so we know that it is working. Update the tasks property in the ToDo.ts component to have some items in the array by default.

public tasks: Task[] = [
  { description: 'Make Coffee', completed: false },
  { description: 'Feed Dragons', completed: false },
];

You should now see those tasks being rendered on the page. Good job!

Creating New Tasks

So we now have a form and a way of displaying the current tasks on the page. Next, we need to actually add the functionality so that when a user adds a task in the form it updates the data property.

To do this we will first need to edit our ToDoForm.ts component. We need to use v-model so that we can capture the input with data binding. Within your ToDoForm.ts file, add a new property called task.

public task: string = '';

Now update the to-do-form.html template so that the input field has v-model.

<form>
    <input type="text" placeholder="Enter task..." v-model="task">
    <button type="submit">Add Task</button>
</form>

Great, we now have a way of capturing the user input. Next, we need to ensure that when the "Add Task" button is clicked, we emit an event to the parent component. Let's add an event listener to the form tag within our template.

<form @submit.prevent="emitTask">
    <input type="text" placeholder="Enter task..." v-model="task">
    <button type="submit">Add Task</button>
</form>

Next, we need to create the emitTask method on in our ToDoForm.ts component. Simply add a new method to the class. Within this method we want to emit a new event, passing the value entered in the form. We then want to reset the value ready for the next input.

public emitTask(): void {
  this.$emit('added', this.task);
  this.task = '';
}

Now that we have an event emitting, we can listen for this event in our parent component. First, let's add an event listener to the component in our to-do.html template file.

<to-do-form @added="addTask" />

Now we need to create the listener. Add a new method to the ToDo.ts class called addTask. In this method, we want to push a new item to the tasks property with the description from the event.

public addTask(description: string): void {
    this.tasks.push({ description, completed: false });
}

And now you are ready to check it out in the browser. You should now be able to add a new task, submit the form and see it added to the list below.

What About Props?

So far I have shown how to use child components, data properties, and events. But you'll commonly have to use props in any real-world use case.

Let's add a new feature so that we can easily customise the text of the form button. We want to be able to pass the value through a prop called button-text.

Firstly, we'll update the template so we are passing a prop through to the child component.

<to-do-form @added="addTask" button-text="Create Task" />

The next thing we need to do is accept the prop in our child component. In order to do this, we are going to use another decorator, @Prop. Update the import statement within our ToDoForm.ts file so that we can use the decorator.

import { Component, Vue, Prop } from 'vue-property-decorator';

Now we can go ahead and use it. Add the decorator to the class to accept the prop. Your ToDoForm.ts file should now look like this.

import { Component, Vue, Prop } from 'vue-property-decorator';
import WithRender from './to-do-form.html';

@WithRender
@Component
export default class ToDoForm extends Vue {

  @Prop(String) readonly buttonText!: string

  public task: string = '';

  public emitTask(): void {
    this.$emit('added', this.task);
    this.task = '';
  }
}

You'll notice that for the prop decorator, we are declaring the type twice. Let me explain just a little what is going on here. The first time we specify it, we are passing it as a parameter to the decorator. This is for Vue's type checking. This is similar to how you would declare the property in the following way.

buttonText: {
  type: String
}

We also specify the type at the end of the property. This is for TypeScript's type checking.

We should now be able to update our to-do-form.html template to reference the property as opposed to a hard-coded value.

<form @submit.prevent="emitTask">
    <input type="text" placeholder="Enter task..." v-model="task">
    <button type="submit">{{ buttonText }}</button>
</form>

However, what if we don't pass through a property? You'll notice that we will just get an empty button. Let's add a default just to be safe. In order to do this, we need to pass more information to the @Prop decorator. As we are already providing the type, we instead need to pass in an object so that we can configure multiple options.

@Prop({ type: String, default: 'Add Task'}) readonly buttonText!: string

That is all there is to it. We now have a default value for the button text if we don't provide one.

Conclusion

This has been somewhat of a lengthy article, but I hope it has been useful. We have looked at how we can use child components, data properties, events, and props.

If you have any questions at all, please feel free to get in touch and I'll do my best to answer them.

If you would like to view the code for this, I have pushed it to a git repository. You can find it here - https://github.com/georgehanson/vue-todo-typescript

Homework

If you fancy it, here is a little task for you to do.

Firstly fork the repository. Next add a feature so that you can mark the task as complete. But rather than using v-model, make each task it's own component and use events.

Good luck!

My Top 3 JavaScript Array Methods

George Hanson — Sun, 21 Apr 2019 15:30:45 +0000

JavaScript is a super versatile language. I love it and it really has come a long way over recent years. With JavaScript, we can now build powerful single page applications and when building these applications you will at some point or another use arrays.

I love arrays, here are my top three JavaScript methods that I use on a regular basis.

1. Array Filter

This is actually a method that was added back in ES5, but it is still a method that I use on a regular basis. Array filter allows us to basically do what it says on the tin. Filter an array to a subset based on rules that we provide.

To do this, you simply call the filter method on the array and pass it a callback. For example in this array, I am filtering the results to only return objects where the age is less than 18.

const people = [
  { name: 'Jon', age: 23 },
  { name: 'Daenerys', age: 23 },
  { name: 'Arya', age: 17 }
]

const children = people.filter(person => person.age < 18)
// Returns [ { name: 'Arya', age: 17} ]

2. Array Find

This is something that was added to the ES6 specification. It is similar to the array filter method, but it instead returns us the first result from the filtered array.

For this method again we pass it a callback, containing the rules for our filter. It will then filter the results and return us the first item in the subset. In this case, I want to find the first adult in the array of people.

const people = [
  { name: 'Jon', age: 23 },
  { name: 'Daenerys', age: 23 },
  { name: 'Arya', age: 17 }
]

const adult = people.find(person => person.age >= 18)
// Returns { name: 'Jon', age: 23 }

You'll notice that this time it returns the object, as opposed to an array containing the object.

3. Array ForEach

The forEach method is one that was introduced back in ES5 and therefore has ample browser support. However, I do still see code where people are not using this and are instead using a for loop.

The forEach method does exactly what you think, it loops over each item in the array for you to run a callback on. This is similar to the map method, but there is one key difference. When you use array map, it returns a new array based on the callback you have passed it. Whereas with the forEach method it returns nothing.

Both the map and forEach methods have their use cases. But if I am not intending on manipulating the array I will generally reach for the forEach method.

In the example below I am simply calling the forEach method on the array and passing the object to a custom function.

const people = [
  { name: 'Jon', age: 23 },
  { name: 'Daenerys', age: 23 },
  { name: 'Arya', age: 17 }
]

people.forEach(person => sendNotification(person))

Conclusion

There you go, there are my three favourite array methods. Don't get me wrong there are plenty of other array methods that are really useful and I implore you to look them up. But these are three of my favourites and the three I most commonly use.

Do you have any different array methods that you frequently use? Be sure to let me know.

I'm a R&D Developer. Ask me anything!

George Hanson — Sat, 20 Apr 2019 18:02:39 +0000

I recently got promoted within my company from a Full Stack Developer to R&D Developer.

Ask me anything!

Turbocharge JavaScript strings with Template Literals

George Hanson — Fri, 19 Apr 2019 15:25:39 +0000

Anyone who has been writing JavaScript for a long time will know it has come on leaps and bounds. ES6 has been out for a while now, but there are still a lot of features that I see developers either forgetting or not realising they exist.

Today I'm going to show one of my personal favourites, template literals!

Before ES6

In the old-un days back when we used to use jQuery for absolutely everything, string concatenation was fairly limited. If we wanted to construct a string it got messy, quite quickly. Here is an example.

var person = {
  name: 'George',
  age: 23,
  location: 'England'
}

var sentence = 'Hi, my name is ' + person.name + '. I am ' + person.age + ' years old and I live in ' + person.location

While this works, it looks messy. If something can be tidied up and made more readable, personally I think it is worth it.

After ES6

When ES6 arrived it brought a bunch of features with it. Template literals allow you to easily construct these strings without making the concatenation look too messy.

Let's take the same example above. How might we do this using ES6 template literals? Well, it is very simple. Below is how we would do the exact same thing but in a more readable way.

let person = {
  name: 'George',
  age: 23,
  location: 'England'
};

let sentence = `Hi, my name is ${person.name}. I am ${person.age} years old and I live in ${person.location}.`

As you can see with template literals we no longer have to use quotes or + operators to concatenate the string. Instead, we can just use ${ and }. I feel like this is a really nice improvement.

In order to use template literals, you'll notice that we use back-ticks rather than quotes. This is also useful because it means we no longer need to escape quotation marks in the string. For example, without using template literals we would have to do this:

let greeting = 'Hello! I\'m pleased to meet you!'

But with template literals, we aren't using quotation marks to denote a string. So we can just include them without having to escape them.

let greeting = `Hello! I'm pleased to meet you!`

One final point I'll make, you can also evaluate expressions within template literals. For example, if I wanted to double the person's age I could write this:

let sentence = `Hi, my name is ${person.name}. I am ${person.age*2} years old and I live in ${person.location}.`

I hope you find this useful, I find myself using template literals all of the time.

This article was originally posted here: https://www.georgehanson.co.uk/code-tips/es6-javascript-tips-template-literals

Doing What Makes You Happy

George Hanson — Thu, 18 Apr 2019 23:00:55 +0000

I wrote my first line of code when I was 9. In most industries starting that early would be unusual. Yet in the tech industry this is actually quite common.

So why is this? It is simply because we have a passion for it.

When you are 9 years old, you're not doing it for money, popularity or anything self indulgent other than the amazement of seeing something you have created out of nothing. Even if it is just a blue box on a webpage. That hit if dopamine still tells you it's the coolest thing ever.

But as we get older and step out into the real world we find all sorts of external pressures. Rent to pay, food to put on the table - the list goes on.

For most people the dream is to have passive income. Be able to build something and earn money from it, rather than selling your time. It gives you the freedom to work on those projects you think are cool and that you enjoy, rather than working out of necessity.

This is where so many developers get into the SaaS mindset. Software as a service can lucrative. So why not? The issue is coming up with an idea.

You search around for SaaS ideas. What industries have a gap for a niche app? You find one and start building. Full of passion and positive mentality.

Some people will succeed at this, but quite a few wont. That's because it all goes back to the 9 year old self making a box blue on the screen. After spending a significant amount of time on just setting up the project you begin to lose interest and motivation. You don't find the project enjoyable because you don't have that passion to see it through.

It is not because you lack passion in coding, it is because you lack passion in the product you are building.

This won't apply to everybody, but I know for me it does.

This is how we end up with a bunch of unfinished side projects.

Because of this, I am now putting that time and energy from trying to build SaaS apps to doing those things that give me the dopamine hit. For me, it is helping people and creating resources.

So I aim to be a lot more active on a variety of channels. My website, DEV and Twitter to name a few.

I'm going back to my 9 year old self and doing what is making me happy - and there's nothing wrong with that.

Why Are Coding Standards Important?

George Hanson — Thu, 18 Apr 2019 10:41:10 +0000

Almost every language has a set of standards that developers advocate. Off the top of my head and coming from a PHP background, PSR standards spring to mind. These standards are essentially a set of rules on how you should name your files, variables, classes and even non-naming issues such as line length.

But why are these standards important? I mean if it works isn’t that the main thing? Why do I have to follow these strict rules that tell me how I should code!?

Well, hang on a minute let’s put the brakes on. Coding standards are important, but it is important to know why you should be doing them, rather than just following them because you feel like you should.

Why are coding standards important?

Coding standards are there for a reason. They are designed to try and make the code you write as maintainable as possible. I want to especially emphasise this if you are working within a team. If you are all following the same set of rules on how you should write your code, it is far easier for other developers to understand it, contribute to it and to help maintain it.

But it is not just for those within teams.

It is also important if you are working solo. Even if it is a project that will never be shared with anyone. By consistently following these standards, if you stop working on a project and come back to it 6 months later it will be far easier to understand the code instead of having to spend hours or even days reading the code trying to understand what is happening.

Having knowledge and experience in coding standards is also beneficial for getting hired. Companies like to know that the code you write can easily be maintained by other developers in the team. Or if you were to leave, that another developer could come along and understand what you are doing.

Coding standards aren’t there to be a hurdle you have to jump over. They are there to stop the headache down the road. If you start using them, it will become muscle memory and you won’t even realise you are doing it.

This article was originally posted here: https://www.georgehanson.co.uk/blog/why-coding-standards-are-important

Code Tip: Avoid unnecessary else statements

George Hanson — Wed, 23 Jan 2019 16:21:27 +0000

When writing code it is easy to think in a logical way. With conditionals, people often write it as they would think it. If this condition is true then return this value, otherwise return a different value.

However there is a trap that people often fall into and one simple refactor can make the code more readable. If you have this conditional within a method or function that is returning a value, you can often just remove the else condition because if the condition is true it would never hit it in the first place.

Consider the following code:

public function getName()
{
    if ($this->firstName && $this->lastName) {
        return $this->firstName.' '.$this->lastName;
    } else {
        return $this->firstName;
    }
}

This is a perfect example for refactoring.

You will notice that if the user has a first and last name, we return it. Otherwise we just return their first name.

However the else condition is redundant because we are already returning a value if the condition evaluates to true.

Therefore we can refactor this method to remove the else statement.

public function getName()
{
    if ($this->firstName && $this->lastName) {
        return $this->firstName.' '.$this->lastName;
    }

    return $this->firstName;
}

By doing this, it removes a level of indentation which makes the code more readable. It's a useful tip to remember and one that I find applying all over the place.

Originally Posted on George Hanson

What are your favourite podcasts?

George Hanson — Wed, 21 Nov 2018 13:22:44 +0000

Many of us developers listen to podcasts, what are your favourites? It doesn't have to be specifically "dev" related :)

To be a software engineer or developer, do you still need a degree?

George Hanson — Mon, 01 Oct 2018 12:27:46 +0000

Many companies and organisations are starting to relax their hiring criteria and don't require employees to have degrees - yet some are still very strict on this. Do you think that a degree is still needed to make it as a software engineer or a developer? Discuss.