Accesses

Let’s take advantage of your new hire from the start. We don’t want to waste hours in an initial setup when we have the chance to move with anticipation. So in this case, if you need to work with your infrastructure team to grant access to git, VPNs, JIRA, etc, you’ll need to create your preferred corporate secure email or in case that’s not available, use the developer’s email (With Hand-Picked, you can use their @hand-picked.io address for this purpose).

With the email as a starting point, you can create all other dependant accounts, and just wait for those confirmation or verification clicks on day 1.

Objectives

There are always tasks in our backlogs that need to be done that are suitable for onboarding processes. Also there are new features or big changes to implement. It is very important to have both kinds of tasks ready for your new developer, so you can assign them right away.

Suggest reading material

Is there any heavy download that the developer may need to start? Is there a way to start doing it before day 1? Sharing a link before starting could make this ready for the project beginning. Also, every project has peculiarities that make it different than the previous one. Maybe you use a novel library, VM or architecture that would need some reading?

An enthusiast developer undoubtedly would go and check and study all this new info beforehand.

Build Instructions

With projects complexity increasing by the day, build processes also became lengthier and more complex. Be sure that in your company’s wiki or knowledge base the process is up to date, so that doesn’t become a problem during the first build for your new hire. Obviously, it could happen that there is no doc available, so anything will help, from an email to a quick chat telling about any quirks in the process. This also includes accesses to any Continuous Integration platforms you may use, at least in the development environment (if every commit or pull request trigger new builds where the developer may need to check for errors).

Communication

Development teams spend a substantial amount of time in communication platforms, less than with their IDEs, but a lot nonetheless. As with other accesses, this one is particularly important as generally different teams are in the same platform, which may help with the initial setup (or any greeting or welcome rite you may have).

Project Tracking

So you have your objectives, deadlines and user stories. How the new developer will check them out? Let’s make sure they have access to the tool you use for this purpose.

Is your project starting from scratch and are you creating a remote team? Start creating boards on Trello and analyze it later in case you need an upgrade to Jira or other platform.

Introduce them to their peers

Introducing the rest of the team is of key importance as the developer starts working on their assignments. Sooner than later they will interact with designers, QAs, other developers, etc. Be sure you introduced them or let them know those names so they can quickly jump into those needed conversations.

Anything extra to sign?

Legal stuff, always important to have them already done so we can let creativity flow. If you need any extra NDAs or contracts, be sure to sign those deals before day 1. If you hire through Hand-Picked, we’ll be sure to remind you about this.

Company equipment

In case your Company workflow involves providing a laptop or equipment that may have already solved many points previously mentioned (already installed VPN, emails accounts already setup, necessary software installed) be sure to ship it at least one week before the initial date with your new developer.

Different countries have different times for their customs processing and anticipating it for at least one week with express shipping carriers -like DHL or FedEx- will make this less of a problem.

Final thoughts

What do you think about these points? Many apply to both new in-house developers and contractors, so we hope this guide helped you.

Hire your next Hand-Picked developer

Hand-Picked developers are motivated from start, so you will find them actively looking to integrate into your team as soon as possible. They will be open to any suggestions even before the contract begins, so you are welcome to communicate even if there is some time left before the project starts.

Cover Photo by Annie Spratt on Unsplash

Algorithms and Data Structures, why?

So let’s approach this question describing when knowledge of algorithms and data structures kick in -in unexpected ways sometimes- into our jobs.

One of the clearest examples is the usage of indexes in databases. It happens that certain queries start being very slow in systems where load and size have increased. Even optimizing the query (tables order, using less data, etc) would not be enough and the need of creating an index arises. Why indexes? Well, basic understanding of data structures make it easy to understand how data access speed is influenced by the data structures enabling it. The most common index in databases are B-tree indexes, which enable searches, access, etc in logarithmmic time. So we have it, algorithms and data structures come along again.

There is something called, “The Law of leaky abstractions” or “leaky abstractions” as is. Simply said, we could trust that the database itself will take the query and run it in efficiently. As we said before, this happens to be wrong in the long run. Sooner than later, the developer (or DBA?) will have to get his hands dirty and make that query perform better, regardless of semantics.

How does this all DB SQL Query thing relates with algorithmic tests? Well, those tests will reveal if the developer is aware of performance impact on many decisions during development. Unnecessary loops, or extra storage used may show disregard on knowing how things work, or that some knowledge is missing.

In some interviews we could find that developers rely too much on a given language libraries (data structures, strings, etc), to the extent that they think the library does magic and they wouldn’t explain “how they would implement it if they had to”. This kind of shallow knowledge gives us developers that, for example, don’t know how sorting works or why allocating memory for arrays in each write access is not good.

Solutions made by aware developers will always have those performance concerns on the radar, which makes those kind of solutions desirable. Clients know that, and in their search for great developers, most of them will want to be sure that the candidate has what it takes.

That’s the reason why at Hand-Picked we do both automated algorithm tests and live coding interviews. We are interested in knowing that our developers will make the cut and have low chances of obvious performance blunders.

I would like to mention some notes about performance in general, there is a saying

Premature optimization is the root of all evil

Credited to Donald Knuth, in a longer sentence

which basically states that acting on performance when it isn’t important, does more harm than good. Will you spend time trying out an idea for your customers to use, or rather seeing if you’ll need a Big Data database to store analytics? Above all, even though algorithmic knowledge is valuable, it is more valuable for the developer to have criteria when taking decisions. So there is also other phrase about priorities.

Make it work, Make it nice, Make it fast

This formulation of this statement has been attributed to Kent Beck

We can see that making it work (correct, do what it is intended) and ‘nice’ (which means, making maintainable code in some way) come first. What will you make fast if it doesn’t work at all? Rhetoric question, as it may happen that not making something fast enough, may make the thing NOT WORK AT ALL for a given volume, users quantity or data amount. So always pay attention, it may happen that performance could be of utter importance.

These two phrases and that counter-argument may look contradictory but they are put together here just to show how good criteria must always be on top.

Conclusion

As performance is an important point in Software Development, Hand-Picked verifies the algorithmic knowledge of its candidates through an Automated Coding Platform and a Live Coding interview. This way we know we are dealing with a candidate that has the proper tools to solve performance problems that may arise during their engagements. But we don’t exaggerate it, solving CS Olympics level problems isn’t a requirement to enter the Hand-Picked network, just a good level of criteria when coding.

Cover Photo by Alvaro Reyes on Unsplash