Hacker News new | past | comments | ask | show | jobs | submit login
Ask HN: What do recruiters look for in a GitHub profile?
235 points by passenger 37 days ago | hide | past | web | favorite | 218 comments
I've submitted a fair amount of job applications that often request for a GitHub profile. I'm however convinced most don't look at it or only take a cursory glance at it.

What do recruiters look out for?




As a hiring manager, I glance at it and take a brief look at anything interesting. It’s good for talking points at the interview, perhaps to ask the candidate to expand upon and explain the work.

If the profile is empty, I close the tab and find something else to talk about. I will never, ever penalise a candidate for an empty GitHub profile. So many people just do not have time for open source and that’s totally fine.

GitHub activity helps lubricate conversation at interviews, but it should never be taken as anything other than a superficial representation of the candidate’s ability or experience.


I penalize people slightly for an empty GitHub if they put it on their resume, just out of annoyance. Why did you put this url for me to follow if there's nothing here but a half started React tutorial from 3 years ago?


Agree on this. If you don't have a useful GitHub portfolio that's fine.

But anything on your resume or linked from your resume is fair game.

If you haven't been able to meaningfully participate in open-source work there's no penalty, but don't link to an empty GitHub page on your resume.


In the rare case that they have an empty GitHub, save for a fork of https://github.com/kelseyhightower/nocode, I hire them immediately.


Yeah, this is just like any other thing you call out by putting on your resume.

Nobody is a expert in everything, of course, but if you specifically put "TCP/IP" or "OOP" on your resume, you better be able to explain TCP vs UDP or class vs interface (both real examples from real phone screens I've done).


As a former recruiter, I just assume all resumes are complete shit. I never saw much of a correlation between a quality resume and a quality candidate. Screening for the stuff one uses on the job is what I prefer to do. It's also nice to focus on the job requirements, too, because it removes any need for someone to impress me with what the have done. When you can walk into an interview with "hey, I really want you to get this job, but we need to find a way for both of us to envision a scenario in which we're working together successfully", it's amazing how well that usually turns out.


Agreed, I think a resume with just yoe, last 10 years of companies worked at/positions/years, education, and 4 our 5 technologies/areas currently interested in working on is enough.

You could probably drop education from it if you have 5 or more yoe.

Frankly you could do this in one 5 or 6 line paragraph without a resume

I never read them anymore. It’s such a waste of time. Totally useless compared to our phone screen templates.


If recruiting software didn't penalize for keywords I think it would be less of an issue. Its a struggle trying to figure out what to put in the "list of technologies" type section. I have to put them somewhere to get past crappy HR screening software since explaining every tech in a job description would create paragraphs but just listing it doesn't represent the level of aptitude.

For example, I might use Chef daily. If I put it in a list of other tools I use it can mean I know how to use it for my very specific use case, but usually it is taken as "this guy thinks he contributes to the Chef source code and knows every bizarre scenario involving it" by some tech screener trying to get his rocks off.

I 100% blame every tech recruiter for furthering this mess.


The secret is don’t base your job search on blindly submitting resumes to applicant tracking systems.

When I am looking for a job, I send my resume to my curated list of local recruiters followed up by a phone call. We talk about what they have available and what I am looking for. I have enough of a history with them that they make sure that my resume shows up on top of the hiring managers stack.

My success rate from submitting my resume to being invited to an in person interview is 100% unless the req was closed. My non rejection rate is close to 100% (I’ve taken myself out of the running because I found a job.)


This is interesting. How did you build your list of local recruiters - through trial and error? And did you use services other than LinkedIn?


It happened over many years. But basically, I respond to every recruiter if I don’t already have a contact with the recruiting company and they have local offices.

Mostly LinkedIn these days. I only got really serious about my career about 10 years ago. Before that I was your typical “dark matter developer” working at one job for almost a decade.


Good to know, this is useful info, especially with respect to working with every recruiter and sticking to LinkedIn. Thanks.


On that note. My ususl response when a recruiter reaches out to me has been.

“Hey, I am not looking to make a move right now/I’m looking to make a move in $x months. What are the trends you are currently seeing and what are the salary ranges? Send me a list of open reqs. I might know some people who are looking”.

This will also let me stay up on market trends and know which projects to focus on and what to emphasize on my resume.


That's quite neat, shifting from being passive to engaging actively with them, I like that, thank you.


I’ll go even further. Don’t put any language, framework, technology on your resume that you don’t want to talk about or that you don’t want to do.

I took C and C++ off of my resume years ago even though I did both for 12 years and I still know all of the ends and outs of C. There is going to be that one old geek (I’m 45) who wants to ask me some obscure question just to prove how smart he is. I definitely leave PHP and Perl off. I don’t want to show up on recruiters search results looking for WordPress developers (I never did WP).

I want to keep the conversation and the interview focused.


Just scanned a resume touting IBM 370 assembly, along with a dozen web frameworks.


>>> class vs interface

This is java specific, that's not OOP.


Interface is a means to achieve OOP. 2 more languages pops off my head:

C#: https://docs.microsoft.com/en-us/dotnet/csharp/language-refe... TypeScript: https://www.typescriptlang.org/docs/handbook/interfaces.html


So many places seem to require a github profile in their form.


There is never anything wrong with writing "n/a" in any kind of form. There was a long overlap during which any form that took contact details already had fields for email address and mobile phone number, but before either of those were as ubiquitous as they are today; nobody processing those forms ever ignored one with "n/a" for email address.

Granted, it might be less prudent to skip some fields than others, of course.


"error: n/a is not a valid URL"


Disable their client side validations and find out if they bothered with server side validations...


how about www.idonthaveaninterestinggithub.com



URL must start from https://github.com/




But it's empty! You'll get penalized


Nice username.


Good job. All projects vacuously have clean READMEs and concise commit history.


n://a?


+1 for this. I used to be a recruiter, and knew hiring managers looked at GitHub profiles. When I started, I used to to stress out over pushing crappy code to my GitHub account. At some point I realized that anyone judging me for stuff I put into GitHub was simply not someone I would ever want to please. My GitHub is mostly a graveyard for experiments, learning, and goofing off, and that is exactly what I want it to be :)

If you have something really notable in your GitHub account, maybe it should probably be on your CV/resume, too!


I've started doing this -- my resume has an "Open Source and Public Speaking" section for putting in noteworthy GH accomplishments.


I’m curious: why bother to use GH then? Why not simply have various repos in your filesystem?

It feels to me like having a blog site and only putting notes, scraps and drafts in it. Maybe there’s some functionality i’m not seeing?


I push to Gitlab from home so that I can pull down to the computer in the shop. Fleshing out an idea is much more comfortable in the home than standing up in front of a an old computer.


It's a good question, and I don't have a specific answer. I guess the short answer is because I want to. It's convenient for a number of reasons.


You could keep experiments in private repos if you worry about showing crappy code.


While you don't actively penalize folks, it's worth pointing out that candidates with an active GitHub profile often _do_ have an advantage in the scenario you describe.


