DEV Community: ammonb

Bootcamps vs. College

ammonb — Wed, 03 Apr 2019 21:32:13 +0000

Programming bootcamps seem to make an impossible claim. Instead of spending four years in university, they say, you can learn how to be a software engineer in a three month program. On the face of it, this sounds more like an ad for Trump University than a plausible educational model.

But this is not what we’ve found at Triplebyte. We do interviews with engineers, and match them with startups where they’ll be a good fit. Companies vary widely in what skills they look for, and by mapping these differences, we’re able to help engineers pass more interviews and find jobs they would not have found on their own. Over the last year, we’ve worked with about 100 bootcamp grads, and many have gone on to get jobs at great companies. We do our interviews blind, without knowing a candidate's background, and we regularly get through an interview and give a candidate very positive scores, only to be surprised at the end when we learn that the candidate has only been programming for 6 months.

Bootcamp grads are junior programmers. They have a lot to learn, and represent an investment on the part of a company that hires them. That said, this is also true of recent college graduates. We’ve found bootcamp grads as a group to be better than college grads at web programming and writing clean, modular code, and worse at algorithms and understanding how computers work. All in all, we’ve had roughly equivalent success working with the two groups.

In this post, I'm going to try to shed some light on how this can be true. I’ll dig more into the differences that we see between the two groups, and hopefully explain how some people can become competitive junior programmers in under a year.

The Analysis

Our technical interview at Triplebyte is about two and a half hours long, and is broken into four main parts, focusing on practical programming, web architecture, low-level system understanding, and algorithmic understanding. Not every engineer completes every question (we let programmers focus on their strengths), but the process gives us a good measure of the relative strengths of each engineer in each of these areas.

To get a better idea of how bootcamp grads and college grads compare, I graphed the two groups’ average performance in each of these areas. The y axis is the score on each problem (where 1 = strong no, 2 = weak no, 3 = weak yes, 4 = strong yes). For reference, I also included the entire population of applicants, and also all engineers who pass our interview.

The first thing to note about this graph is that bootcamp grads do as well as or better than college grads on practical programming and web system design, and do worse on algorithms and low-level systems. Our practical programming questions are not easy. They require understanding a problem, coming up with abstraction to solve the problem, and rendering this in code. If anything, our practical programming questions require more on-the-spot thinking than our algorithm problems do. They do not, however, require academic CS or math, or any specific knowledge. This is the crux of the issue. Bootcamp grads match or beat college grads on practical skills, and lose on deep knowledge.

A similar pattern holds on the design questions. Bootcamp grads do better on web questions involving web servers, databases and load balancers. College grads do better on low-level design questions involving bit/bytes, threading, memory allocation, and understanding how a computer actually works.

Triplebyte sees a biased sample of both bootcamp grads and college grads. We do background-blind screening via an online programming test, and only interview engineers who pass this test. Thus we have no way to know what percentage of bootcamp grads and college grads fail early in our process, and the graph above reflects only people who pass our test. Still, a significant number of bootcamp grads pass our test and go on to do as well as college grads on our interviews.

I want to specifically draw attention to the performance of college grads on algorithm problems. They are not only better than bootcamp grads, they are a lot better. They are significantly better than the average programmer making it to our interview (most of whom have 2+ years of experience), and almost as good at the average engineers who we pass. This is interesting. It backs up the assertion that algorithm skills are not used on the job by most programmers, and atrophy over time.

How is this possible?

Our data aside, it still just seems hard to believe that 3 months can compete with a 4-year university degree. The time scales just seem off. The first thing to note is that the difference in instructional time is not as large as it seems. Bootcamps, are intense. Students complete 8 hours of work daily, and many stay late and work on the weekends (one popular bootcamp runs 6 days per week). TAs are working with the students during this entire time. What bootcamps lack in duration they perhaps make up in intensity.

The second point is that bootcamps teach practical skills. Traditional CS programmers spend significant amounts of time on concepts like NP-completeness and programming in Scheme. Now, I in no sense mean to belittle this material. I love academic CS (and the Cook–Levin theorem). It’s beautiful, fascinating stuff, and I got a lot out of learning it. But it is not directly applicable to what most programmers do most of the time. Bootcamps are able to show outsized results by relentlessly focusing on practical skills. Bootcamp TAs continually critique each student's coding style. They teach testing. They teach their students how to use their editors. How to use an editor is something that a traditional CS degree program would never think of teaching.

