DEV Community: Chris Harding

Tips for getting hired as a developer

Chris Harding — Mon, 08 Jun 2020 10:45:54 +0000

Given the uptick in people looking for roles right now, I thought I’d share some tips for getting hired as a developer. These tips are things I look for when hiring developers. My aim is to shed some light on what people over the other side of the desk are thinking. Perhaps armed with this perspective, you will think differently about your own approach.

It started with a resume

Before jumping into the interview itself, it’s first important to talk about how to get one. When making decisions on who to interview, I spend time looking through a candidates background and portfolio. The main two aspects I look at are as follows:

Resume

Your resume encompasses a range of mediums which should clearly and concisely demonstrate why I should bring you in for interview. These mediums include your LinkedIn profile, personal website and 2-page resume, but to name a few. Think about these as telling a story about how you got to where you are, what skills you have developed and the achievements you had along the way. It should stoke their imagination and encourage them to want to dig deeper.

Hiring managers will look at plenty of resumes each day, so you should aim to make their life as easy as possible. There is nothing more frustrating than having to sift through 6 pages of terse text, not least because it contradicts the oft stated ‘good communicator’. There are some quick wins here:

Keeping your resume to two, well-formatted, pages
Strip back information which is not directly relevant such as part-time work or whether you have a driving licence
Bring to the top specific points mentioned in the job spec. By this I mean if a hiring manager is looking for a Python developer with AWS experience, make sure this is clearly stated at the top of your resume.
Highlight results and achievements where possible. Rather than “Upgraded website from .NET to .NET Core”, try “Scaled website from handling 500k to 2 million customers a week, resulting in 50% increase in sales”

I also like to see some personality injected where possible. Could you add a little about your hobbies? Or an interesting social enterprise you’re passionate about? This starts to build a picture in my head about who you are and whether you would make a good fit for the team.

Portfolio

Your portfolio is another cache of evidence around the statements in your resume. For me, it’s a really important part of initial candidate vetting and gives me insight into what you have built, how you write code and what methodologies you follow.

Portfolios can include personal websites, GitHub accounts, Stackoverflow pages or other relevant links. I would encourage everyone to throw up some sample projects and if you don’t have one, try and make a couple. It could be anything as simple as a todo list through to a clone of a social media site. The important part is demonstrating concepts such as clean code, testing methods, documentation and even devops process. Personally, I’m not looking at the result of the project necessarily, rather how it was built.

And now, we tango

So onto the interview. This part is about really understanding your personality, and whether you can backup everything you wrote on your resume. Often your response to questions will be measured by the thought process, the reaction and the communication rather than the specifics of the answer. Some of the qualities I look for are as follows:

Passion

It’s really important that you are passionate about what you do and the vision the company is driving towards. Passion fuels motivation and is good indicator of how you will perform in a role. Are you doing the job because you genuinely care about solving the mission statement, or because tech pays well?

Adaptability

Being adaptable and able to cope with change is a crucial trait and something I value when hiring. An example of why this is important. The technical shopping list is a snapshot of today and borne out of current requirements. It will almost definitely change over time as these requirements evolve. Hiring for this specific skill set will solve a problem now, but if you can’t adapt then the whole process will repeat down the line. I would much prefer someone intelligent, willing to learn and able to adapt than a marginally better coder of a specific tech stack.

Get things done

Businesses survive by getting results. Results require you to get things done and add value. It may be great that you can architect the perfect, fault tolerant and performant system. But can you actually write it? Can you ship it in a timely manner? Can you get something out that will move the needle now rather than in two years time?

When can you start?

Well, if you made it this far congratulations - you got the job. To summarise, the first step is getting your foot in the door. Do this by telling your story and showing the hiring manager you can meet the role requirements. Once at interview, demonstrate your personality traits and qualities. Show that you can learn and adapt and will grow with the business. That they can trust you to do the job.

Building a calendar in Swift

Chris Harding — Mon, 18 May 2020 18:15:35 +0000