Yes, I would agree that it helped but only based on the logic that a resume/cv is a document designed to advertise your accomplishments. If your accomplishments are best shown by your GitHub then include it, if it shows nothing don't! It's the same as advertising a volunteer group or something on a resume, a group with high participation and clear commitment to some purpose (if relevant to the job in question) is worth more than a random meetup group that met only once and when pressed the candidate clearly shows that it was invented for the resume. That's potentially 10 minutes or so the candidate could have talked about something else which is an actual strength.


Similar to how a much better developer has an advantage over me in an interview


I like to think people who are further into their career and keeping up with development have a github with lots of stars... the github doesn't make the developer, the developer makes the github.


Your statment is built upon the pernicious idea that all good developers should write code in their spare time.


I said 'stars' meaning they at least follow the market trends.


I've been super concerned about my empty stackoverflow and github accounts. This is reassuring. Thanks for sharing!


> So many people just do not have time for open source

On the other hand, it's hard to imagine someone senior enough (in terms of experience, not years) who haven't ever hacked a FLOSS dependency to do something it originally didn't.

Of course, it could be that the source wasn't on GitHub, or that author did effort to persuade upstream into accepting their changes and then repository was removed, or that the code is in the company's internal systems (which can be a good idea for various reasons). However, I'd say that most typical scenario is "you see it, you find it on GitHub, you fork it, patch it and leave it there - just in case". I have a bunch of those, and I'm just archiving those repos when I recognize they're not relevant anymore. It's not like I'm paying for those - and having an ancient fork had helped me once, when someone from my old place had a problem and asked me if I still remember how things worked there.

I mean, many (most?) of software engineers are directly working with free software every day. And, sadly, world isn't that perfect this software provides everything one might need without any tinkering. :) So, in a certain sense, "no time for open source" is a little bit questionable.

But, yeah, there are valid reasons why a good engineer may not even have GitHub account at all. Unless you're drowning in a torrent of great-looking resumes (and you're not GitHub Inc.), no harm in not making GH account a mandatory requirement.


> On the other hand, it's hard to imagine someone senior enough (in terms of experience, not years) who haven't ever hacked a FLOSS dependency to do something it originally didn't.

No, I find that pretty easy to imagine.


> On the other hand, it's hard to imagine someone senior enough (in terms of experience, not years) who haven't ever hacked a FLOSS dependency to do something it originally didn't.

I can think of plenty of developers working in non-OSS (either internal/nonlicensed or proprietary licensed) shops who, even if they have and work with OSS dependencies, and even if they might hack on them for the sake of the projects they work on, have never, by (or at least as a result of the requirements of) employer policy, contributed a thing back.

Of course, that's because I've spent most of my career in that kind of environment, which is why I've got very little on my GitHub none of which has a direct relationship to my paid work.


In the past year we grew our team from 6 to almost 30 and counting. About 10 of those 30 are senior engineers (between 8-15 years of experience). So far everyone's been very skilled and great to work with.

We work in GitHub, and of those who use their personal profile for work, all of them have "empty" profiles and no meaningful OSS contributions. They spend their free time with their family and in other hobbies.

People who hack on OSS for fun are usually good developers, but good developers rarely hack on OSS for fun especially once they get older.


I didn't mean hacking OSS side projects for fun, on free time. Why everyone reads it like that?

I meant, using FLOSS libraries for the actual job, during normal work hours. Depends on the industry, of course, I guess.


The trouble is, many of the people who responded to you had a legitimate point. I've done embedded development with OS libraries that I've extended, but there was 0% chance of me opwm-sourcing any of that code. I didn't even ask. Not everyone works in a field that is conducive to OS models. Consider that there are people who work in the military space who read this site, and the thought of open-source would give their managers aneurysms.


The trouble is, many of the people who respond


I mean, many (most?) of software engineers are directly working with free software every day.

I think there's many more working on proprietary software, we just naturally don't hear about it due to its nature. Open source is prominent only because it's public.


Yes, I meant that lots of proprietary software links with and relies on FLOSS components.

E.g. I open Slack (a random pick - it's open on my desktop right now), a proprietary software app. And in the "about" section there's a huge list of FLOSS libraries they use: https://slack.com/libs/desktop

Moreover, I'd say, every website out there (and web is a giant niche) uses lots of FLOSS components.

And for GitHub contributions, I meant that once in many years there happens to be a library that's out of date but otherwise useful, or lacks some nice feature.


As a recruiter I can answer this! I do not speak for all recruiters. As a recruiter who is also a programmer, my approach may be nonstandard.

* I want to see thoughtful README files. If the README is whatever was generated default by the framework and not edited at all, that's a huge groan and turn off and you lose tons of strength (credibility) as a candidate.

* I want to see your code looking pretty. Consistent indentation, run through a linter, good comments, and so forth. Would I be able to contribute to and maintain this code?

That's pretty much it. The most important thing that companies want to see is employment history, either at brand name companies or somewhere where you've already been doing the job they're hiring for.


This is awful, no offense. You're a recruiter, do you mind if I ask if you were previously a professional software engineer? GitHub is often, very often, for small personal projects where you don't spend a lot of time going through TDD or making sure the readme is up to date. Often mine are smaller projects I built to accomplish a specific goal (hello python script that clicks the "okay I'm still watching" button on all the required learning videos I've had to watch at work). It's impressive when someone has a substantial project or contributed to open source, but GitHub shouldn't be a negative signal.


I really don’t see why these things are relevant at all.

It’s a personal Github profile. Why would anyone add thoughtful readme’s or a clean coding style if they’re the only contributor?

I mean, those things are great of course, but not sure if I’d expect it on Github.


If you use your GitHub profile as part of your personal brand / marketing then these things absolutely are relevant.

As a developer in a professional context you'll hardly ever work alone or be the sole contributor.

Even if you use a GitHub profile just as your personal code repository code still is communication, even if it's just with your future self.

Therefore communication skills are crucial. A well-thought-out README file and consistent, readable code help others to understand your work. These aspects often are more important than what the code accomplishes.

Working, even efficient, but unmaintainable code is a risk. Ultimately, code is a precise specification of what the software at hand is supposed to do. If that specification is hard to understand it'll be much less useful.


> If you use your GitHub profile as part of your personal brand / marketing then these things absolutely are relevant.

The problem is when others assume this on your behalf. I would take a lack of proper readme as a signal that the repo isn't intended for viewing and judgement by others, not as a signal that the candidate has poor communication skills. If the repo is for a library that the author has published and is marketing for production use, then sure, but I'd wager that does not represent the vast majority of repos on GitHub, and to assume otherwise is foolish in my opinion.


I use to think this way then I started working in the real world with developers who coded and documented work code cleanly but had messy GitHub profiles especially because until recently private repos were not free. A lot of people don't care about perfectly formatted READMEs, commit comments, etc. if they're just hacking on the weekend on something small... and that's fine.

Nowadays unless you pushed your profile and repos hard in the resume or interview process, I couldn't care less if the rest of the interview went fine. Worst case scenario they're "forced" to write good documentation as part of the job - not everything we do at work is natural or fun for us.


My GitHub/GitLab profiles are full of hacky, ugly games written at game jams in 48 hours, often just by me or me plus some artist, with just one end-goal: to be able to present it at the end of the event. A README file is the last thing needed there :P


I 100% disagree. Even just saying that it was hacked together gives some context for

1) Why the code looks so unconventional

2) What you do in your spare time.