This does not leave bootcamp grads equivalently skilled to university grads. If you want to do hard algorithmic or low-level programming, you’re still better served by a traditional CS eduction. But it does leave the best of them surprisingly competitive for many entry-level development positions.

Conclusion

There are two ways to interpret the results in this blog post. One way is to say that bootcamps are window dressing. They teach inexperienced programers what they need to know to look like good programmers, but skimp on the heart of the discipline. However, I think this view is too cynical. The other way to view this post is as evidence that bootcamps focus on totally different areas than CS programs. They focus intensely on the practical skills required to be a productive programmer. These are skills that CS programs expect students to pick up around the edges of their course work. By being this pragmatic and giving students an intense workload, bootcamps are able to match the practical skills of CS grads.

Bootcamp grads don’t make sense for all companies. Just like recent college grads, they are an investment for a company that hires them. They have much to learn. And they are clearly worse at algorithms and low level systems than engineers with academic training. A database or self-driving car company should probably stick to folks with CS degrees. But the significant majority of companies need programers to solve practical problems on the web. On this axis, we’ve found bootcamp grads totally competitive.

Triplebyte is one year old. In that time, we’ve both placed bootcamp grads at top companies, and also watched them grow. We’ve watched them learn some of the CS skills that they lack on graduation. We’ve watched them learn about large-scale production systems. We’ve watched them take on leadership positions. It’s really incredible how quickly and how well the best bootcamp grads learn. It’s been a pleasure to work with them, and we’ll definitely keep working with bootcamp grads.

If you’re a bootcamp grad (or a college grad, or anyone else), and are interested in a way to find companies where you’re a strong technical match, give our process a try. I'm also interested in your thoughts on this post! Send me an email at ammon@triplebyte.com.

Thanks to Jared Friedman and Daniel Gackle for reading drafts of this, and Buck Shlegeris for major help writing it.

A Humility Training Exercise for Technical Interviewers

ammonb — Tue, 05 Feb 2019 21:40:51 +0000

tl;dr Humility is an important quality in technical interviewers. Our data shows that interviewers who are strongly confident in their own abilities give less consistent interview scores. Interviewers who are aware of their own weaknesses (and of how noisy interviews can be) in contrast, give more consistent scores. We've developed an exercise to help train interviewers in this area.

Programming interviews are noisy. Two interviewers judging the same candidate will often reach decidedly different conclusions about the candidate's skill, even in the same specific area. This noise is a significant obstacle to interview accuracy. Reducing this noise is one of the primary goals when training technical interviewers.

Training Interviewers

We train a lot of interviewers at Triplebyte. We employ a team of 40 experienced engineers to conduct interviews with candidates as they go through our platform. When we train new members of this team, we focus on several things. We make sure that interviewers are strong and up-to-date in the areas they will be measuring (it's surprisingly hard, sometimes, to distinguish a candidate who gives an unusual answer because they are an expert in an area from someone who gives an unusual answer because they don't know what they are talking about). We make sure that interviewers have clear guidelines for what skills they are assessing (this is the best defense against pattern matching bias in interviewers). However, I now think it's equally important to train interviewers in humility ^[1].

Lack of recognition of your own weaknesses is a major source of interview noise. This is true because overconfident interviewers judge candidates too harshly. The field of software engineering is broad enough that no single engineer can master it all. However, we all convince ourselves that the areas that we have mastered are the most important. And we don't fully respect another engineer if they are weak in an area where we are strong (even if they are very strong in other areas). In interviews, this manifests as a bias against candidates whose technical strengths are dissimilar to those of their interviewers. We measure this at Triplebyte by having multiple interviewers observe and grade the same interview. The effect persists even when interviewers grade areas unrelated to their own strength, and even when they use structured grading rubrics. Interviewers just give lower scores to candidates who are not like them. This is noise. It makes interviews less accurate, and we need to reduce it.

The solution, we've found, is to train interviewers in humility. Interviewers who are aware of their own weaknesses (and aware of how noisy interviews can be) are less influenced by areas other than the ones they are supposed to be evaluating, and give more consistent scores.

An Exercise to Build Humility