In this post, I wanted to walk through an approach I used when building a calendar view in Swift for an iOS app I’m working on. The requirements were as follows:

Should start from the current day, and then scroll backwards through time
Each month is it’s own section, with corresponding header
Days should be a selectable square cell, and we should have 3 days on each row
The grid should take up as much screen real estate as possible
It should be memory efficient

And with any luck, it will look something like this...

With this in mind, I decided to use a customised UICollectionView, as most of the work around grid layouts and memory optimisation are done for me.

Bring the calendar to life

The first step in this process is to initialise a collection view. That’s relatively simple as follows

Most of this code is layout plumbing such as setting the frame size to it’s container, along with constraints to anchor it's size. This will fulfil my requirement around maximising screen real estate.

Go with the flow (layout)

Next up, I wanted to further optimise the layout such that the day cells are as big as possible. To achieve this, we can subclass UICollectionViewFlowLayout. The important methods to implement are as follows

Here we are calculating the maximum size of cell, based on the current frame and padding used. This should yield 3 day cells on each row, each maximising the width.

This subclass now needs be registered with my collection view as follows

Make it fancy

The final piece of layout required are definitions for what the day cells and month section headers will look like. To achieve this, I created two simple nibs. The day cells need to subclass UICollectionViewCell as follows

Nothing out of the ordinary here, just a label being set. I did however implement static convenience functions so that details such as reuse identifiers are encapsulated. As for the month header, we need to subclass from UICollectionReusableView

Note how we register this as a kind of UICollectionView.elementKindSectionHeader. We now need to tell our collection view to use these templates when creating new header and collection cells.

Let there be data

Finally, we need to tell the collection what it’s actually supposed to be rendering. I achieved this by firstly implementing a manager class which will calculate the necessary data, and put it into an efficient struct format.

The reason for this is that we can calculate this once, upfront, and then simply lookup the relevant data at render time (as opposed to re-calculating for each cell). Here is the supporting code to decide how many months we need to show, along with how many days each month contains

With this data in place, we again lean on the on the built in collection view functionality and subclass UICollectionViewDataSource

As you can see, returning the relevant section and cell data is just a lookup from our array. We can now hook this data source up to the collection view and away we go!

Looking back through the approach I have taken, I'm pleased to say it meets all of the requirements I set out at the top. This makes me happy.

You can see the full Swift calendar source code for this solution here: https://github.com/wdchris/calendar-grid-swift

Setting Up Netlify Forms With Gatsby

Chris Harding — Tue, 05 May 2020 10:07:07 +0000

I recently built a website using Gatsby, choosing to host it on the Netlify free tier. One of the features I wanted to try was form handling. Typically, handling form posts requires wiring up and hosting a backend to process requests. Netlify forms allows me deploy a simple static site with zero backend, letting them handle the rest for me. You can read more about the functionality here.

React setup

The setup is relatively straight forwards. Firstly, we need to add in the usual form, input and button tags. Below is a sample component for submitting a user email address.

Notice two extra attributes on the form tag. data-netlify is used to tell Netlfy we want to track this form. data-netlify-honeypot is the name of an input within the form we’ll use to counter bot attacks. Note also that we need to specify a name attribute on the input we're tracking. This is a key, the input being the value, which will be sent to the Netlify forms api.

The last pieces of markup we need are two hidden inputs.

The first wires up the form name to the Netlify api. The second is the aforementioned honeypot input field for tricking bots. This will be hidden from users, but will likely be completed by any bots informing Netlify to ignore this response.

Hooking it up

Now that the markup is in place, we just need to add some standard React code to track the state of the input and send a POST request for Netlify to capture.

Here we have used React hooks to track the state. A fetch method is then used to send a POST request, encoding the form name and email address response to be sent to the Netlify api.

That’s all folks

And that’s all it takes. Push this to deploy and you’ll notice submissions coming through on the Netlify forms dashboard. It will track a form called register, and will contain a field called email. All this built on a static React site with a stateful front-end. You can see the full code sample here.