Context for whom? My target audience for my personal projects is myself. Any company that assumes their recruiting org is the target audience for my personal projects is setting themselves up for disappointment.


Sure, but we're in a discussion of what recruiters look for. If you only code something for yourself, that's fine, but if you want it to be taken well when job-hunting, you should make it at least minimally presentable (i.e., a recruiter can tell what they're even looking at).


in which case you wouldn't have put your github profile on your resume, so there is no issue. That's not what this question was about, thought.


Tell us in the readme if you make it public. You gotta think, who is reading this? That goes beyond documentation to code itself and any communication you do.


Repositories are public for a lot of reasons, a lot of which are not "I want to show this off to a potential employer". Let me give some good reasons, that's not an exhaustive list.

- It is the default.

- Free private repos are new and no one is going back and making things private.

- If you are working with someone it is many times easier to make it public.

- You want to share code with someone, public is easier than making them a collaborator.

Honestly I don't think a lot of people, if any, are reading the stuff I have on GitHub.


I put my things public on GPL out of principle, because there are some people playing those games, so I want to provide all necessary freedoms to them - even if nobody is actually interested in exercising those freedoms, because well, those are shitty jam games.


Of course, I can talk about that. Pointing it out in the README file during the game jam would be the worst use of time available there, though, and even now I have better use of my time than adding it to all of my past ~50 projects like that.

This profile is my personal space where I can put any junk I want to. When you're a recruiter randomly looking at that profile, you won't know the context. If you want to know the context, ask about it. It's not my responsibility to provide it in my personal space.

(plus, what I do in my spare time is the last thing the recruiter should be interested in, unless I mention it to them myself)


Personal projects can give signal about someone's interests, level of investment, sense of adventure, etc. They're also often an explicit relief valve from "dotting the Is and crossing the Ts" at work, so not a great way to assess professional/production code quality.

If I see a tower of inscrutable Haskell on someone's Github, that is a great thing: both that they have the urge to do it, and the good sense to scratch that itch away from the company's codebase.


I write verbose readme files with examples of how to use my libraries because it's what I expect of other engineers. I do the same for private repos.


Some use GitHub as a portfolio, it seems. Mine is/was mostly a dumping ground of half finished ideas in my college days.


The assumption is that if you have a personal github project then you're doing it because it interests you, you're passionate about it, and you're not doing it just for money.

If a developer writes sloppy code when they're doing it for passion, then that doesn't show them at their best. Of course we all have repositories, tools, or code, that was just thrown together to solve an immediate project but in general I'd expect something that is a labour of love - not a project for work - to be something that they'd put more effort into.


You're right -- if they don't feel like they need to have clean, maintainable code on their own personal work, why would they feel like they need to do it at work? That's a red flag.


Yes, sounds like BS to me.

But on the other hand I'm no employee and don't know the "virtues" employers look for, haha.


if you are linking to it in your resume than you are showcasing it. if you are showcasing it and it's a scrapheap, folks straight not going to be impressed.

I think the obvious thing to do is create a showcase profile and a scrappy scratchpad profile. keep the former clean and polished


Ostensibly, you put your code on Github for others to read, use, and maybe even contribute to. If you have a project that you didn't care enough to write cleanly, or even document in the most bare minimum of ways (a helpful README to contextualize the code) then why are you even putting it online? It's just going to reflect poorly upon you. If all your Github repos are as described above, people are going to (rightly) assume that's how you treat all of your projects, even those you are paid for.


That’s quite an assumption to make about intentions. Repository hosting is also a way to back up your code or make sure it’s available on multiple devices. Until very recently, you couldn’t do that and keep your code private on github without paying. So (unless they want to also maintain a bitbucket account) people dump stuff there for reasons other than explicitly wanting to share it with the world or show it off.


> Until very recently, you couldn’t do that and keep your code private on github without paying.

Ok, but now you can.

> people dump stuff there for reasons other than explicitly wanting to share it with the world or show it off.

Maybe, but that doesn't change the fact you are sharing it with the world and you are showing it off, and if you put a bunch of sloppy inscrutable code on your GitHub, people are going to assume you tend to write sloppy inscrutable code, especially if you don't contextualize it with a Readme. That's just the reality of it. The real big assumption here is thinking people aren't going to judge you by how you present your work online.


>>a bunch of sloppy inscrutable code on your GitHub, people are going to assume you tend to write sloppy inscrutable code

Im sorry, but wouldn't most developers have a large amount of code that fits this description? I likely have several mB of hacked python and bash scripts that were only intended to run once. But, I kept them in a repo because I occasionally would refer to an old script. But expecting a readme is a bit much, most of those scripts were lucky to get a descriptive file name, much less documentation. I hate doing documentation professionally, I'm certainly not stressing over it in my free time.


This kind of proves the point -- that if a recruiter is looking for a developer who values documentation, the state of documentation on a developer's GitHub is informative.

Personally one thing I've learned over the years is when it comes to referring to old code, having spent a few minutes writing out a description on how to run and configure it is a net time saver in the long run.


> That's just the reality of it.

Given that I don’t, and am in a position to hire people tells me this isn’t as hard and fast as you present it.


This whole thread started because people claim that they do exactly what I'm describing. I'm not telling you it happens, they are. Just because you don't doesn't mean others do don't as well.


I've been programming for years and I've had a GitHub account for about as long. Almost every piece of code I've ever written that wasn't for an employer or a school assignment has gone into a public GitHub repository. It goes online because that's what I do. It's the easiest way for me to share code with friends and others, to manage it across multiple machines, etc. There's no reason to put it in a private repository, especially if I'm sticking an open source license with a disclaimer like this attached:

THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.


That's well and good, but the thing people seem to keep missing is that git != github. Github is first and foremost a social network. You may keep your personal projects there, but they are still public and on a social network, and that means anyone who reads them will judge them.

The question before us is, how do recruiters judge them?, and the answer one has given is he or she looks at style and clarity in code. Others have come back responding that's not fair or relevant, but that's the reality of putting things into the public sphere; you are judged whether you like it or not on terms that you don't get to dictate.

Look at it this way: when you go out and about to meet someone, you might get all gussied up to present yourself in the best way. But when you go to the grocery store, you might not have done your hair and makeup, maybe you might be wearing day old sweat pants. If someone catches your eye at the grocery store when you're looking like a slob, your chances don't improve just because you put your best foot forward last week at the club.


It usually takes a lot of work to get a person to judge your work. Typically if you make a repository public, no one will give a shit. It takes a lot of advertising to produce any interest.

I have a repository with 4500 stars, and hundreds of thousands of visitors. Not one person has ever commented on the quality of my code, but many people contribute. Back when I had 100-200 stars, potential employers were impressed by the popularity and rarely commented on the code either. When I got any comments at all, it would be questions like why did I decide to do something one way and not another. No judgment there either.

Bottom line: nobody will ever judge your code if it's public, unless you work very very hard for it.


> nobody will ever judge your code if it's public, unless you work very very hard for it.

But this whole thread is about people reporting that they do just that for recruiting purposes.


I was responding to this question:

If you have a project that you didn't care enough to write cleanly, or even document in the most bare minimum of ways (a helpful README to contextualize the code) then why are you even putting it online?

If I put it online for a different intended audience then the question "how do recruiters judge them?" is beside the point.

I am well aware of the difference between git and GitHub. I alluded to some projects that I don't put on GitHub. Let me be explicit in stating that just because the project isn't on GitHub doesn't mean that I don't keep it in a git repository (or other version control, for certain employers). This has nothing to do with confusing git and GitHub.


Looks like someone spends a lot of time on his github profile. Has that made a difference in your job search?


>that's a huge groan and turn off and you lose tons of strength (credibility) as a candidate.

Toxic and off putting. You put too much weight on relatively minor things. It’s preventing you from fairly considering the rest of the candidate. You could be the one to teach them to do READMEs well.


Wow. This comment is deep. People who call themselves managers, read that last sentence 20x. This is what we need to do, can you?


Most big companies no longer believe in training but selecting. This is popularized in “strengths based” training sold by a handful of consultants.


So choose between:

1. A developer who doesn't respect himself first and foremost to write a README/maintainable code so that his future self and others can have an easier time.

2. A developer who cares about communicating his work to himself/others and making the environment easier for everyone to work for the future.

Right.


False dichotomy, and if you actually witness this first hand and only have two options in your candidate pool, you might need to spread your net a bit further. Also the original post was about READMEs only, so if they have unmaintainable code, the README really doesn't matter that much, does it?

Developers are at various stages in their expertise when they go looking for jobs. READMEs are nice but try not to let yourself get tied up with emphasis on a few signals that document the whole human. README quality is a pretty weak signal.

If you bring up the README in an interview, and the dev cannot find any motivation or acknowledge that it could be better, then maybe you might have to pass on them. My problem with your methods is that you get to this point without even opening a discussion.

READMEs are a relatively teach-able skill and in pretty quick fashion. Maintainable code, much less so obviously.

zepolen 37 days ago [flagged]

> README quality is a pretty weak signal.

It's a fantastic signal of what the quality of the code will be. Lack of a README indicates many things, including unmaintainable code either via lack of experience or rushed work.

But hey talk is cheap and you seem to know a lot - so how about you link an open source project you've published ;)


That crosses into personal attack, which is a bannable offense on HN. Please don't do this.

https://news.ycombinator.com/newsguidelines.html


>But hey talk is cheap and you seem to know a lot - so how about you link an open source project you've published ;)

I wrote tech docs explaining the jungle of IT systems that we were relying on at a hospital I worked at, and sometimes that included diving into old code. These were usually much longer than READMEs.

Having a README wouldn't have saved this code from needing to be refactored. Nor would it have really changed my opinion of the code. It hasn't been a reliable signal.

The hard part about documentation is keeping it up-to-date and accurate and not filling it with extraneous details and going off on tangents. A lot of the READMEs are written for quick bootstrapping and that isn't going to reflect much on your code quality. I care more about good documentation and that's harder to write than a README and a much better signal.

I don't have time to work on open source but it's clear my experience has been vastly different than yours and I doubt either one of us are going to come up with a peer reviewed reason for either side.

Turn this around and say "this repo has a README! surely it's really good and so is the code" and it makes no sense to give that much credit for something that really isn't impactful beyond the first few days of using something.


A programmer who by default adds a good concise readme to his projects is an indicator that the same will apply to the codebase, in that he will plan for the future.

I've seen it too many times, exceptions are rare.

A good readme is concise, it offers key 'bring me up to speed as fast as possible' information, nothing more. It's not documentation.

A good readme should include a quick bootstrapping info, but it's not enough, it should have a concise summary overview and list any important gotchas. As well as provide the procedures for builds/releases if apply. Links to relevant docs if exist are fine if the information becomes too large for the readme.

> Having a README wouldn't have saved this code from needing to be refactored. Nor would it have really changed my opinion of the code. It hasn't been a reliable signal.

See I read that and figure that it was actually a perfect signal - since that "bad unmaintainable code" lacked a good readme.

It's like the Van Halen requiring Brown M&Ms at their concerts https://www.snopes.com/fact-check/brown-out/ - I've found the README is one of the best indicators of the level of detail a person applies to their work.

> it makes no sense to give that much credit for something that really isn't impactful beyond the first few days of using something.

This is the attitude that I wouldn't be looking for when recruiting - a README has a ton of use, for helping bootstrapping new people to the code base - to even helping yourself if you do some maintenance on an old project and don't want to spend more than the minimum time necessary.

It's this forethought I'd like to see in a candidate, and that 99.9% of the time shows in the quality of the readme.


I cannot stand this kind of developer armchair psychology.


You're choosing between a person who didn't write a readme and a person who did.

Anything beyond that is unfounded bias IMHO.

(I have a lot of personal projects and I've conducted interviews)


Are developers only male? Your biases are really showing in these comments.


I don't agree with zepolen's comments at all. But can you guys who use "downvote to disagree" kindly please stop? You are just making Ask HN worse for all of us by turning it into an echo chamber. This isn't Reddit FFS.


In the long term any vote based community turns into an echo chamber.

The popular opinions win.

The users with unpopular opinions get downvoted/censored and are either banned/leave.

Leaving one opinion behind.

Moderators also a play a huge part in this - which is why it's only an illusion of democracy.

I wonder if it would be possible to create truly neutral discussion platform that doesn't end up as an echo chamber.


And fading out comments just because people here disagree with them is super annoying.

If 4 ppl disagree with something No one else is even able read it??

We shall all only say that which no one will disagree with.


That's lame, sorry. As a long-time hiring manager I do value a good readme if the project is meant for others to consume, otherwise if it's a scratch pad for learning who cares? And I could care less about how pretty their code is. I'm more interested to see if they are PASSIONATE about tech. While it's true that some folks don't have time outside of work my experience is that really good Engineers still play around a bit. They fork stuff. They try it. They may submit a PR that fixes something. They have some experimental repos where they put stuff when learning a new language. And yes, the rare one will have a fork of a project where they regularly contribute. I don't think you are looking for the things I look for in a candidate at all.


Let me politely call BS on that. There is no possible correlation between the "code quality" of my random github repos, which I usually start to learn/test/share something, and my general ability to write clean documented code. If a project evolves to have users, things shift.


I know people are being down on this comment, but it's important to know that people do this, which might help people get jobs.

Google is known to can applications if there are typos in either the resume or cover letter. Supposedly there is a statistical correlation that backs this. While this seems arbitrary and absurd it is important to know it's a thing so you can at least work around it.


I disagree. Bending over backwards to strange expectations and requirements is a race to the bottom.


Everything you say makes sense on the surface. But it scares me a little bit.

Do you ignore all my half-done prototypes and junky hacks and experiments?


Or your proprietary work you don't own IP to. Ironically, some look to GitHub to somehow correlate with employment history. Many employed are too busy sinking development time in source that's never releasable. Some companies may contribute to certain OSS projects publically but a lot of their core business code base is protected.


This is what I never understood. Say that I choose to spend my spare time in propriety code instead of open source or personal hobby code. It seems like some recruiters are making a tradeoff in indicating metrics here. They are saying that a good GitHub profile correlates so strongly with a good recruit, that it's worth a false positive of someone who spends too much time working on side projects and doesn't get as much done at work, and also this seems to be saying that people who spend spare time innovating proprietary code aren't worth finding and should be lumped into the weak coder pile by default. Is this a plausible deniability thing? ("How could I have known that guy would be a dud? I mean, look at his GH!"). This can't possibly correlate as well as people claim to success on the job... There just seem to me to be too many other complicating factors for this specifically to be any kind of decent metric.


Haha dude expects personal projects to go through a linter... You code?


I look for things to chat about. That's it. If there aren't any then I'll find other things to chat about.

It's almost like a dating profile. You use the items as jump-off points to start a conversation and get to know the other person better.


> It's almost like a dating profile.

That's a good description!


I would say that it’s more like a dating profile picture. You don’t have to add one, but if you do, it better be one where you’re smiling, not the one where you’re in hung over with a little bit of barf on your pajamas.


git commit -m "adding just_ask.md"

I'm riffing on a comment chain elsewhere in the thread about candidates who provide links to empty Github profiles.

Reading the comparison to online dating just makes me think of the dating profiles out there that have a couple of photographs, but nothing beyond the line "Just ask" in the summary/description field of the profile holder.

But agree, it's an interesting and apt comparison I think.


As a hiring manager, I am careful to avoid drawing any negative conclusions from looking at a personal GitHub profile, because I believe that sloppiness or "bad" code is actually just fine in the context of random personal projects. And of course not everyone programs for fun in their free time, so a lack of a meaty profile is not something I worry about. (I would sure hate for someone to judge me for a lack of comments in some random code I wrote a 2AM 8 years ago for giggles.)

But sometimes I can get a really strong positive signal from a GitHub profile. All else being equal, if a candidate has a meaty personal project, or has been an active contributor to other projects, etc, I can greatly increase my confidence that they're a good hire by reading through their code. It can sometimes show me that they're really capable in some dimension that's hard to assess otherwise.

In other words, a GitHub profile is not a make-or-break thing for me, but hiring is always based on information that's more limited than one would like, and sometimes a GitHub profile can provide enough extra signal to make a hiring decision easier.

I will say that one specific thing that is really helpful is the presence of simple README files for original projects that describes what they are and who the author is.


I am not a recruiter but help with software/firmware interviews where I work. When interviewing someone, any and all signals are very useful. For someone fresh out of university, they can show me their student projects. But an experienced engineer, their contributions are usually property of their previous employer and can't be shown.

To me, being able to see an interviewee's code is like being able to see an artist's portfolio. Alternatively, if an interviewee can point to mailing lists, code repos, etc, for open source contributions, that also is very valuable.

Some other folks in the comments are saying they use Github, etc, as a dumping ground for projects. Still valuable. In my opinion, that means you're interested enough in the project to at least save the code. Plus, even quick and dirty code can have valuable information. Does this person understand, for example, the common idioms in C, C++, Python, etc? (Specific example, using malloc/free/printf correctly, new[]/delete[], not using for i in range(len(foo)). Simple stuff like that.)

Note a repo containing "this is code where I'm learning this language, this library, etc" won't have the best use of the language, obviously, but will be a good sign this person is learning something new. It's another signal.

Just my opinion.


Noob question: Why is it bad to use for i in range(len(foo))? Because you can just use for bar in foo?


It's mostly a bikeshed and a signaling thing. Only a "noob" wouldn't know about enumerate(), right? The program could be brilliant in much higher level ways, but mid/senior only-knows-Python hot shot will jump on your anti-idiom like a dog on a dropped hamburger. Including such anti-idioms in your public code can filter out people like that.


Where are you meant to learn this?


Python's list of built-in functions is fairly small https://docs.python.org/3/library/functions.html#built-in-fu... (but to be clear, I wouldn't ding somebody for forgetting about one of them).


Reading other people's code (usually while improving it)


https://docs.python.org/3/

Consider that your iterable may not be a list, and may not actually have a "length" prior to its being consumed


Yes. Iterating over a range of integers equal to the length of an iterable is really clunky compared to iterating directly over the iterable. Plus, if you actually want to use one of the elements of the list, for instance, in the body of the loop, you would have to do foo[i] instead of referring to it as bar.


And when your actually need the index, generally you use enumerate(foo).


It's not "bad", but it's generally unnecessary. And breaks on generators.


I ask both Github and StackOverflow profiles. In Github I look for code style & quality, tests written, open source project participation (often good indicator of quality code when accepted). In SO I look for issues created as an indicator of one's struggles and overall expertise. Both profiles offer me a strong view over one's position and the data really helps me to filter out prospects.

95% of the times when they respond with "I don't have a Github|StackOverflow profile" they prove to be juniors or time wasters applying for a high salary. That's fine if I'm looking for a junior but they often apply for senior positions.

I trust the data on these two as I consider it to be really difficult to get by as a programmer without decent activity on at least one platform. HAving code out there, IMHO, adds better than any CV. It's just data but it helps me get a clearer view.


I seem to be in that 5%.

I wrote the /bin/ps program used by Linux. You might have heard of it. I maintained procps for about a decade. I also did a few Linux kernel changes. That all stopped around 2006 due to having 5 kids and working at a start-up.

StackOverflow and Github were both created years later, in 2008. I still don't have much use for either. Occasionally one will show up in a search for something.

There is no indicator of my struggles. When I had them, I'd walk over to the office of a more-senior developer and have a chat. Back when I started as a professional software developer, the web... existed. It wasn't a place with forums for asking beginner questions. One could turn to Usenet or IRC, but that was often useless. We used to buy books about computer programming by traveling to a bookstore, usually paying with cash.


I still buy books. I have modernized to the point that I will use a credit card on occasion.


Stackoverflow seems interesting as an inclusion of that level.

I've always used SO as a "read-only" source, and generally when I need an answer to a question not on there I ask on a relevant IRC channel. My github has quite a few OSS projects though.

Do you find there are any other devs like that?


I’ve never asked a question on SO. I don’t think most people should, because these days most questions will be duplicates, mistakes, or just too obscure for anyone to answer.

I’ve answered questions enough that I have enough rep to edit review queues, and probably 90% of what gets asked on SO these days is unnecessary.


No. It does not work as a filter.

But if you have a high amount of applications then statistically it may work for you. Same as throwing half of the CVs in the bin, as you only hire lucky people.

Github and SO data is a conversion point, not a filter. Sure I am also suspicious if no public profile, but never exclude as it often has valid reasons.

My personally github code is a lot more slapdash than my commercial github code. Nearly all of my commits in commercial github repos are private repos so not on my profile except in the activity graphics.

I have worked with and hired really good developers with a great public github profile and with lots of SO points. I have also worked with many very experienced and good developers with no github or SO presence. And I have met people with lots of SO points that I never want to work with again.

But if you got too many applicants you can apply whichever filter you want. It just wouldn't work for me, or my location (London)


I’ve never written a SO post, and barely have a github profile.

I’ve been coding since the 80s.

Some people don’t live on social networking - and that is, after all, exactly what those sites are.


I'm always writing there as it's the only platform where you have 80-90% chances of getting a reply within minutes. Docker, Kubernetes, Go, Elixir etc. were not here in the 80s.

You cannot learn new things without asking questions.


Dig into the source code / play around. Spend all of your time asking questions you will never learn anything or do anything.


That's how I learned.

damn kids and their internets.

;)