So, how can you train interviewers to be humble? How can you make yourself more humble? The answer, I think, is to experience what a candidate goes through. Interviewing for a job is humbling. You get grilled. You have to remember things you've not thought about in years. Smart people point out embarrassing flaws in your logic and code. You never know quite as much as you thought you did. And almost everyone fails a good percentage of their interviews.

We've developed an exercise that we use to let our interviewers experience being a candidate. At first we tried simply asking interviewers to interview each other. This did not work, however, because they were not able to give honest feedback. If you interviewed your co-worker and ended up thinking that they were kind of bad, would you tell them this honestly? Most people in this situation wouldn't. We needed to get around this somehow.

The solution came unexpectedly. The exercise actually started while I was trying to hire for our interview team. Part of the evaluation process that I used was asking candidates to interview me (it got really meta), and, in order to make these interviews more interesting, I gave a mix of (my attempt at) good and bad answers. I immediately noticed how this got them to give honest (and humbling) feedback--even on my “good” answers. From this experience, we developed the following exercise to train all our interviewers in humility:

Pair up with a co-worker, and have them ask you some of their favorite interview questions.
Tell them in advance that you are going to intentionally answer some of the questions poorly (role-playing answers that a weak candidate might give).
Then, as the interview progresses, do exactly this. About half the time give your best answer. The other half of the time give an intentionally poor answer.
After the interview is over, ask your co-worker to critique your answers.

What this does is free your co-worker to be 100% honest. They don't know which parts of the interview were really you trying to perform well. Moreover, they are on the hook to notice the bad answers you gave. If you gave an intentionally poor answer and they don't “catch” it, they look a little bad. So, they will give an honest, detailed account of their perceptions.

Be careful with this exercise! I've done this a bunch, and it's deeply humbling. It almost always results in someone you respect pointing out things you're bad at. And it has some potential to create conflict. I think it should probably only be done inside teams with a good degree of internal trust (the danger is convincing team members that other team members are not very good). But the result is powerful. It highlights clearly both the extent to which strong engineers are weak in certain areas, and the extent to which interviewers jump to conclusions about what a candidate means. I think everyone who conducts interviewers should put themselves through this exercise.

Conclusion

It's important for technical interviewers to be humble. This creates a better experience for the candidate, and it also makes interviews more accurate. The best interviewers are aware of their own limitations, and have a healthy appreciation of how capricious the process can be. To get better at these things, interviewers need to spend more time as candidates, being interviewed themselves. It's hard to create this experience among co-workers, but we've come up with a (dangerous!) exercise that does a pretty good job.

I'd love it if people tried this exercise more broadly. I think it might be something that should become standard for interview teams at most companies. If you give it a try, email me at ammon@triplebyte.com and let me know how it went.

^[1] I've interviewed over 1000 people since starting Triplebyte. Some of the them probably don't feel that I was humble when I spoke with them. All I can say to this is... I'm sorry if I did a bad job interviewing you. Everything I write about here I apply to myself.↩

How to Pass a Programming Interview

ammonb — Wed, 16 Jan 2019 00:10:09 +0000

This post started as the preparation material we send to our candidates, but we decided to post it publicly.

Being a good programmer has a surprisingly small role in passing programming interviews. To be a productive programmer, you need to be able to solve large, sprawling problems over weeks and months. Each question in an interview, in contrast, lasts less than one hour. To do well in an interview, then, you need to be able to solve small problems quickly, under duress, while explaining your thoughts clearly. This is a different skill ^[1]. On top of this, interviewers are often poorly trained and inattentive (they would rather be programming), and ask questions far removed from actual work. They bring bias, pattern matching, and a lack of standardization.

Running Triplebyte, I see this clearly. We interview engineers without looking at resumes, and fast-track them to on-sites at top tech companies. We’ve interviewed over 1000 programmers in the last nine months. We focus heavily on practical programming, and let candidates pick one of several ways to be evaluated. This means we work with many (very talented) programmers without formal CS training. Many of these people do poorly on interviews. They eat large sprawling problems for breakfast, but they balk at 45-min algorithm challenges.

The good news is that interviewing is a skill that can be learned. We’ve had success teaching candidates to do better on interviews. Indeed, the quality that most correlates with a Triplebyte candidate passing interviews at companies is not raw talent, but rather diligence.

