Ask the person to implement "Hello world" and then count the lines of code, number of classes, inheritance depth, number of external dependencies, etc.
$ perl -wle "print 'hello world'"
$ echo "hello world"31–40 of 52 posts
If it's NodeJS the fastest way is to check how many dependencies they have in total, bad developers will find a way to include 100s or 1000s of dependencies, anonymous third-party blobs of code running within their application: $ npm install Another indicator is how elaborate their build process to munge w/e they wrote into w/e a machine understands.
Don't agree with the approach because using a proven solution can be superior and net a simpler code base than rolling your own. Fyi, by using webpack, couple loaders, babel, etc I net 100s of dependencies just for the build. Ymmv.
Let me explain, a person thinking through a solution that should only take 1 hour and spends an entire day on it is overengineering. What goes through this persons mind goes something like this: "Maybe solution X is better?", "Is my code good enough?", "What happens in area X?", "Maybe add more tests to cover X?" ...
You get the point. That's why I always focus on the end result and try to be pragmatic as possible. Would this solution be enough to solve this problem, if yes, then move on. Don't get me wrong, performance wise, it should also be taken in consideration but not that it consumes all your time.
I'd also look for people who are constantly starting from scratch. The complex system builders I've known are _terrible_ at maintaining systems. So, they throw them away every 12 to 18 months and start over. If you think they're complecting too much, ask them how they supported one of their creations over _years_.
Lastly, ask them what customers thought of the result. Look for specifics here. They should give names, use cases, etc... Really, they should understand the business problem their customer needed solved and be able to communicate why the complexity of their solution was necessary to solve the customer's problem.
I ask candidates to sketch an API (program, not REST, i.e. an outline of classes, functions and module structure) for a problem similar to those we solve, but smaller in scope. I also ask about things like test coverage and programming paradigms they have an affinity for. Some things I look for that can be negative signals are: * Propensity to choose classes and OO programming in a domain it isn't really suited for,…
Actually, the question is related to employee, not a candidate:) He is working with us quite for a long time, and he writes really good code. But he can't make simple solutions, only the hardest way to solve a problem. And because of it, we can't plan work and estimate tasks.
If it's NodeJS the fastest way is to check how many dependencies they have in total, bad developers will find a way to include 100s or 1000s of dependencies, anonymous third-party blobs of code running within their application: $ npm install Another indicator is how elaborate their build process to munge w/e they wrote into w/e a machine understands.
Don't agree with the approach because using a proven solution can be superior and net a simpler code base than rolling your own. Fyi, by using webpack, couple loaders, babel, etc I net 100s of dependencies just for the build. Ymmv.
We all work with really complex systems. The trick is to abstract them to the point where they're simple to understand and use. 1000s of dependencies doesn't even have to be complex at all if you use simple patterns to manage those dependencies.
Have them build "A framework for X", where X is some commonly-done problem most programmers in their field have worked on (webapps, CMSes, forums, build systems, big data, etc.), ideally related to your business. If you want to do this in an interview or take-home setup, you will likely need to use a cut-down version of this problem, although really, much of the point of it is to see just how much the problem expands…