I find that most questions have been answered already. Unless one is doing cutting edge research, somebody has almost always had the same problem I'm having before, and written about it, and some guru has written a five page response on SO that breaks it down in detail and I don't have to ask...


I’m interested to know what kind of software system you work on that you “need” github code to prove that a candidate is good. IMO your hiring practices need to include processes that can evaluate a candidate based on their talent and experience, and not what do in their spare time.


> I trust the data on these two as I consider it to be really difficult to get by as a programmer without decent activity on at least one platform

So I guess you weren't familiar with the industry before 2010?

SO is the most frequented place with the least reliable, least trustworthy information on current topics that comes to mind. In fact, all in all it's a very mediocre site (the 'practical programming' parts). Its only merit is its discoverability via search engines. The pearls are few among mountains of rubble. I wouldn't expect a really competent person to waste their time with that.


I have a mix of things on Github: one might be positive, a few are ok, but most are crap. However I almost never ask important questions on SO. It’s almost all from languages/frameworks I’m playing around with, and I’m usually stuck on things I’d find elementary once I’m actually fluent. Actual work problems have too much context to make them things I can ask ok SO. So giving a thumbs up to a really good SO profile might make sense, but I couldn’t endorse caring if a candidate’s profile was unimpressive.


I’ve been writing code for over 20 years yet I don’t have anything that I can share in a public repo. My employer would sue me immediately. I don’t imagine I will be looking for a job via the “normal process” with recruiters and all, but if I did, would I need to put out stuff to github? Would I need to spend 6 months just writing random but nice-looking code so I’m not rejected due to not having github profile?