I fundamentally do not believe that good programmers should have to learn special interviewing skills to do well on interviews. But the status quo is what it is. We’re working at Triplebyte to change this. If you’re interested in what we’re doing, we’d love you to check out our process. In the meantime, if you do want to get better at interviewing, this blog post describes how we think you can most effectively do so.

1. Be enthusiastic

Enthusiasm has a huge impact on interview results. About 50% of the Triplebyte candidates who fail interviews at companies fail for non-technical reasons. This is usually described by the company as a “poor culture fit”. Nine times out of ten, however, culture fit just means enthusiasm for what a company does. Companies want candidates who are excited about their mission. This carries as much weight at many companies as technical skill. This makes sense. Excited employees will be happier and work harder.

The problem is that this can be faked. Some candidates manage to convince every company they talk to that it’s their dream job, while others (who are genuinely excited) fail to convince anyone. We’ve seen this again and again. The solution is for everyone to get better at showing their enthusiasm. This is not permission to lie. But interviewing is like dating. No one wants to be told on a first date that they are one option among many, even though this is usually the case. Similarly, most programmers just want a good job with a good paycheck. But stating this in an interview is a mistake. The best approach is to prepare notes before an interview about what you find exciting about the company, and bring this up with each interviewer when they ask if you have any questions. A good source of ideas is to read the company’s recent blog posts and press releases and note the ones you find exciting.

This idea seems facile. I imagine you are nodding along as you read this. But (as anyone who has ever interviewed can tell you) a surprisingly small percentage of applicants do this. Carefully preparing notes on why you find a company exciting really will increase your pass rate. You can even reference the notes during the interview. Bringing prepared notes shows preparation.

2. Study common interview concepts

A large percentage of interview questions feature data structures and algorithms. For better or worse, this is the truth. We gather question details from our candidates who interview at companies (we’ll be doing a in-depth analysis of this data in a future article), and algorithm questions make up over 70% of the questions that are asked. You do not need to be an expert, but knowing the following list of algorithms and data structures will help at most companies.

Hash tables
Linked lists
Breadth-first search, depth-first search
Quicksort, merge sort
Binary search
2D arrays
Dynamic arrays
Binary search trees
Dynamic programming
Big-O analysis

Depending on your background, this list may look trivial, or may look totally intimidating. That’s exactly the point. These are concepts that are far more common in interviews than they are in production web programming. If you’re self-taught or years out of school and these concepts are not familiar to you, you will do better in interviews if you study them. Even if you do know these things, refreshing your knowledge will help. A startlingly high percentage of interview questions reduce to breadth-first search or the use of a hash table to count uniques. You need to be able to write a BFS cold, and you need to understand how a hash table is implemented.

Learning these things is not as hard as many of the people we talk to fear. Algorithms are usually described in academic language, and this can be off-putting. But at its core, nothing on this list is more complicated than the architecture of a modern web app. If you can build a web app (well), you can learn these things. The resource that I recommend is the book The Algorithm Design Manual by Steven Skiena. Chapters 3 through 5 do a great job of going over this material, in a straightforward way. It does use C and some math syntax, but it explains the material well. Coursera also has several good algorithms courses. This one, in particular, focuses on the concepts that are important in interviews.

Studying algorithms and data structures helps not only because the material comes up in interviews, but also because the approach to problems taken in an algorithm course is the same approach that works best in interviews. Studying algorithms will get you in an interview mindset.

3. Get help from your interviewer

Interviewers help candidates. They give hints, they respond to ideas, and they generally guide the process. But they don’t help all candidates equally. Some programmers are able to extract significant help, without the interviewer holding it against them. Others are judged harshly for any hints they are given. You want to be helped.

This comes down to process and communication. If the interviewer likes your process and you communicate well with them, they will not mind helping. You can make this more likely by following a careful process. The steps I recommend are:

Ask questions
Talk through a brute-force solution
Talk through an optimized solution
Write code

After you are asked an interview question, start by clarifying what was asked. This is the time to be pedantic. Clarify every ambiguity you can think of. Ask about edge cases. Bring up specific examples of input, and make sure you are correct about the expected output. Ask questions even if you’re almost sure you know the answers. This is useful because it gives you a chance to come up with edge cases and fully spec the problem (seeing how you handle edge-cases is one of the main things that interviewers look for when evaluating an interview), and also because it gives you a minute to collect your thoughts before you need to start solving the problem.