I think there’s a lot of people like that. Making github a mandatory requirement is strange.


You just tell the truth. Create a repo that says in the readme that you can’t show any code you write if you’re concerned that not having a profile is a problem.


> My employer would sue me immediately.

This is the first time I'm hearing about something like this. Why would your employer sue you?


Probably because of an NDA the OP signed. Companies don't like it when their employees share the company's profitable code with the world.


The main thing I don't want to see is a bunch of repos where you're just taking a library/framework for a spin. This isn't because these are bad in any way, but it can be hard to tell whether they represent your real coding approach or not, and therefore risk creating unconscious bias. Whereas I'm not going to hold it against you if you don't have a public profile.

Now that Github allows free private repositories, if you're planning to use your profile as part of a recruitment process, you're arguably better off only making your best work public. It doesn't have to be your best code, just something you're proud of and are happy to talk about.

This may run counter to normal thinking, but I have no way of knowing the extent to which my assessment is unconsciously coloured by seeing code that isn't representative of your ability, so I worry about the impact of that.


A recruiter or sourcer? In most cases (and I am generalizing here) basically a pattern-matching robot, so the same treatment as your CV. Have words and phrases they're looking for? Great! No? Meh.

Someone besides a recruiter? Might give it a glance out of curiosity and for conversation starter material, but if they're overly concerned about what's there or how much is there - you didn't want to work for/with them anyway. Honestly, most people that have been in the industry for any time at all quickly run out of free time and motivation for this stuff, and their github profiles will be rather barren as a result (unless they work at a company that publishes open source software, of course... but that's the exception not the rule).