Next, you should talk through the simplest brute-force solution to the problem that you can think of. You should talk, rather than jump right into coding, because you can move faster when talking, and it’s more engaging for the interviewer. If the interviewer is engaged, they will step in and offer pointers. If you retreat into writing code, however, you'll miss this opportunity.

Candidates often skip the brute-force step, assuming that the brute-force solution to the problem is too obvious, or wrong. This is a mistake. Make sure that you always give a solution to the problem you’ve been asked (even if it takes exponential time, or an NSA super computer). When you’ve described a brute-force solution, ask the interviewer if they would like you to implement it, or come up with more efficient solution. Normally they will tell you to come up with a more efficient solution.

The process for the more efficient solution is the same as for the brute force. Again talk, don’t write code, and bounce ideas off of the interviewer. Hopefully, the question will be similar to something you’ve seen, and you’ll know the answer. If that is not the case, it’s useful to think of what problems you’ve seen that are most similar, and bring these up with the interviewer. Most interview questions are slightly-obscured applications of classic CS algorithms. The interviewer will often guide you to this algorithm, but only if you begin the process.

Finally, after both you and your interviewer agree that you have a good solution, you should write your code. Depending on the company, this may be on a computer or a whiteboard. But because you’ve already come up with the solution, this should be fairly straightforward. For extra points, ask your interviewer if they would like you to write tests.

4. Talk about trade-offs

Programming interviews are primarily made up of programming questions, and that is what I have talked about so far. However, you may also encounter system design questions. Companies seem to like these especially for more experienced candidates. In a system design question, the candidate is asked how he or she would design a complex real-world system. Examples include designing Google Maps, designing a social network, or designing an API for a bank.

The first observation is that answering system design questions requires some specific knowledge. Obviously no one actually expects you to design Google Maps (that took a lot of people a long time). But they do expect you to have some insight into aspects of such a design. The good news is that these questions usually focus on web backends, so you can make a lot of progress by reading about this area. An incomplete list of things to understand is:

HTTP (at the protocol level)
Databases (indexes, query planning)
CDNs
Caching (LRU cache, memcached, redis)
Load balancers
Distributed worker systems

You need to understand these concepts. But more importantly, you need to understand how they fit together to form real systems. The best way to learn this is to read about how other engineers have used the concepts. The blog High Scalability is a great resource for this. It publishes detailed write-ups of the back-end architecture at real companies. You can read about how every concept on the list above is used in real systems.

Once you’ve done this reading, answering system design questions is a matter of process. Start at the highest level, and move downward. At each level, ask your interviewer for specifications (should you suggest a simple starting point, or talk about what a mature system might look like?) and talk about several options (applying the ideas from your reading). Discussing tradeoffs in your design is key. Your interviewer cares less about whether your design is good in itself, and more about whether you are able to talk about the trade-offs (positives and negatives) of your decisions. Practice this.

5. Highlight results

The third type of question you may encounter is the experience question. This is where the interviewer asks you to talk about a programming project that you completed in the past. The mistake that many engineers make on this question is to talk about a technically interesting side-project. Many programmers choose to talk about implementing a neural network classifier, or writing a Twitter grammar bot. These are bad choices because it’s very hard for the interviewer to judge their scope. Many candidates exaggerate simple side projects (sometimes that never actually worked), and the interviewer has no way to tell if you are doing this.

The solution is to choose a project that produced results, and highlight the results. This often involves picking a less technically interesting project, but it’s worth it. Think (ahead of time) of the programming you’ve done that had the largest real-world impact. If you’ve written a iOS game, and 50k people have downloaded it, the download number makes it a good option. If you’ve written an admin interface during an internship that was deployed to the entire admin staff, the deployment makes it a good thing to talk about. Selecting a practical project will also communicate to the company that you focus on actual work. Programmer too focused on interesting tech is an anti-pattern that companies screen against (these programmers are sometimes not productive).

6. Use a dynamic language, but mention C

I recommend that you use a dynamic language like Python, Ruby or JavaScript during interviews. Of course, you should use whatever language you know best. But we find that many people try interviewing in C , C++ or Java, under the impression these are the “real’ programming languages. Several classic books on interviewing recommend that programmers choose Java or C++. At startups at least, we’ve found that this is bad advice. Candidates do better when using dynamic languages. This is true, I think, because of dynamic languages’ compact syntax, flexible typing, and list and hash literals. They are permissive languages. This can be a liability when writing complex systems (a highly debatable point), but it’s great when trying to cram binary search onto a whiteboard.