I never look at them, at all. Some of the worst programmers I've met have got some fantastic portfolio/showcase work on their github. Conversely some of the best coders have no OSS contributions at all.

In all, I find it to be a fairly poor signal. I get a much better feel for someone from conversation alone, and some well thought out questions about someone's previous projects and workflow usually tell me all I need to know.


To heck with the recruiter. As a hiring manager I look for passion for coding and learning - and that your profile isn't brand new. If it has periods of no contribution I don't care - people get busy, have lives, etc. I don't hold the lack of a profile against someone, but an active profile that shows someone playing, learning, testing, and especially contributing is someone that jumps to the top of my list. A passion for doing and learning is something that cannot be taught. Faked maybe. But that shows up pretty quick too.


I'm not convinced that the Github profile is for recruiters alone. As someone doing hiring at the company, I want to see it myself.

So what am I looking for? Clean code that's more than just boilerplate. Comments, good logic, some sense of purpose. There can be garbage repos in there, too, but I expect there to be some that show off who you are.

In short, they want to see who you are. If your Github isn't showing who you are, you're not helping yourself by providing it to the recruiter.


I do this too, just to find stuff to dive into in the first 10 mins. The worst was when somebody’s github was full of tutorial projects that were done in 2-4 hours a piece by following detailed instructions.


In my experience they don't look your Github profile at all. I think mainly because the average recruiter have no competence to read it (sad but true). I had two so called independent recruiters pretending to read it, but when I asked what repository preferred and why I obtained an embarrassing silence. Worst, the same happened with a couple of programmers during the final interviews. Recently I had a letter from a big software house, declaring they was interested to my projects on Github, I asked some questions discovering that that someone else ( maybe some kind of automatic system) give him a suggestion, but that wasn't his direct examination.


We hire remote software engineers to work with Python/Django/Vue. We believe talent can be anywhere.

Many companies will ask you to invest a couple hours of your life writing some toy project as a code exercise (often unpaid). Instead, we ask you to pick any open issue in an opensource project and contribute a few hours to fix it (we suggest links to a dozen issue lists filtered by "easy for beginners" tags) - we call it "social code exercise".

Of course if you have such contributions already you can skip this step. We will analyse your github profile and give extra points to:

* any PR to projects in our technology stack

* good online citizenship

* constructive, reproducible bug reports

* well written documentation

* test coverage

We penalize:

* unprofessional, disrespectful or toxic behavior while interacting with the community

* non-constructive comments and answers

The rationale is that while pushing the envelope with an opensource stack we often have to report (and fix) bugs or implement lacking features.

Projects like Python and Django have a high bar for accepting contributions so any candidate able to land a PR is capable of basic communication in English, writing acceptable code, documentation and tests.


I've done it, really surprising a candidate. He was a developer for Xenia, an emulator for the Xbox360.

Right away, I reported several bugs. I found a problem in the executable loader, a problem with the division instruction, and a problem in the memory mapper. These could be considered software vulnerabilities if you accept that test code or a game might be hostile.

Despite the bugs, we hired him.

(now everybody will apply for the job so that I will find their bugs, LOL)


Love the question! I'm a developer who has optimized his Github profile as I could/thought it was best.

If it's okay, let me highjack one thread to ask, RECRUITERS, how would you improve further my Github profile?

https://github.com/franciscop


I do look at GitHub profiles when filtering applicants.