No matter what language you use, it’s helpful to mention work in other languages. An anti-pattern that companies screen against is people who only know one language. If you do only know one language, you have to rely on your strength in that language. But if you’ve done work or side-projects in multiple languages, be sure to bring this up when talking to your interviewers. If you have worked in lower-level languages like C, C++, Go, or Rust, talking about this will particularly help.

Java, C# and PHP are a problematic case. As we described in our last blog post, we’ve uncovered bias against these languages in startups. We have data showing that programmers using these languages in the interview pass at a lower rate. This is not fair, but it is the truth. If you have other options, I recommend against using these languages in interviews with startups.

7. Practice, practice, practice

You can get much better at interviewing by practicing answering questions. This is true because interviews are stressful, but stress harms performance. The solution is practice. Interviewing becomes less stressful with exposure. This happens naturally with experience. Even within a single job search, we find that candidates often fail their initial interviews, and then pass more as their confidence builds. If stress is something you struggle with, I recommend that you jumpstart this process by practicing interview stress. Get a list of interview questions (the book Cracking the Coding Interview is one good source) and solve them. Set a 20-minute timer on each question, and race to answer. Practice writing the answers on a whiteboard (not all companies require this, but it’s the worst case, so you should practice it). A pen on paper is a pretty good simulation of a whiteboard. If you have friends who can help you prepare, taking turns interviewing each other is great. Reading a lot of interview questions has the added benefit of providing you ideas to use when in actual interviews. A surprising number of questions are re-used (in full or in part).

Even experienced (and stress-free) candidates will benefit from this. Interviewing is a fundamentally different skill from working as a programmer, and it can atrophy. But experienced programers often (reasonably) feel that they should not have to prepare for interviews. They study less. This is why junior candidates often actually do better on interview questions than experienced candidates. Companies know this, and, paradoxically, some tell us they set lower bars on the programming questions for experienced candidates.

8. Mention credentials

Credentials bias interviewers. Triplebyte candidates who have worked at a top company or studied at a top school go on to pass interviews at a 30% higher rate than programmers who don’t have these credentials (for a given level of performance on our credential-blind screen). I don’t like this. It’s not meritocratic and it sucks, but if you have these credentials, it’s in your interest to make sure that your interviewers know this. You can’t trust that they’ll read your resume.

9. Line up offers

If you’ve ever read fund-raising advice for founders, you’ll know that getting the 1st VC to make an investment offer is the hardest part. Once you have one offer, more come pouring in. The same is true of job offers. If you already have an offer, be sure to mention this in interviews. Mentioning other offers in an interview heavily biases the interviewer in your favor.

This brings up the strategy of making a list of the companies you’re interested in, and setting up interviews in reverse order of interest. Doing well earlier in the process will increase your probability of getting an offer from you number one choice. You should do this.

Conclusion

Passing interviews is a skill. Being a great programmer helps, but it’s only part of the picture. Everyone fails some of their interviews, and preparing properly can help everyone pass more. Enthusiasm is paramount, and research helps with this. As many programmers fail for lacking enthusiasm as fail for technical reasons. Interviewers help candidates during interviews, and if you follow a good process and communicate clearly, they will help you. Practice always helps. Reading lots of interview questions and inuring yourself to interview stress will lead to more offers.

This situation is not ideal. Preparing for interviews is work, and forcing programmers to learn skills other than building great software wastes everyone’s time. Companies should improve their interview processes to be less biased by academic CS, memorized facts, and rehearsed interview processes. This is what we’re doing at Triplebyte. We help programmers get jobs without looking at resumes. We let programmers pick one of several areas in which to be evaluated, and we study and improve our process over time. We’d love to help you get a job at a startup, without jumping through these hoops. You can get started here. But the status quo is what it is. Until this changes, programmers should know how to prepare.

Thanks to Jared Friedman, Emmett Shear, Garry Tan, Alexis Ohanian and Daniel Gackle for reading drafts of this.

^[1] This is not to say that interview performance does not correlate with programing skill. It does. But the correlation is far weaker than most companies assume, and factors other than programing skill explain a large part of interview variance. ↩