Mostly overall activity, consistency in commit messages, and actual code and PR.


As someone doing interviews, most of the github profiles I’ve seen have a bunch of forked repos with little to no added code. I don’t understand why people include a link to that.

A couple of times I’ve seen real code and it certainly didn’t hurt.


GitHub doesn’t do a good job with this. IMO they’re sometimes just a fork with the intention of a PR. Gotta see what they committed on top of it. When it’s nothing, I’d love to see them hidden or downplayed on the default view.


Some people seem to make an organization (e.g.forks-by-$username) and put their "unimportant" forks in there as a workaround.


Also, though limited and sometimes not great, "Pinned Repositories" is an easy tool to manage (easier than bouncing things between orgs and pseudo-orgs like `$username-forks`) and typically a strong signal for "I contribute to this".


Right, I forgot those are a thing now (and just pinned a few repos). They certainly help a lot with that.


When interviewing devs, I always check GH profile. If its empty it's usually a read flag (meaning that I will have to do more work during the interview). Coding samples, contributions graph, personal projects can push a candidate forward very fast.

Worth to note: GitHub itself does NOT matter, the contents your profile and you contributions do. Prefer GitLab? awesome! Just don't forget to put it in your resume.


“meaning that I will have to do more work during the interview”

Isn’t that your job as a hiring manager? Also how do you know that their github projects actually work in production? Do you do a through code analysis to evaluate performance bottlenecks or do you do a build-deploy-test do figure that out? IMO if you want to evaluate candidates on complete end to end projects you should give them assignments based your your evaluation parameters and ask them to explain their code/solution


Depends. Depends. No. In some cases.


So any candidate that doesn't have open source contributions can basically take a hike because they'll be viewed as lesser? Many folks have full time jobs working on closed source projects and don't do software engineering as a hobby, so if you're really putting them down because of that you will be missing out on a lot of talent.


1. No. 2. No, read my comment again.


A recruiter will take whatever you've posted publicly, and draw conclusions based on what you've presented. Whether you agree with it or not, that's precisely what will happen, even if they try not to.

It's on you to communicate your intent for things you release publicly. That means a README.md which explains what the reader is looking at. If it's just some half baked idea you've been kicking around, say so. Tell your reader what to expect, because if you don't, they WILL expect the wrong thing.

Effective communication is the foundation of any relationship, including work relationships. Show that you can communicate your thoughts. Guide your reader. Make it dead simple for them to see the best of you.

Beyond that, it's helpful to have a showcase "portfolio" project that is written as if you were presenting a finished product to a customer, including documentation, unit tests, ci, good design, the works. Showing that you can see a product through from initial design to release will impress people. Do you need it? No, but it will set you apart from the crowd.


99.9% of excellent people I worked with don't have a public GitHub profile. Most of the remaining 0.1% don't have anything interesting there, in part because their employer claims ownership of everything they create, so disclosing their side projects publicly is stupid. As the old Russian saying goes, "the less they know, the better they sleep".


Its incredible that anyone would accept such a horrid term.


All those high-paid FAANG jobs come with that term. Most others do, too, but if you're senior enough and they want you badly enough, you can strike it out.


As a rule of thumb, people who offer their own code publicly, are usually in the top 10% of developers. People who have ever contributed to another project, even if in a minor way, are in the top 5%. And people who contribute or develop their own projects with any regularity, are the top 1%. Exceptions exist, but this pattern emerges on a large enough scale.


No idea what recruiters look for, but when I'm part of a hiring process I'm particularly interested in evidence about how well a candidate communicates with other people, whether presenting their ideas or discussing options.


Like other people in this thread have said, I definitely look for projects or contributions that look interesting, or are job related, to start out having a conversation.

However, there is one thing I look for that will, usually, be a huge negative against the candidate. I have run into many candidates where their github projects are just 100% clones of various tutorials. When a github profile is only full of such projects it doesn't tell me anything different than what is on your resume, and my trust in the candidate goes down.

Other than looking at code quality, I actually look into their commit history and see if they are using the various best practices of git.


From experience, not much. I have an open source project with millions of downloads and thousands of stars on the top of my profile. Never once got asked about it across at least 10-15 interviews with both startups and large companies.


It should be on your resume or you may not be giving the attention it deserves on your resume.


It was in fact the top personal project on my resume (though below work experience). Dunno how I can give it more attention than saying the millions of downloads and stars.


To just toss ideas I changed my resume to be experience vs projects over work vs ‘personal’ (which could be undermining if one has significant project experience), where the experiences have multiple strong points and the projects are short descriptions. Take account importance of each item to you and recency for order. Millions of downloads is a great metric (github stars lingo is ‘meh)

Assuming you have put lot of commitment or hard work in it maybe there’s more to talk about :p. I personally have personal projects I rate higher than previous employment experience so this isn’t applicable to everyone.


I was approached by an Amazon recruiter that seemed to have used some sort of algorithmic tool that had keyed on specific information about in my github profile. Specifically, it mentioned that I had more than 1 public repository with 'stars' from more than 2 people and 1 or more forks. I asked the recruiter about this and she mentioned that she used a tool like this to find potential recruits. It didn't sound like it was a company-wide thing, though.


I glance at their code to see if there is something that can say whether they are very good coders or terrible coders. Usually you can't say anything though.

Something I really try to find is how they communicate when writing bugs, responding to questions, differences in opinion etc. If you find someone who can respond to an angry user of their library because their feature wasn't implemented, or that can politely turn down a PR for example, that's really good sign.


Depending on the exact environment and position, "I don't use GitHub" may actually be a positive response, because they might signify someone who is less likely to accidentally publicise a company's confidential IP. Likewise for anyone who "stays dark" online, in social media and such.


I would hazard a guess that most pure recruiters aren't looking at your GitHub profile other than ensuring that you've provided one. The hiring manager or interview team, however, might be interested in it.

Here are some things that I check for in a GitHub profile, as a hiring manager and as a recruiter (hooray startup roles!):

1. Repos that aren't just forks. I've seen plenty of profiles where the majority or entirety of repos are forks. Unless there's some annotation that talks about contribution to those projects, I assume that those forks don't contain any actual development.

2. Code past the boilerplate. A lot of projects start with enormous boilerplate, checked-in node_modules, and large-app scaffolding. The README should have a pointer that says "actual code is in src/app/site" or something, otherwise I click around for where the commit message is something other than "initial commit".

3. A real README.md. Bonus points for README.md in the subdirectories.

4. A "real" photo of you. LinkedIn profile pictures tend to be very professional and buttoned-up (sometimes literally). Most GH profile photos in my experience are a closer of the real person though. You're more likely to see a casual photo, a hobby, someone's dog, a photo of their art, etc. When that person is working with you, they're going to act more like their GitHub profile photo than their LinkedIn profile photo. Conversely, when I don't see a profile photo, that's concerning.

5. Nothing too boring, or too creative, in the name. The era of screen-name judging is not over, and you will get judged based on your GitHub handle. John35082192 makes me think that John reluctantly created a GitHub account and loathes using it. XxCodeMurdererGoatSlayerJohnnyXx makes me think that John is a bit of a weirdo, and his code reviews may be... uncomfortable.

6. Stars. If your real repos have real stars (or even forks), that means that not only have you creating something cool, but you've created something useful, and marketed it at least somewhat well. NB: repo stars are not expected for professional-profile style repos, only if you're creating something for an actual OSS community.

7. A real github.io page/repo. Maybe this is the basis of your professional profile, maybe there's a link to a personal website in your profile, but I am interested in seeing how you present yourself beyond which repos you show first.


What’s wrong with not having a profile photo?

FWIW, as a woman, I leave my photo off github to avoid the assumptions people make when they know someone’s gender. In fact, there’s research to back that up: https://arstechnica.com/information-technology/2016/02/data-...


Same here; I'm woman, and over 50. I use a landscape snapshot from an enjoyable daytrip for my profile photo. Is this, like removing graduation dates from a resume, an undesired tell?


Most companies would discriminate in your favor for both reasons. I suppose it is unpleasant to be the token woman or the token old person though. It sucks to suspect that you are being kept around to meet somebody's quota.


That’s a fair criticism. Having any kind of profile image I think is preferable to the default, because then it distinguishes you from someone who signed up a day ago. So it doesn’t have to be a photo of you, it could be a photo of your city, pet, some hobby etc.

Just something to humanize the profile, even if it doesn’t gender the profile.


Or you could conclude that this person is in there to just get stuff done, and couldn't be bothered with wasting their time to fill in their profile, or was concerned with how their data was used by Github, or is a woman, or is part of a minority group that couldn't possibly benefit from posting a photo, or... There's all sorts of reasons why people don't post their profile online, and factoring this into your hiring criteria is about as valid as using graphology.


Very much agree with the point others have made about photos being a bit problematic. I know that you don't mean to be doing this, but judging people for lack of a photo on their profile is an unintentional form of gender discrimination (and possibly race, religion, etc. as well), because of the different incentives that people have to post photos. Women who post photos get creepers, lots of people of color have reasons not to post photos to avoid other kinds of bias (and I imagine similar points with respect to, e.g., a Muslim person who wears religious headwear), older people probably have a disincentive to post photos because of the massive amount of age discrimination in tech, etc.


It feels kind of weird that large parts of the world have stopped to do profile photos on CVs for fairness reasons, but then you expect people to have photos in the links they put on said CV?

EDIT: and re forks: surely regular PRs against other projects would also tell you something?


I definitely would expect real photos of the person on LinkedIn, and everyone I know who hires will look on LinkedIn as a confirmation of the resume. Not sure if this is a vector to enable bias or not, but it’s a reality of hiring for many.


I don't have a pic on my LinkedIn for that reason CV's with photos can be discarded just for that in some countries.


> 1. Repos that aren't just forks. I've seen plenty of profiles where the majority or entirety of repos are forks. Unless there's some annotation that talks about contribution to those projects, I assume that those forks don't contain any actual development.

Perhaps you are not aware of the workflow many fs developers use when creating pull requests? You start out by forking the project's repository and create a branch in it where you put your bug fix. Then you submit a pull request using the github UI. End result is that your profile contains a lot of repos appearing to never have had any activity unless you dig into them.

It also appears that you are using candidates github profiles more for finding negatives rather than positives, which is disheartening.


> Conversely, when I don't see a profile photo, that's concerning.

Ever considered how women or non-whites feel about this?


The only company I worked with that made much use of it was open-source inside and out. They mostly hired developers that had been OSS contributors.

They'd use GH to evaluate coding style and as a proxy for skill level.

It was a terrible proxy IMHO, because a lot of the projects or contributions they were looking at were years old. (People change and grow.)

Anyway, if there's a takeaway here it's this: Delete old repos that you wouldn't feel comfortable putting forward as examples of how you currently work. Or refactor the code to match what you'd currently do. Or don't maintain any public GH profile, frankly -- there are plenty of great engineers out there who have a family and no time to contribute OSS.


Not to get off topic but...Recruiters? Haven't I heard more than one of companies that (promise to) analyze code for quality, etc.? That is, resume aside, they can grade the quality of code / coder?

I'm not sure how often these come into play, but I would also bet that outfits that do don't brag about it.


Speaking as someone with a decent github profile, we need to get out of the notion that github profiles are important. Anything substantial or noteworthy of interest should really be on the candidate's resume. Even personal websites are more worthwhile going through than github profiles in my opinion.


I'm on the technology side, but I review and interview candidates pretty regularly. Unless you have an actual notable repo with stars or something (and I've literally never seen a candidate with stars on a repo) then I don't care. Maybe if you have a cool picture of yourself?


It's a good arena to discover talking points especially if the candidate is not a good interviewer. There are a lot of good engineers who simply do not interview well and this is a fantastic way for me to pry some positives out that may otherwise have been missed / glossed over.


For me, my github profile shows my personal interests. I work on a bunch of robotics stuff for fun, and then try to get jobs related to things I like. So if the job is a good fit the github profile serves as an extension of my resume. At the very least it shows my passion for the field.


Tech recruiter here.

The list of repos give a rough idea about the tech stack the person prefers.

That's it.

If it is Javascript or Python (I can read & assess the quality of the code of these languages) I sometimes dig into some project, if it is not a fork.


I don't think they look at to GitHub profile at the very first place. I see that most of then even not checking what is written in my linkedin profile.


Github commit history is an excellent measurement of your willingness to work overtime for free. Of course companies will love you for that


I've never met a recruiter who discussed my GitHub beyond asking for the link. As for interviewers, my GitHub has only been brought up a handful of times.


Related question: how many recruiters actually look at GitHub pages? Does this number change if one is linked in the resume they’re looking at?


Yes, please put your GitHub, GitLab, etc, profile on your resume. When interviewing, being able to see someone's code quality is golden.


But do you actually look at them? I have my GitHub profile in my resume, but I’ve never once been asked about anything on there, nor has a recruiter let on that they had looked at it.


But actually a breach of contract in most places - you know "gross misconduct" as HR call it.


i know this from tons of experience.

Everyone asks for github profile but no one actually has the time to analyze it. I asked an interviewer about it and said he admitted he hasn't looked at it.


Since most people’s work is going to be in private repos, Ive always thought the most consistently valuable signal is the contribution graph.

But that’s just my opinion.


And some of us are contributing to private repos hosted on bitbucket or gitlab. Just saying.


For sure, I'm not saying it's a universally valuable signal, just the most valuable one relative to other signals on a github profile.


Or on locally hosted infrastructure.


> Since most people’s work is going to be in private repos

Is this generally true?


Yes


An email address, in my experience.


- Stars

- Green squares


Why do you need GitHub? There are many places where you can send a resume. here https://uk.jobsora.com, for example. There are a lot of vacancies for any choice


Suckers.


I want to know what other people will see when they look at my employees GitHub Account. If I see nothing that concerns me, I move on. All of our companies code is private so an empty GitHub is not concerning.

Daily stars in the seize_the_means_by_any_means repository is going to get your resume tossed.


I don’t understand the second paragraph. Could you explain?




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: