Awesome idea. I could imagine a marketplace for resume themes that is based on this. Would be easy to switch between different designs to see consistent details.
I've actually written my resume in markup for a while just so that I could put it on a nice dynamically driven site. Sort of a fun weekend project (no, it's not hosted anywhere).
While I strongly doubt that this will ever be a standard, I think it's nifty, and potentially useful. It opens up easy, pretty resumes, which the world really needs (Note: I'm not being sarcastic. The number of mountains-of-text word document resumes I've gotten in the past few weeks is too high).
> It opens up easy, pretty resumes, which the world really needs
People have been doing XML+XSLT for their resumes for a long time, yet it really hasn't taken off in a standard way for whatever reason. Not sure this being JSON-based will change that. I guess I'm wondering what this solution brings to the table that previous attempts didn't.
Isn't the look of your resume one of your competitive advantages as job-seeker?
Sorry I really don't understand the use-case. Having an API is good for styling (as you say), or doing some soft of programmatic transformation to data. I am having trouble understanding the need to do either for a resume.
Maybe it would help as metadata for a search engine, but in that case I think a plain text search would be just as effective?
I think json schema is a really nice thing to have and I'd like to see more people adopt it, but I'm having trouble coming up with the point for this use.
Came here to say this. I feel the same way — even about the schema. Having a poorly-organized or thought out resume should be an immediate signal to employers. This eliminates that.
Of course, this is not to imply that having a really well-done resume is really worth much either.
I looked over the website briefly, and I couldn't find an answer to this question so I'm going to ask here. I am not asking this tongue-in-cheek, these are serious questions:
* By "open source standard," what do they mean? I don't see any evidence they're on an RFC track, so this would be "standard" in what way?
* Why? I've never needed a resume in JSON format, but that is anecdotal. They don't really say why they're pursuing this on the site, except why they chose JSON.
Good luck, either way! Making something isn't easy, so I applaud any effort to do anything.
Assuming this takes off and everyone uses it (you be the judge of those odds), I can see a standard format being really useful for both employers and job board websites.
Let's say you had a bank of resumes -- you could easily find all resumes that know Java and have had at least 2 jobs and an active GitHub repo, and automatically send out a request to their references.
Currently, you have to read an unformatted PDF and extract the info manually -- it's not the end of the world, but it gets tedious if you're dealing with lots of resumes.
It would be really useful for the people making the resume also. Right now the current mainstream advice is to use Microsoft Word for creation and editing and then (typically) to submit as PDF. Both of those document standards are proprietary and opaque. If you two computers that don't have the same operating system, you're probably SOL for tweaking your resumes across computers as well.
You are right, I am still researching how to manage a standard formally hence why the site wasn't meant to go on HN just yet. If you have any good advice or links to advice for writing and managing standards that would be fantastic.
For example, what is an "RFC track"? I was also hoping that Github Issues might be able to replace the mailing list style of managing standards, what do you think?
Hey guys, we weren't actually ready for a lot of eyes to see this project. We were hoping to keep it small and get some feedback on important decisions about the project's trajectory.
The plan is to create a standard that developers worldwide are comfortable enough with to build upon.
To give the standard some traction, we have built tools to export to other formats such as pdf, txt and doc.
We also thought it would be cool and useful to have an NPM like system for resumes. So we built a CLI heavily inspired by NPM, to init and publish your resume to the jsonresume.org registry.
The themes right now are in bad shape, and we are looking for designers who would love to jump in during the early stages. We are thinking of building a theming version manager on top of NPM to take advantage of versions/distribution and also allow theme developers to implement their theming systems however they like (erb, mustache, md etc).
People with comments about the standard semantics and structure are encouraged to post their ideas to Github issues. -> http://github.com/jsonresume/resume-schema We also want to formalize the standard a lot more over the coming weeks.
If the project can be pulled off professionally and driven by the community, we believe that working with resumes will be fun!
Edit: Here are some of the reasons why I personally think JSON resumes will improve HR.
(trying to figure out bullet points)
- Better searching and filtering than PDF/doc. Making recruiting a tad easier.
- Applying themes will be a lot easier.
- Applying for jobs will be easier. Instead of filling out complex forms over and over again services might start allowing you to auto-fill with your JSON resume.
- There are many services that ask for your career history such as LinkedIn, Angel.co etc. These could be autopopulated or synced with your master copy.
- You can update your resume programatically so Github projects can be inserted and any other online certificates that you might want automatically added to your resume like Mozilla Open Badges -> http://openbadges.org/
- The comment section suggests that lots of innovation could arise from it.
----------
Make sure you try the CLI! sudo npm install -g resume-cli
I would just like to say that I think that this is a great idea(despite agreeing with others here that XML + XSLT would seem like a more logical choice). I hope it gets some traction in the long run.
I've posted an issue on github [0][1] mentioning that "firstName" and "lastName" is probably not a good representation of names. I don't actually know what the solution is, but this article [2] gives some great reasons why we tend to make incorrect assumptions about peoples names, which have the possibility of excluding some people form our tools based on their name alone.
I agree with the names. Even just the ordering of first/last name can be difficult. I come from Korea where last name always comes before the first name in a formal setting.
Perhaps you should just require "full name" which the author of the resume would decide for him or herself.
or, have both fields, which the author needs to fill in. This makes it easy to parse the data, but also makes it readable by humans, by separating it into different fields, for different purposes.
Regarding names, I've heard of two solutions that cover enough edge cases to be suitable:
1. Asking for "Given Name" and "Surname" clears up most issues with cultures like Korea (where surname comes first).
2. Simply have a "Name" field. Accept any Unicode characters. Hope for the best.
If someone has a name that cannot be represented in written characters or cannot be rendered in Unicode (which would be amazing, since Unicode covers ancient dead languages and fictional languages like Klingon) they probably have more pressing issues than trying to serialize their resume.
Mostly, people ask for firstname and lastname because they want to call you by one of them. you can avoid this problems by having a "Full name" and a "what do we call you": my full name is "Paul Biggar" but you should call me "Paul".
In Germany it's not really common to call people by their first name (IT is an exception), but I would hardly put "Mr. Lastname" into "what do we call you". It all depends on the context, even in the limited scope of a resume.
If they're just looking for something to say on the other end of the phone when you answer, isn't "Mr. Lastname" the appropriate thing to enter in that box?
No, it's not, because calling someones phone is also culturally dependent. Because in Germany, when you are calling someone, it is expected that person picking up the call will speak up first and introduce themself. Something like: "Herr Mustermann, hallo!".
You see, if you are calling person from Germany, knowing how to address him is not enough, you shall still know how to make a call. If you don't know that, you'll be rude anyways, and if you know that, you'll also know a proper way of addressing persons in different cultures.
I built something similar a couple of years back when I was job hunting using a json and Angular.js, I called it modern resume [1]. Live example can be found here [2]. I got tired of having a resume for each format - plain text, html (website), word document, PDF. Every change had to be made in all the places. I wanted to have a single source of truth. This kind of standardization would be great!
I am very interested into your thoughts about LateX, why we need another "standard" if we have LateX? Do you provide something in addition which is not possible with LateX?
but is LaTeX machine readable - can i be given a latex document, and extract the essential data from it and transform it into some other format/structure that i can use elsewhere?
I think we might be conflating 'machine-readable' and 'well-formed/structured' here...
What they're proposing is structure, not machine readability... Technically, with the state of OCR and other methods, many things like LaTeX, PDFs, .DOCs, etc are all perfectly machine readable -- the problem is getting the information out in a meaningful way.... that's usually done by standardizing on structure.
When it comes to specifying structure, XML and JSON are pretty much the front-runners (at least I think so), and since XML isn't so popular lately (since it's so verbose), JSON is in the spotlight now
It depends on the machine, if you're feeding your picture to a machine with image recognition capabilities, it might just be able to tell that it's your ass. Some pretty big companies are working on just that. (not on figuring out if it's your ass, but image recognition in the general sense)
The big picture is to make as many things as possible "machine readable" (things more difficult than resumes), and use machines to work faster than humans ever could.
Machine readability, unless I and the dictionary are mistaken, is related to whether or not you can input the data from some physical medium into a computer. It's not the same as asking whether something you read in makes sense, or is easy to parse, or is well-structured, which is what their idea is related to.
Other than the fact that most of the things I noted are ALREADY in a state that is computer usable (whether it makes sense to humans looking at computers is another question), I was trying to point out that getting the information into a computer (A.K.A. Machine readability) is not the issue we're struggling with now, it's structuring, characterizing and understanding the information.
I mentioned OCR because it's used to parse resumes to find important bits when other methods fail (or someone submits something crazy like a scanned version of their resume instead of the file) -- something that wouldn't be necessary if there was a standard (like is being proposed) to adhere to, that people could semantically find what they wanted from.
Also, if you read closely, I said with the state of OCR AND OTHER METHODS... OCR does not have anything to do with the machine readability of other methods, it's just one method people use to extract data, or for machines to "read" the document.
I've been working on a LaTeX-based resume builder (link in profile) and I could see something like this being useful for allowing users to take their data with them and move it between services. Anything that reduces the time it takes for people to input information and see the resulting image/pdf is worth looking into, so I'll be checking this out.
You could use the "correct" spelling of the word: Résumé.
It took me ages to figure out what this actually was, because your non-standard "lazy" spelling made me think this was about resuming interrupted downloads/transfers of generic JSON data. (Possibly by doing a partial parse of the data that you have got, or over a non-HTTP protocol, otherwise why not just use HTTP "Range:" headers?) I had to unlearn that before the light-bulb went off.
At least in the UK - and probably other countries in the Commonwealth - we almost exclusively say "CV" ("curriculum vitae", literally "course of [my] life"). "Résumé" is not well-understood here.
I'm also from the UK, and although I'm part of the "we" who normally use the term CV, due to the incredible pervasiveness of USA culture, I (and probably most of the people I know) am perfectly aware of what a résumé is. I just never expected to see it spelled "resume".
I mean, résumé and resume have the same French root, but in English - even American English as far as I can tell - they're totally different words! Even the pronounciation is completely different. So why would someone spell résumé as resume, especially in the name/title of a project about them?
How is that going to do anything except cause confusion?
Non-English loanwords enter the English language by a process of naturalization, [...] there is a tendency for accents and other diacritics that were present in the donor language to be dropped [1].
We have words with the same spelling but different meanings and pronunciations all the time - so called Heteronyms [2]. Doesn't seem that confusing to me. To me it'd be pretty weird if people who understood the word rôle were baffled by the word role.
Really? I've always thought of heteronyms as one of the most stand-out features of English that exemplify its confusing inconsistency. More so than the homophones, because it's harder to think of the "other" meanings if you've got the wrong pronunciation in your head.
In reference to the passage you quoted about diacritics, if only you had read as far as the next-but-one paragraph, you might have noticed: "Words that retain their accents often do so to help indicate pronunciation (e.g. frappé, naïve, soufflé), or to help distinguish them from an unaccented English word (e.g. exposé, résumé, rosé)."
Résumé, resume, and resumé are all accepted spellings in American English. As noted by others, many countries use the term C.V., which is likely to be a larger source of confusion for people.
Part of this is likely that many Americans do not have an easy way to type the accented 'e' character. (Short of copy/paste, I'm not even sure how I'd do it. Friends who have Macs have it easy.)
> Make sure you try the CLI! sudo npm install -g resume-cli
Regarding that: I recently reached the fed-up point with sudo or not sudo to install nodejs app and the mess it leaves behind when using sudo for just installing some local binaries.
I stumbled upon nvm[0] when installing docpad:
> The above should not require sudo (the # means sudo). If it does, we recommend reinstalling Node.js so that it doesn't. Otherwise you're likely to run into permission problems in the future. Follow the Step 1 instructions to reinstall Node.js without requiring sudo.[1]
It makes npm installs everything under $HOME and never needs to be ran with escalated privileges. `nvm install X.X` and `nvm use X.X` allows switching between node versions and installed packages.
Your References fields need a section for contact details - email or phone. Testimonials are worthless by themselves.
Edit: references should also have an optional 'organisation' field and a 'position title' field. "This reference was the technical lead at Foo Corp, my second-last job. Contactable here"
Random Project Idea - use this as part of an API which scrapes multiple sites (like Linkedin, Github, Monster, what have you) and builds a single, canonical resume from the various sources using this standard.
I don't know that the themes, necessarily, are that useful (I don't like the idea of implicitly connecting presentation with JSON like that - i'll make my own themes thank you) but I do like the idea of a common transport format for resumes.
To clarify, I meant that when looking for a job it is a pain to retype your resume multiple times (because having a human look at candidates apparently isn't a thing, especially at larger organizations). Having a standard format, supported by many employers would have made the process much easier.
I think this is a great idea. I love the idea of a universal data format for resumes.
However, I'm not at all convinced that JSON is the way to do it. I think the way to do it is with XML and XSLT, although I already can hear the cries of "But XML is yucky and XSLT is hard." But by using JSON, we lose some semantic markup and end up having to parse it to create some semantic markup.
Still, I hope this, or something like it, takes off. This just needs a web-based GUI tool to publish a resume so that non-geeks can make it happen.
It was a very hard decision to make and starting such a movement is unfortunately from my viewpoint much more than making rational choices about the technologies. We wanted to have a low barrier to entry and also take advantage of the large ecosystem of libraries. At the moment the majority of web technologies are using JSON so we believe that to get this standard off the ground we will need to go with the grain.
LinkedIn actually exports into a Microformat called hResume which has been around for a long time but has evidently not been able to amass a large developer community. This was another reason we decided to not start with XML.
> LinkedIn actually exports into a Microformat called hResume which has been around for a long time but has evidently not been able to amass a large developer community. This was another reason we decided to not start with XML.
So, not trying to be rude here, but have you wondered why it is that an XML resume format hasn't taken off? Other than it being based on icky XML? I mean XML+XSLT has been around for a loooong time and can more than handle exactly what this format sets out to do, and yet a standard XML resume format hasn't taken off.
I'm not entirely sure, something to do with XML not being human readable maybe. All I can really say is that I don't use XML most of the time is because I'm lazy, JSON.parse() is just too easy but I also don't know XML that well and I believe that is because the large majority of RESTful interface's I work with are JSON.
Though I would love to hear someone else's thoughts on why an XML resume hasn't gained critical mass.
The trick with XML is to learn XSLT. The trick with that is it's really a weird language that uses recursion and acts almost functional, but not. But if you learn that, you don't have to parse anything because you just "style" the xml.
Here's a silly playground I wrote to show my students XML.
There's nothing particularly "icky" about XML. That's just a silly hipster meme. XML is just a tool, it makes sense in some places, less so in others. Same deal for JSON.
I mean XML+XSLT has been around for a loooong time and can more than handle exactly what this format sets out to do, and yet a standard XML resume format hasn't taken off.
It's just as likely that the answer is "a standard resume format hasn't taken off" where the serialization format is irrelevant. Maybe not enough people are interested in working with documents and knowledge at that deeper, semantically meaningful level. Maybe sending resumes as PDF or MS Word or ODT and using simple keyword extraction has been "good enough" that nobody has felt the pull to use a better system?
What I mean is, it's entirely possible that this will fail to gain adoption for the exact same reason that the XML based one(s) did, and that the difference between JSON and XML is actually irrelevant. This is, of course, just speculation on my part. In any case, I hope this (or something like it) gains traction, since I'm a strong proponent of publishing semantically meaningful content, whether it's in RDF/XML, JSON-LD, SGML, DAML+OIL, YAML, Texinfo, Markdown, Hytime or hieroglyphics chiseled into stone tablets. :-)
Agreed. There is one difference with json (and yaml) though: it truly is more human writable (and readable), and by extension provides nicer diffs. I'd be much more happy to maintain my resume in json than in XML, even if I might be more happy exchanging/submitting resumes with (one of) the existing XML standards.
But all that's needed is a script that eats XML resumes and outputs json resumes, and vice versa.
Just like I'd rather write markdown and read (rendered) html+css.
That said, on the subject of XML not being "icky": one resource for having fun with XML: "Program Generators with XML and Java" by J. Craig Cleaveland (Prentice-Hall, 2001):
Hm, looks like there might be bit too many dependencies here for my taste:
npm install resume-cli
du -hs node_modules
103M node_modules
All this, and it doesn't provide line numbers when reporting errors due to an extra comma in the json file? Nor does it (yet) have LaTeX output...
Still, can't complain, 5 minutes and I have a resume draft that doesn't look half bad in html, and is presumably entirely reasonable to customize (not to mention it's all inn a json-file anyway, so one could just use what's in ones actual resume, and shove the json through pretty much any scripting language w/templates and generate something reasonable).
Sorry about the large dependency size, we were mainly rapidly prototyping and didn't expect so much usage. That size will drastically be reduced and we hope to have better error reporting.
Currently have 60 fresh issues on Github for the schema so after we digest those we will be improving the CLI once again.
> There's nothing particularly "icky" about XML.
> It's just as likely that the answer is "a standard resume format hasn't taken off" where the serialization format is irrelevant.
Just to be clear, I was taking the same position you were...
I honestly don't like XML, not that there aren't very verbose tools and standards to make it easier to use, but intrinsically you can't look at XML file and know how a codified representation should look like... if you have an element it will have properties and child elements... said child elements may contain children, strings, or ??? ... JSON maps much more naturally to an object model in a given language. That's just one way that by example you can show JSON, and know what you need to make.
Not to mention, XML is much more verbose, and when you wrap it in things like ws*/SOAP it gets really ugly really quickly, and if you don't map everything, it gets complicated and often fails. When you publish a service using one toolkit, it's often difficult to use the service in another toolkit (example, using Java services in .Net gets really painful at times). Unless a lot of detail is done, or an API client in that client's environment is provided.
This isn't about XML specifically but about the environment it tends to create. JSON is typically simpler to write, easier to code against and more forgiving in the tooling than XML is. Much like the differences between a scripted environment and a statically compiled environment.
wait... I don't understand comments like these. You're not the only one to make these claims, but I'll address yours specificially:
> but intrinsically you can't look at XML file and know how a codified representation should look like...
Let's compare:
<book>
<title>How To Be Awesome</title>
<subtitle>Surviving on HN Posts</subtitle>
<author>
<first_name>Max</first_name>
<last_name>Power</last_name>
</author>
</book>
1. need a schema to be useful as a standard
2. express their hierarchy
3. don't specify data type (although I could add that info to both if needed)
4. have a level of annoying to them (commas, colons, angle brackets, etc) which modern IDEs have taken care of for us.
> if you have an element it will have properties and child elements... said child elements may contain children, strings, or ???
I need to use documentation to use `package.json` files too, because each node may or may not contain children. Node graciously tells me if I missed something. Docbook also tells me if my XML is malformed. I see no difference here,
> JSON maps much more naturally to an object model in a given language.
It maps to a hash/dictionary. I'm not sure that qualifies as an "object model" unless you only write JavaScript.
I'd really like people to understand that XML is, like HTML, really great at describing and marking up content so that something else may process it.
You could also have <book title="..." subtitle="..." >... There's no real canonical representation of what an object should look like... can you have more than one title tag for a book? If you look at your xml, you don't know. Can you have more than one author tag? from the xml, you don't know... both of these, you do know looking at the json.
> We wanted to have a low barrier to entry and also take advantage of the large ecosystem of libraries.
That doesn't make sense. You wanted a low barrier to entry, but you have to mark this up yourself with JSON, install command line tools, etc. Seems to me a web app that I fill in some forms and generate a page on your site would be the quickest way to lower the barrier.
> At the moment the majority of web technologies are using JSON so we believe that to get this standard off the ground we will need to go with the grain.
I understand the desire to use what's popular. But I just don't think it's the right choice. I'm interested to see the implementation of how this is turned into a PDF though.
Right now, though, it does sound a bit like "every problem is a nail." Perhaps it'll become more clear to me as I dig in more.
Again, I do think the project is very cool and will be encouraging my students to take a look at how they can use this to promote themselves.
Ahh I thought it might be better to start the movement at the developer level before asking regular people to opt in. So JSON was meant to be the common denominator for developers, hopefully they build tools that makes the process less technical for the general population.
We actually had to pull our PDF converter due to bugs and are currently just using a service called pdfcrowd.com.
Though the general idea is that HTML can be passed through WebKit and rendered as various image formats and PDF -> http://wkhtmltopdf.org/
Here is a link to what your first idea might look like, it automatically generates forms based of JSON specifications -> http://jeremydorn.com/json-editor/
I'll start adapting resumebeacon.com to support jsonresume. I created my site as a LinkedIn resume generator, so integrating a JSON formatted feed shouldn't be much trouble. I'll start work on it tonight and post it to "show HN" when it's done.
Hey Paul, Loving those themes. I would sort of recommend waiting until the specification grows some legs over the next week but you could go ahead as planned and just mark what you have done at v0.0.0
It's just as doomed as all the other attempts - recruiters don't generally care about machine readable versions of CVs (even though they should because it simplifies searching and matching).
(I've worked at three recruiters, two of the biggest in the UK)
> At the moment the majority of web technologies are using JSON
The majority of which technologies? The CV generators that are already out there, which are the most relevant ones, don't use JSON. How are you creating a low barrier to entry by completely disregarding what people are already using?
XML was horrible for data interchange, configuration, and all the other crap people used it for.
It's one of the best tools for marking up content. It's a Markup Language! If you've never used XSLT you really should look at what it can do. Because I can transform an XML resume into something gorgeous without writing too much programming logic.
It's the reason so many technical book publishers use XML. Easy to transform content while also describing that content.
It is horrible for markup too. It is far, far, far too complex and far more verbose than it needs to be. These are the hallmarks of a bad language (or metalanguage).
It is absurdly popular in bureaucratic environments. Bureaucrats adore its complex rules, ability to create arcane standards and illusion of openness. It's also good for job security. However, none of that bodes well for the rest of us.
I have used XSLT and I am absolutely appalled that something like that can even exist. It's actually worse than XML. It is a turing complete language (this means that you can make it as complex as you like, and boy oh boy does THAT happen), but its readability is AWFUL.
There is a reason we have other general purpose languages turing complete like python or javascript or even java and that is because, while they may have some warts, they have had a lot more thought put into them in order to help make them more consistent, better structured and readable than similarly committee-designed / thrown together languages like XSLT.
I can use a normal programming language transform a JSON resume into something gorgeous and I GUARANTEE it will be lot easier to read and modify than your XSLT equivalent.
> It is horrible for markup too. It is far, far, far too complex and far more verbose than it needs to be.
Oh stop. XML syntax is freaking simple. <tag>content</tag>, <tag><child>...</child>...</tag>, or <tag attribute="value" ...></tag>. Toss in namespaces for composing other formats _if need be_ (and you don't have to use them). And... you're done for 99.9% of any use case you can think of. You have to repeat yourself when you close a tag. Whoopdedoo. Any decent editor will close them for you anyway. I think the "XML sucks" crowd are conflating very complex XML _formats_ with XML _itself_ and deciding that XML is ridiculously complex and verbose because e.g., SOAP is complex and verbose.
Just curious, do you hate HTML for similar reasons as well?
I have to agree. XML can be complicated, or can at least look complicated when using lots of namespaces and what-not, but for most purposes it's dead simple and about as easy to understand as anything else.
Truth be told, I find XML easier to read than JSON in many cases. shrug
* The likelihood that you will receive badly formed XML and be forced to parse it anyway.
* The multiple different ways of escaping characters.
* Language identification
...I could go on.
Oh, and your parser has to handle ALL of this. It's no good assuming that "since the basics are fairly basic it doesn't matter". It doesn't matter only when you're generating XML, but somebody SOMEWHERE is going to have to consume it.
Wanna know why it's typically possible to blow up an XML parser with a memory leak or a buffer overflow but not a JSON parser? This complexity is why. Just using it creates an increased attack surface for your internet facing API.
>Just curious, do you hate HTML for similar reasons as well?
I'm not its biggest fan, and I feel like it could have been done a lot better. However, A) there isn't much alternative so bitching about it it somewhat pointless and B) at least I never have parse it (want an exercise in frustration some time? try doing THAT...).
I was mentioning the "99.9%" use case of XML for e.g., a resume format. You don't have to specify DOCTYPEs, namespaces, etc.
> The likelihood that you will receive badly formed XML and be forced to parse it anyway.
You're supposed to fail on badly-formed XML!
> Oh, and your parser has to handle ALL of this.
So? I don't have to write an XML parser because there are numerous well-tested ones already written. I wouldn't write a JSON parser for the same reason.
> Wanna know why it's typically possible to blow up an XML parser with a memory leak or a buffer overflow but not a JSON parser?
First of all, you shouldn't speak in absolutes. You certainly could write a JSON parser that blows up for the same reasons. There's nothing inherent in JSON that makes it impossible to write a bad parser.
> at least I never have parse it (want an exercise in frustration some time? try doing THAT...).
For anything more than a trivial format you can automatically have the parser bind the content to a POJO (or your language's "plain old object" analogue).
Sorry to rain on yours, but XML isn't bad. The way people used it is bad.
Just because you were forced to use bad schemas in enterprisey situations doesn't mean XML is bad. SOAP is not XML. Spring MVC is not XML. Those things use XML.
Docbook's pretty easy to follow. That, in my opinion, is a great example of XML+XSLT.
With XML I can do this:
<experience>
<title>Manager</title>
<company>Veridian Dynamics</company>
<description>
Responsible for doing all manner of things.
</description>
</experience>
It describes exactly what we're looking for in the same way as the JSON variant does. My editor will auto-close those tags the same way my editor will auto-close the closing curly braces in the JSON version.
Of course, we could make it suck if we just go ahead and add all sorts of extra rules and hierarchy and turn it into a monstrosity.
No, it IS bad and the complaint that 'people use it badly' is simply an excuse to cover for its deficiencies. In many ways, its deficiencies (which YAML/JSON do not have) are an incitement to use it badly, but that's far from the only problem with it.
I am not complaining about being forced to use bad schemas in enterprisey situations, either. That is merely the icing on the cake of the badness that is XML.
I am complaining simply because there is not one instance I have ever come across in my entire programming career (12 years now) where XML would have served me better than an alternative (assuming I had a choice). Zero.
For example:
>With XML I can do this:
>
><experience> <title>Manager</title> <company>Veridian Dynamics</company> <description> Responsible for doing all manner of things. </description> </experience>
Yes, you can, but so what? You can do that in YAML and JSON too. Furthermore, your YAML/JSON parser is 10x less complex, faster, less likely to have buffer overflow security issues and less likely to have memory leaks.
Furthermore, while my app that consumes this markup will probably have to treat <experience><title>Manager<company>Veridian</experience> as valid, because consuming badly formed XML is standard and expected (your product manager will probably treat not parsing it as a bug), my app won't EVER have to treat invalid JSON as valid.
>Of course, we could make it suck
Yes, and there's a 90% chance somebody will. Whereas with JSON and YAML the chances of it being made to suck are far lower, because so many of the unnecessary avenues which are used to make XML suck are closed off in YAML.
I don't have to do anything with XML that I don't want to. I don't have to accept XML that doesn't conform to my schema. You're talking web services again and I'm talking about resumes. You're talking general and I'm talking about a specific place, publishing content, where XML shines. See previous comments - I use XML daily in book publishing. It is not anything like what you're making it out to be.
XML is a markup language. JSON is a serialization language. YAML is a serialization language too. I want to semantically mark up my content. And this is very different than application programming with XML.
You want to write a book with Docbook's XML? Better give it exactly what it wants, or it will reject it. It's not SOAP.
>I don't have to accept XML that doesn't conform to my schema.
Yes you do, because otherwise people will treat your application as buggy. People have tried doing this with browsers and it never, EVER, ever works. If one app accepts malformed markup, they expect every other one to do it as well and no amount of preaching about the sanctity of well formed markup is going to change their mind.
>You're talking web services again and I'm talking about resumes.
If resumes are going to be done in markup it's so they can be consumed by web services. There is no point in having a machine readable language if it's not going to be read by machines.
>You're talking general and I'm talking about a specific place, publishing content, where XML shines.
I would rather use LaTeX for publishing content. It's complex, but it can handle layout beautifully.
For simple markup, I would rather use markdown. Markdown in YAML would probably be a better solution than docbook, but docbook's the standard now, so not much you can really do about that.
> Yes you do, because otherwise people will treat your application as buggy
You are mistaking HTML/Browser rendering and XML parsing. An application that parses XML for book rendering, or whatever the hell the purpose of the application is, will fail on invalid input, whether it is because of invalid tag nesting or schema invalidity.
That is NORMAL, and you would do the same with JSON, so that's not because of history of HTML and IE/Netscape/whatever that you need to change your mind about XML.
> If resumes are going to be done in markup it's so they can be consumed by web services
So if a web service was to accept a specific type of XML, it would certainly need to be made valid, if a client does not conform why the fuck do you want your service to be permissive? Seriously.
You can make a service that accepts the resume schema directly, or embed it in a CDATA if you want to.
> I would rather use LaTeX for publishing content. It's complex, but it can handle layout beautifully
Talking about apple and oranges. XML and docbook are not the same.
>You are mistaking HTML/Browser rendering and XML parsing.
I am not mistaking, I am comparing.
>An application that parses XML for book rendering, or whatever the hell the purpose of the application is, will fail on invalid input
Which will be treated as a bug if other applications DON'T fail (which some undoubtedly will).
>That is NORMAL, and you would do the same with JSON
In my experience the OPPOSITE is normal. If XML is invalid but still makes sense, you treat it as valid, because if you don't, your competitors will.
If the customer is getting XML from output X and feeding into your app, he doesn't care that output X is outputting invalid XML if your competitors' apps accept it. He'll just treat your app as the broken one, not buy it and move on with his life and you've just lost a sale. I've seen it happen MANY times. This phenomenon does NOT just apply to browsers, it's just more aptly demonstrated with browsers. NOBODY wants a browser that doesn't accept valid HTML. They never did and they never will.
And what's different about web pages to any other kind of XML? There's more of them, that's all, and people want ALL of them to work. Permissiveness in the consumers is inevitable with ANY kind of XML document that becomes popular for exactly the same reason as it is with browsers.
>that's not because of history of HTML and IE/Netscape/whatever that you need to change your mind about XML.
Yes it is because this sort-of-invalid-but-not-quite problem is a unique one to XML. JSON doesn't have it.
>So if a web service was to accept a specific type of XML, it would certainly need to be made valid
If you don't think somebody would throw invalid XML at your app and not expect it to work then you've clearly never worked with XML seriously.
If you think you can just tell the customer to go fuck themselves because the XML they got from another service doesn't validate, see my previous point.
>if a client does not conform why the fuck do you want your service to be permissive? Seriously.
Because it will make your service work where an impermissive one won't, and when your service works and competitors don't, that's called gaining marketshare.
Seriously.
>You can make a service that accepts the resume schema directly, or embed it in a CDATA if you want to.
Or you could just use JSON or YAML.
>Talking about apple and oranges. XML and docbook are not the same.
Yes, you are mistaking it. HTML is "relaxed" about various parsing errors. XML absolutely is not. If the input document so much as has a closing tag missing, parsing will fail, end of story. If it doesn't match your schema, parsing will fail, end of story. I'm not sure why you keep going on about this point. You're woefully misinformed if you think XML parsers accept malformed input.
> Which will be treated as a bug if other applications DON'T fail (which some undoubtedly will).
Are you talking about "my app accepts schema A and another app accepts schema A.1, therefore if I don't accept schema A.1 people will think my app sucks"? I'm not sure why you think this is an XML-specific issue.
Yes apples and oranges. They taste different, because they are.
> In my experience the OPPOSITE is normal. If XML is invalid but still makes sense, you treat it as valid, because if you don't, your competitors will.
If this is a business requirement you would do the same for JSON.
> If you don't think somebody would throw invalid XML at your app and not expect it to work then you've clearly never worked with XML seriously.
Nope, if you have a customer sending you an XML which should validate against a predefined schema, no, hell no.
I've worked for the European office of publications, and the web services were just receiving tons of XML on a daily basis. And you know what, invalid XML were rejected that's as simple as that. If you don't respect the supplied schema, retry when correct.
> docbook IS XML.
Docbook USES XML.
Last but not least, HTML is not XML, HTML is not a subset of XML. Permissiveness has nothing to do with web services acceptance of invalid schemas.
If you call a Google service whether it uses SOAP (so XML) or REST, if the request body is invalid, you'll be rejected either way. The SOAP one won't try to parse more or resolve issues just because it is XML based.
The way I see it we actually want to serialize a datastructure. We have many potential use cases not just presentation. If I download a thousand resumes I'm not as interested in viewing them as documents as I am in consuming them as datastructures, doing filtering / machine learning / ranking / ..
The way I look at it this is as much (and probably way more) a platform to write services on top of as it is a another hole to throw resume.xml down. And for that, json is undeniably better suited.
Nobody is trying to convince you to publish books in json.
I have to agree here. XSLT failed when they added <xsl:if>. Get your flow control out of my document format. That's what code is for. Adding <xsl:if> makes it code, horrible, horrible code.
> XSLT failed when they added <xsl:if>. Get your flow control out of my document format. That's what code is for.
XSLT isn't a document format, its by design a domain-specific programming language designed for use in transforming XML documents to other formats.
> Adding <xsl:if> makes it code, horrible, horrible code.
Its supposed to be code. Now, if you want to argue that its horrible code, that's another issue, but complaining that XSLT is code when that's the whole point of XSLT is, well, missing the point.
Anyone that has ever used xslt in a non-trivial way most likely understands that it is a terrible answer to just about any problem. Complexity for the sake of complexity is never a good path to follow.
I've written 7 books with it and those books have been published in print, PDF, epub, and mobi. I think that's non-trivial. But if you're referring to SOAP and WS* and all that stuff from the J2EE days, the I agree. That's a terrible terrible solution.
In my opinion, it should be RDF, so that we can programmatically define a common structure, link to shared concepts (e.g. programming languages) and to other personal documents. If it's encoded XML, JSON-LD, or (my personal favorite) Turtle, that's mostly irrelevant.
Nice. Although I'm not too sure what the social implications of this would be. As it is already I think employers do too much parsing of resumes rather than looking at them with human eyes. PDF resumes are awesome in that you get a blank sheet of paper to do whatever you want with to impress the employer.
There's a lot of reading between the lines that can be done in an resume. Even the fonts say something about the person. If the person is claiming to be a UI designer and their resume has poorly chosen fonts and bad kerning, I'd toss it. If they claim to be a physics researcher and the resume is written in Word, I'd toss it too. With a JSON resume you don't get any of this information.
Also, it's not entirely clear how extensible this "standard" is. Resumes take multiple forms. A computer scientist might want to list a few open source projects. A photographer might want to embed a sample or two of their work.
Yeah, I was going to say that this project is awesome, and I like the web themes, but the PDF export needs a lot of work. I think that will be the hardest aspect to achieve. Maybe some LaTeX resume themes can be borrowed from. There are some very nice ones in LaTeX.
Maybe. As someone who likes to be creative I'd still never use someone else's template though. Even the font I use on my resume I did some editing on because I didn't like the way a couple of the glyphs looked.
I think that gets to the heart of why a standard metadata-to-pretty-resume solution has never really taken off. The people who really care about it don't even bother trying to make a one-size-fits-all solution, since it's such a customized and personal undertaking. Glad to hear I'm not the only person who's spent countless hours tweaking my resume to the nth degree.
The organization of a resume is almost as useful an introduction to a candidate as the terms on it. It's also useful to understand how much time was put into the resume.
> If they claim to be a physics researcher and the resume is written in Word, I'd toss it too.
But the relationship with future performance and these subjective "reading between the lines" opinions is unclear. You need standardization to reduce bias in hiring decisions and make them as objective as possible.
Need more formal ontological definition of the "skills" field, E.g. If you type "Django" the system should infer that you have fair amount of Python skills already.
Some things that I think would be useful to add to the schema, in no particular order:
* It's common for resumes to include a full address, so elements supporting that could be added to the location. There should probably be a way to strip this out before publishing it to a public place though.
* I'd like to see a section for volunteer activities. I do some volunteering which, while not related to my day job, is worth highlighting.
* The references section would usually include contact information for a potential employer. Generally this would be a separate page that would be given during an interview. My main resume says "References available upon request" and I have a separate document with my references in it.
The biggest win, in my mind, is that the schema captures the knowledge of what belongs on a resume. Being able to take that single source and produce multiple versions (e.g., the public one, the private one with full details, a list of references, etc), not to mention everything else that comes with a standard schema, is a huge bonus.
Your meta-layer idea is great too, at the moment we only have password protected resumes.
We are actually building an encryption converter, so you can encrypt your resume with a passphrase, I imagine these public,private etc versions could be controlled by encryption.
I have earlier written a similar json resume conversion gem - http://prat0318.github.io/json_resume I am currently working on i18n and a real time conversion web app. I would love to have something standardized and i hope it gets an active community.
It took me until I got to the sample before I realized the page was talking about Resumés, not resuming file uploads or something. It was very confusing.
In the education section, I'd like to see an option for GPA or degree class. Be aware that some countries do not provide a GPA (for example, the UK has these classes: 1st, 2:1, 2:2, 3rd).
Would it make sense to mimic attributes present in LinkedIn's JSON structure? Most people already have a LinkedIn profile, and it would be easy to make a tool that exports LinkedIn profiles into you new open standard.
If you want this to take off, you really need to provide a mechanism for exporting it to a wide variety of large resume handlers (monster, various large employers, etc.) and importing (e.g. from linkedin).
It's boring and tedious work, and the number of edge cases will multiply geometrically, but it's likely the only kind of thing that would make this take off.
We were nearly going to do a brand change because JSON and YAML are interchangeable and it doesn't really make any sense to just promote JSON in this case. I also love YAML, the problem was writing specification's seems a lot more mature when you follow the json-schema.org project. So I thought why not write it initially in JSON with the json-schema project as a basis and then just supply the tools for people who prefer YAML.
Ugh, json schema is horrible. Have you used orderly? It's far less verbose, more readable and it compiles to json schema.
I agree that making it interchangeable is best overall (especially since there is a 1:1 convertibility between the two languages).
Perhaps the brand should actually reflect this instead. JSON is preferable in a data interchange scenario, but for keeping or displaying a human readable version, YAML is better.
As before, though, it's not YAML/JSON - it's the richness of the import/export filters that will make this idea float or die. Nobody much is going to want this so that they can publish their resume on jsonresume.org. People will want to use it so they can efficiently and easily import their linkedin resume and upload it to [insert fortune 500] company's custom HR portal / top 7 job sites.
This is a neat idea but this schema is a bit...specific in areas. Much like XML schemas of past the great thing about the JSON interchange format is that it's insanely flexible and anything goes (essentially).
I feel like it would be a much better way of handling resume type data if it was self describing rather than using a very specific schema that ties you into a data structure that may not make sense in many cases. In that case you could simply look for different types of data to display versus a very specific format that won't hold up to every use case.
While I don't jump for opportunities to fiddle with a word processor to make a document like a resume look good, I am curious if this is partially driven by an effort to populate databases with information. While I have been unimpressed by efforts to do this by scanning a doc or pdf file, I am afraid of the possible implications for encouraging poor recruiting techniques. Having a searchable database can be nice, but there are so many other layers to finding good talent.
I like the idea, because I deal with a lot of resumes and can't parse them programmatically.
Some thoughts:
- Eliminate first/last name distinction, and let people just put in their full or legal/passport name. Names are very crazy across cultures, as in some people don't have first or last names, so might as well just let them enter free form text as their name.
- Include a "Preferred name" field, also as freeform text. Some people like to go by nicknames, or shortenings of their names, and it will help out.
- Collapse location region and state into a single field.
- If "websites" is a hash with only a single field, call it "website" and make it a string.
216 comments
[ 2.3 ms ] story [ 275 ms ] threadWell done.
I've actually written my resume in markup for a while just so that I could put it on a nice dynamically driven site. Sort of a fun weekend project (no, it's not hosted anywhere).
While I strongly doubt that this will ever be a standard, I think it's nifty, and potentially useful. It opens up easy, pretty resumes, which the world really needs (Note: I'm not being sarcastic. The number of mountains-of-text word document resumes I've gotten in the past few weeks is too high).
People have been doing XML+XSLT for their resumes for a long time, yet it really hasn't taken off in a standard way for whatever reason. Not sure this being JSON-based will change that. I guess I'm wondering what this solution brings to the table that previous attempts didn't.
Sorry I really don't understand the use-case. Having an API is good for styling (as you say), or doing some soft of programmatic transformation to data. I am having trouble understanding the need to do either for a resume.
Maybe it would help as metadata for a search engine, but in that case I think a plain text search would be just as effective?
I think json schema is a really nice thing to have and I'd like to see more people adopt it, but I'm having trouble coming up with the point for this use.
Of course, this is not to imply that having a really well-done resume is really worth much either.
* By "open source standard," what do they mean? I don't see any evidence they're on an RFC track, so this would be "standard" in what way?
* Why? I've never needed a resume in JSON format, but that is anecdotal. They don't really say why they're pursuing this on the site, except why they chose JSON.
Good luck, either way! Making something isn't easy, so I applaud any effort to do anything.
Let's say you had a bank of resumes -- you could easily find all resumes that know Java and have had at least 2 jobs and an active GitHub repo, and automatically send out a request to their references.
Currently, you have to read an unformatted PDF and extract the info manually -- it's not the end of the world, but it gets tedious if you're dealing with lots of resumes.
Except that you're going to have people who put "J2EE" or "J2ME" or "JavaFX" or whatever else people like to specialize in instead of plain "Java".
For example, what is an "RFC track"? I was also hoping that Github Issues might be able to replace the mailing list style of managing standards, what do you think?
[0] http://tools.ietf.org/html/bcp9
The plan is to create a standard that developers worldwide are comfortable enough with to build upon.
To give the standard some traction, we have built tools to export to other formats such as pdf, txt and doc.
We also thought it would be cool and useful to have an NPM like system for resumes. So we built a CLI heavily inspired by NPM, to init and publish your resume to the jsonresume.org registry.
The themes right now are in bad shape, and we are looking for designers who would love to jump in during the early stages. We are thinking of building a theming version manager on top of NPM to take advantage of versions/distribution and also allow theme developers to implement their theming systems however they like (erb, mustache, md etc).
All the code is open source and available at -> http://github.com/jsonresume
Theme developers should be looking at the resumeToHTML repo -> http://github.com/jsonresume/resumeToHTML
People with comments about the standard semantics and structure are encouraged to post their ideas to Github issues. -> http://github.com/jsonresume/resume-schema We also want to formalize the standard a lot more over the coming weeks.
If the project can be pulled off professionally and driven by the community, we believe that working with resumes will be fun!
Edit: Here are some of the reasons why I personally think JSON resumes will improve HR.
(trying to figure out bullet points)
- Better searching and filtering than PDF/doc. Making recruiting a tad easier.
- Applying themes will be a lot easier.
- Applying for jobs will be easier. Instead of filling out complex forms over and over again services might start allowing you to auto-fill with your JSON resume.
- There are many services that ask for your career history such as LinkedIn, Angel.co etc. These could be autopopulated or synced with your master copy.
- You can update your resume programatically so Github projects can be inserted and any other online certificates that you might want automatically added to your resume like Mozilla Open Badges -> http://openbadges.org/
- The comment section suggests that lots of innovation could arise from it.
----------
Make sure you try the CLI! sudo npm install -g resume-cli
I've posted an issue on github [0][1] mentioning that "firstName" and "lastName" is probably not a good representation of names. I don't actually know what the solution is, but this article [2] gives some great reasons why we tend to make incorrect assumptions about peoples names, which have the possibility of excluding some people form our tools based on their name alone.
[0] - https://github.com/jsonresume/resume-schema/issues/4 [1] - It seemed like an appropriate place to comment. Please let me know if there is somewhere else you'd prefer such comments. [2] - http://www.kalzumeus.com/2010/06/17/falsehoods-programmers-b...
Perhaps you should just require "full name" which the author of the resume would decide for him or herself.
1. Asking for "Given Name" and "Surname" clears up most issues with cultures like Korea (where surname comes first).
2. Simply have a "Name" field. Accept any Unicode characters. Hope for the best.
If someone has a name that cannot be represented in written characters or cannot be rendered in Unicode (which would be amazing, since Unicode covers ancient dead languages and fictional languages like Klingon) they probably have more pressing issues than trying to serialize their resume.
This solves some of the falsehoods programmers believe about names: http://www.kalzumeus.com/2010/06/17/falsehoods-programmers-b...
In Germany it's not really common to call people by their first name (IT is an exception), but I would hardly put "Mr. Lastname" into "what do we call you". It all depends on the context, even in the limited scope of a resume.
You see, if you are calling person from Germany, knowing how to address him is not enough, you shall still know how to make a call. If you don't know that, you'll be rude anyways, and if you know that, you'll also know a proper way of addressing persons in different cultures.
Is there really any further scope that should be covered? If there are specific cultural issues, shouldn't that be hammered out later?
Really, the design question for JSON Resume is "For what purpose is a name being provided?"
My resume.json for science [3]
[1] https://github.com/dhawalhshah/modern-resume [2] http://dhawal.me/ [3] http://dhawal.me/js/resume.json
Thanks
What they're proposing is structure, not machine readability... Technically, with the state of OCR and other methods, many things like LaTeX, PDFs, .DOCs, etc are all perfectly machine readable -- the problem is getting the information out in a meaningful way.... that's usually done by standardizing on structure.
When it comes to specifying structure, XML and JSON are pretty much the front-runners (at least I think so), and since XML isn't so popular lately (since it's so verbose), JSON is in the spotlight now
Uh, no. What does OCR even have to do with the 'machine readability' (for your strange definition of it) of the formats you mention?
The big picture is to make as many things as possible "machine readable" (things more difficult than resumes), and use machines to work faster than humans ever could.
Other than the fact that most of the things I noted are ALREADY in a state that is computer usable (whether it makes sense to humans looking at computers is another question), I was trying to point out that getting the information into a computer (A.K.A. Machine readability) is not the issue we're struggling with now, it's structuring, characterizing and understanding the information.
I mentioned OCR because it's used to parse resumes to find important bits when other methods fail (or someone submits something crazy like a scanned version of their resume instead of the file) -- something that wouldn't be necessary if there was a standard (like is being proposed) to adhere to, that people could semantically find what they wanted from.
Also, if you read closely, I said with the state of OCR AND OTHER METHODS... OCR does not have anything to do with the machine readability of other methods, it's just one method people use to extract data, or for machines to "read" the document.
It took me ages to figure out what this actually was, because your non-standard "lazy" spelling made me think this was about resuming interrupted downloads/transfers of generic JSON data. (Possibly by doing a partial parse of the data that you have got, or over a non-HTTP protocol, otherwise why not just use HTTP "Range:" headers?) I had to unlearn that before the light-bulb went off.
I mean, résumé and resume have the same French root, but in English - even American English as far as I can tell - they're totally different words! Even the pronounciation is completely different. So why would someone spell résumé as resume, especially in the name/title of a project about them?
How is that going to do anything except cause confusion?
We have words with the same spelling but different meanings and pronunciations all the time - so called Heteronyms [2]. Doesn't seem that confusing to me. To me it'd be pretty weird if people who understood the word rôle were baffled by the word role.
[1] http://en.wikipedia.org/wiki/English_terms_with_diacritical_... [2] http://en.wikipedia.org/wiki/Heteronym_(linguistics)
Really? I've always thought of heteronyms as one of the most stand-out features of English that exemplify its confusing inconsistency. More so than the homophones, because it's harder to think of the "other" meanings if you've got the wrong pronunciation in your head.
In reference to the passage you quoted about diacritics, if only you had read as far as the next-but-one paragraph, you might have noticed: "Words that retain their accents often do so to help indicate pronunciation (e.g. frappé, naïve, soufflé), or to help distinguish them from an unaccented English word (e.g. exposé, résumé, rosé)."
Regarding that: I recently reached the fed-up point with sudo or not sudo to install nodejs app and the mess it leaves behind when using sudo for just installing some local binaries.
I stumbled upon nvm[0] when installing docpad:
> The above should not require sudo (the # means sudo). If it does, we recommend reinstalling Node.js so that it doesn't. Otherwise you're likely to run into permission problems in the future. Follow the Step 1 instructions to reinstall Node.js without requiring sudo.[1]
Which led me to this:
> http://learn.bevry.me/node/install
and then this:
> https://github.com/creationix/nvm
It makes npm installs everything under $HOME and never needs to be ran with escalated privileges. `nvm install X.X` and `nvm use X.X` allows switching between node versions and installed packages.
[0] https://github.com/creationix/nvm
[1] http://docpad.org/docs/install
Edit: references should also have an optional 'organisation' field and a 'position title' field. "This reference was the technical lead at Foo Corp, my second-last job. Contactable here"
Checking that dates are logical, spell checks, checking for dead links, showing employment gaps and so on.
I don't know that the themes, necessarily, are that useful (I don't like the idea of implicitly connecting presentation with JSON like that - i'll make my own themes thank you) but I do like the idea of a common transport format for resumes.
My resume is set up as http://www.microformats.org/wiki/hresume and noöne supports that, and it's been around for a while.
However, I'm not at all convinced that JSON is the way to do it. I think the way to do it is with XML and XSLT, although I already can hear the cries of "But XML is yucky and XSLT is hard." But by using JSON, we lose some semantic markup and end up having to parse it to create some semantic markup.
Still, I hope this, or something like it, takes off. This just needs a web-based GUI tool to publish a resume so that non-geeks can make it happen.
LinkedIn actually exports into a Microformat called hResume which has been around for a long time but has evidently not been able to amass a large developer community. This was another reason we decided to not start with XML.
So, not trying to be rude here, but have you wondered why it is that an XML resume format hasn't taken off? Other than it being based on icky XML? I mean XML+XSLT has been around for a loooong time and can more than handle exactly what this format sets out to do, and yet a standard XML resume format hasn't taken off.
Though I would love to hear someone else's thoughts on why an XML resume hasn't gained critical mass.
XML is perfectly human-readable...
> but I also don't know XML that well
Suddenly that statement makes sense.
Here's a silly playground I wrote to show my students XML.
http://xslteatime.herokuapp.com/
There's a pre-built example you can run.
I mean XML+XSLT has been around for a loooong time and can more than handle exactly what this format sets out to do, and yet a standard XML resume format hasn't taken off.
It's just as likely that the answer is "a standard resume format hasn't taken off" where the serialization format is irrelevant. Maybe not enough people are interested in working with documents and knowledge at that deeper, semantically meaningful level. Maybe sending resumes as PDF or MS Word or ODT and using simple keyword extraction has been "good enough" that nobody has felt the pull to use a better system?
What I mean is, it's entirely possible that this will fail to gain adoption for the exact same reason that the XML based one(s) did, and that the difference between JSON and XML is actually irrelevant. This is, of course, just speculation on my part. In any case, I hope this (or something like it) gains traction, since I'm a strong proponent of publishing semantically meaningful content, whether it's in RDF/XML, JSON-LD, SGML, DAML+OIL, YAML, Texinfo, Markdown, Hytime or hieroglyphics chiseled into stone tablets. :-)
But all that's needed is a script that eats XML resumes and outputs json resumes, and vice versa.
Just like I'd rather write markdown and read (rendered) html+css.
That said, on the subject of XML not being "icky": one resource for having fun with XML: "Program Generators with XML and Java" by J. Craig Cleaveland (Prentice-Hall, 2001):
http://craigc.com/pg/
Still, can't complain, 5 minutes and I have a resume draft that doesn't look half bad in html, and is presumably entirely reasonable to customize (not to mention it's all inn a json-file anyway, so one could just use what's in ones actual resume, and shove the json through pretty much any scripting language w/templates and generate something reasonable).
Currently have 60 fresh issues on Github for the schema so after we digest those we will be improving the CLI once again.
Just to be clear, I was taking the same position you were...
Not to mention, XML is much more verbose, and when you wrap it in things like ws*/SOAP it gets really ugly really quickly, and if you don't map everything, it gets complicated and often fails. When you publish a service using one toolkit, it's often difficult to use the service in another toolkit (example, using Java services in .Net gets really painful at times). Unless a lot of detail is done, or an API client in that client's environment is provided.
This isn't about XML specifically but about the environment it tends to create. JSON is typically simpler to write, easier to code against and more forgiving in the tooling than XML is. Much like the differences between a scripted environment and a statically compiled environment.
> but intrinsically you can't look at XML file and know how a codified representation should look like...
Let's compare:
vs To me, it seems that both of those:1. need a schema to be useful as a standard 2. express their hierarchy 3. don't specify data type (although I could add that info to both if needed) 4. have a level of annoying to them (commas, colons, angle brackets, etc) which modern IDEs have taken care of for us.
> if you have an element it will have properties and child elements... said child elements may contain children, strings, or ???
I need to use documentation to use `package.json` files too, because each node may or may not contain children. Node graciously tells me if I missed something. Docbook also tells me if my XML is malformed. I see no difference here,
> JSON maps much more naturally to an object model in a given language.
It maps to a hash/dictionary. I'm not sure that qualifies as an "object model" unless you only write JavaScript.
I'd really like people to understand that XML is, like HTML, really great at describing and marking up content so that something else may process it.
That doesn't make sense. You wanted a low barrier to entry, but you have to mark this up yourself with JSON, install command line tools, etc. Seems to me a web app that I fill in some forms and generate a page on your site would be the quickest way to lower the barrier.
> At the moment the majority of web technologies are using JSON so we believe that to get this standard off the ground we will need to go with the grain.
I understand the desire to use what's popular. But I just don't think it's the right choice. I'm interested to see the implementation of how this is turned into a PDF though.
Right now, though, it does sound a bit like "every problem is a nail." Perhaps it'll become more clear to me as I dig in more.
Again, I do think the project is very cool and will be encouraging my students to take a look at how they can use this to promote themselves.
We actually had to pull our PDF converter due to bugs and are currently just using a service called pdfcrowd.com.
Though the general idea is that HTML can be passed through WebKit and rendered as various image formats and PDF -> http://wkhtmltopdf.org/
Here is a link to what your first idea might look like, it automatically generates forms based of JSON specifications -> http://jeremydorn.com/json-editor/
I'll start adapting resumebeacon.com to support jsonresume. I created my site as a LinkedIn resume generator, so integrating a JSON formatted feed shouldn't be much trouble. I'll start work on it tonight and post it to "show HN" when it's done.
But let me guess: you will?
(I've worked at three recruiters, two of the biggest in the UK)
The majority of which technologies? The CV generators that are already out there, which are the most relevant ones, don't use JSON. How are you creating a low barrier to entry by completely disregarding what people are already using?
JSON was a much better choice. YAML would have been better still (it's more human readable), but both beat XML hands down in any situation.
It's one of the best tools for marking up content. It's a Markup Language! If you've never used XSLT you really should look at what it can do. Because I can transform an XML resume into something gorgeous without writing too much programming logic.
It's the reason so many technical book publishers use XML. Easy to transform content while also describing that content.
It is absurdly popular in bureaucratic environments. Bureaucrats adore its complex rules, ability to create arcane standards and illusion of openness. It's also good for job security. However, none of that bodes well for the rest of us.
I have used XSLT and I am absolutely appalled that something like that can even exist. It's actually worse than XML. It is a turing complete language (this means that you can make it as complex as you like, and boy oh boy does THAT happen), but its readability is AWFUL.
There is a reason we have other general purpose languages turing complete like python or javascript or even java and that is because, while they may have some warts, they have had a lot more thought put into them in order to help make them more consistent, better structured and readable than similarly committee-designed / thrown together languages like XSLT.
I can use a normal programming language transform a JSON resume into something gorgeous and I GUARANTEE it will be lot easier to read and modify than your XSLT equivalent.
Sorry to rain on your parade, but it's true.
Oh stop. XML syntax is freaking simple. <tag>content</tag>, <tag><child>...</child>...</tag>, or <tag attribute="value" ...></tag>. Toss in namespaces for composing other formats _if need be_ (and you don't have to use them). And... you're done for 99.9% of any use case you can think of. You have to repeat yourself when you close a tag. Whoopdedoo. Any decent editor will close them for you anyway. I think the "XML sucks" crowd are conflating very complex XML _formats_ with XML _itself_ and deciding that XML is ridiculously complex and verbose because e.g., SOAP is complex and verbose.
Just curious, do you hate HTML for similar reasons as well?
Truth be told, I find XML easier to read than JSON in many cases. shrug
* DOCTYPE
* Namespaces and namespace collision handling.
* The likelihood that you will receive badly formed XML and be forced to parse it anyway.
* The multiple different ways of escaping characters.
* Language identification
...I could go on.
Oh, and your parser has to handle ALL of this. It's no good assuming that "since the basics are fairly basic it doesn't matter". It doesn't matter only when you're generating XML, but somebody SOMEWHERE is going to have to consume it.
Wanna know why it's typically possible to blow up an XML parser with a memory leak or a buffer overflow but not a JSON parser? This complexity is why. Just using it creates an increased attack surface for your internet facing API.
>Just curious, do you hate HTML for similar reasons as well?
I'm not its biggest fan, and I feel like it could have been done a lot better. However, A) there isn't much alternative so bitching about it it somewhat pointless and B) at least I never have parse it (want an exercise in frustration some time? try doing THAT...).
I was mentioning the "99.9%" use case of XML for e.g., a resume format. You don't have to specify DOCTYPEs, namespaces, etc.
> The likelihood that you will receive badly formed XML and be forced to parse it anyway.
You're supposed to fail on badly-formed XML!
> Oh, and your parser has to handle ALL of this.
So? I don't have to write an XML parser because there are numerous well-tested ones already written. I wouldn't write a JSON parser for the same reason.
> Wanna know why it's typically possible to blow up an XML parser with a memory leak or a buffer overflow but not a JSON parser?
First of all, you shouldn't speak in absolutes. You certainly could write a JSON parser that blows up for the same reasons. There's nothing inherent in JSON that makes it impossible to write a bad parser.
> at least I never have parse it (want an exercise in frustration some time? try doing THAT...).
For anything more than a trivial format you can automatically have the parser bind the content to a POJO (or your language's "plain old object" analogue).
Just because you were forced to use bad schemas in enterprisey situations doesn't mean XML is bad. SOAP is not XML. Spring MVC is not XML. Those things use XML.
Docbook's pretty easy to follow. That, in my opinion, is a great example of XML+XSLT.
With XML I can do this:
<experience> <title>Manager</title> <company>Veridian Dynamics</company> <description> Responsible for doing all manner of things. </description> </experience>
It describes exactly what we're looking for in the same way as the JSON variant does. My editor will auto-close those tags the same way my editor will auto-close the closing curly braces in the JSON version.
Of course, we could make it suck if we just go ahead and add all sorts of extra rules and hierarchy and turn it into a monstrosity.
But I'd rather not.
I am not complaining about being forced to use bad schemas in enterprisey situations, either. That is merely the icing on the cake of the badness that is XML.
I am complaining simply because there is not one instance I have ever come across in my entire programming career (12 years now) where XML would have served me better than an alternative (assuming I had a choice). Zero.
For example:
>With XML I can do this: > ><experience> <title>Manager</title> <company>Veridian Dynamics</company> <description> Responsible for doing all manner of things. </description> </experience>
Yes, you can, but so what? You can do that in YAML and JSON too. Furthermore, your YAML/JSON parser is 10x less complex, faster, less likely to have buffer overflow security issues and less likely to have memory leaks.
Furthermore, while my app that consumes this markup will probably have to treat <experience><title>Manager<company>Veridian</experience> as valid, because consuming badly formed XML is standard and expected (your product manager will probably treat not parsing it as a bug), my app won't EVER have to treat invalid JSON as valid.
>Of course, we could make it suck
Yes, and there's a 90% chance somebody will. Whereas with JSON and YAML the chances of it being made to suck are far lower, because so many of the unnecessary avenues which are used to make XML suck are closed off in YAML.
XML is a markup language. JSON is a serialization language. YAML is a serialization language too. I want to semantically mark up my content. And this is very different than application programming with XML.
You want to write a book with Docbook's XML? Better give it exactly what it wants, or it will reject it. It's not SOAP.
Yes you do, because otherwise people will treat your application as buggy. People have tried doing this with browsers and it never, EVER, ever works. If one app accepts malformed markup, they expect every other one to do it as well and no amount of preaching about the sanctity of well formed markup is going to change their mind.
>You're talking web services again and I'm talking about resumes.
If resumes are going to be done in markup it's so they can be consumed by web services. There is no point in having a machine readable language if it's not going to be read by machines.
>You're talking general and I'm talking about a specific place, publishing content, where XML shines.
I would rather use LaTeX for publishing content. It's complex, but it can handle layout beautifully.
Docbook is complex and it can't: http://www.docbook.org/tdg/en/html/part2.html
For simple markup, I would rather use markdown. Markdown in YAML would probably be a better solution than docbook, but docbook's the standard now, so not much you can really do about that.
> Yes you do, because otherwise people will treat your application as buggy
You are mistaking HTML/Browser rendering and XML parsing. An application that parses XML for book rendering, or whatever the hell the purpose of the application is, will fail on invalid input, whether it is because of invalid tag nesting or schema invalidity.
That is NORMAL, and you would do the same with JSON, so that's not because of history of HTML and IE/Netscape/whatever that you need to change your mind about XML.
> If resumes are going to be done in markup it's so they can be consumed by web services
So if a web service was to accept a specific type of XML, it would certainly need to be made valid, if a client does not conform why the fuck do you want your service to be permissive? Seriously.
You can make a service that accepts the resume schema directly, or embed it in a CDATA if you want to.
> I would rather use LaTeX for publishing content. It's complex, but it can handle layout beautifully
Talking about apple and oranges. XML and docbook are not the same.
I am not mistaking, I am comparing.
>An application that parses XML for book rendering, or whatever the hell the purpose of the application is, will fail on invalid input
Which will be treated as a bug if other applications DON'T fail (which some undoubtedly will).
>That is NORMAL, and you would do the same with JSON
In my experience the OPPOSITE is normal. If XML is invalid but still makes sense, you treat it as valid, because if you don't, your competitors will.
If the customer is getting XML from output X and feeding into your app, he doesn't care that output X is outputting invalid XML if your competitors' apps accept it. He'll just treat your app as the broken one, not buy it and move on with his life and you've just lost a sale. I've seen it happen MANY times. This phenomenon does NOT just apply to browsers, it's just more aptly demonstrated with browsers. NOBODY wants a browser that doesn't accept valid HTML. They never did and they never will.
And what's different about web pages to any other kind of XML? There's more of them, that's all, and people want ALL of them to work. Permissiveness in the consumers is inevitable with ANY kind of XML document that becomes popular for exactly the same reason as it is with browsers.
>that's not because of history of HTML and IE/Netscape/whatever that you need to change your mind about XML.
Yes it is because this sort-of-invalid-but-not-quite problem is a unique one to XML. JSON doesn't have it.
>So if a web service was to accept a specific type of XML, it would certainly need to be made valid
If you don't think somebody would throw invalid XML at your app and not expect it to work then you've clearly never worked with XML seriously.
If you think you can just tell the customer to go fuck themselves because the XML they got from another service doesn't validate, see my previous point.
>if a client does not conform why the fuck do you want your service to be permissive? Seriously.
Because it will make your service work where an impermissive one won't, and when your service works and competitors don't, that's called gaining marketshare.
Seriously.
>You can make a service that accepts the resume schema directly, or embed it in a CDATA if you want to.
Or you could just use JSON or YAML.
>Talking about apple and oranges. XML and docbook are not the same.
docbook IS XML.
Yes, you are mistaking it. HTML is "relaxed" about various parsing errors. XML absolutely is not. If the input document so much as has a closing tag missing, parsing will fail, end of story. If it doesn't match your schema, parsing will fail, end of story. I'm not sure why you keep going on about this point. You're woefully misinformed if you think XML parsers accept malformed input.
> Which will be treated as a bug if other applications DON'T fail (which some undoubtedly will).
Are you talking about "my app accepts schema A and another app accepts schema A.1, therefore if I don't accept schema A.1 people will think my app sucks"? I'm not sure why you think this is an XML-specific issue.
Yes apples and oranges. They taste different, because they are.
> In my experience the OPPOSITE is normal. If XML is invalid but still makes sense, you treat it as valid, because if you don't, your competitors will.
If this is a business requirement you would do the same for JSON.
> If you don't think somebody would throw invalid XML at your app and not expect it to work then you've clearly never worked with XML seriously.
Nope, if you have a customer sending you an XML which should validate against a predefined schema, no, hell no. I've worked for the European office of publications, and the web services were just receiving tons of XML on a daily basis. And you know what, invalid XML were rejected that's as simple as that. If you don't respect the supplied schema, retry when correct.
> docbook IS XML.
Docbook USES XML.
Last but not least, HTML is not XML, HTML is not a subset of XML. Permissiveness has nothing to do with web services acceptance of invalid schemas.
If you call a Google service whether it uses SOAP (so XML) or REST, if the request body is invalid, you'll be rejected either way. The SOAP one won't try to parse more or resolve issues just because it is XML based.
The way I look at it this is as much (and probably way more) a platform to write services on top of as it is a another hole to throw resume.xml down. And for that, json is undeniably better suited.
Nobody is trying to convince you to publish books in json.
Just like XML.
XSLT isn't a document format, its by design a domain-specific programming language designed for use in transforming XML documents to other formats.
> Adding <xsl:if> makes it code, horrible, horrible code.
Its supposed to be code. Now, if you want to argue that its horrible code, that's another issue, but complaining that XSLT is code when that's the whole point of XSLT is, well, missing the point.
There's a lot of reading between the lines that can be done in an resume. Even the fonts say something about the person. If the person is claiming to be a UI designer and their resume has poorly chosen fonts and bad kerning, I'd toss it. If they claim to be a physics researcher and the resume is written in Word, I'd toss it too. With a JSON resume you don't get any of this information.
Also, it's not entirely clear how extensible this "standard" is. Resumes take multiple forms. A computer scientist might want to list a few open source projects. A photographer might want to embed a sample or two of their work.
The organization of a resume is almost as useful an introduction to a candidate as the terms on it. It's also useful to understand how much time was put into the resume.
> If they claim to be a physics researcher and the resume is written in Word, I'd toss it too.
Hm, that's going too far, though!
* It's common for resumes to include a full address, so elements supporting that could be added to the location. There should probably be a way to strip this out before publishing it to a public place though.
* I'd like to see a section for volunteer activities. I do some volunteering which, while not related to my day job, is worth highlighting.
* The references section would usually include contact information for a potential employer. Generally this would be a separate page that would be given during an interview. My main resume says "References available upon request" and I have a separate document with my references in it.
The biggest win, in my mind, is that the schema captures the knowledge of what belongs on a resume. Being able to take that single source and produce multiple versions (e.g., the public one, the private one with full details, a list of references, etc), not to mention everything else that comes with a standard schema, is a huge bonus.
Your meta-layer idea is great too, at the moment we only have password protected resumes.
We are actually building an encryption converter, so you can encrypt your resume with a passphrase, I imagine these public,private etc versions could be controlled by encryption.
https://github.com/ransomw/ransomw.github.io/tree/master/med...
We also want to build a feature into the command line tool that lets users sync their resume.json to LinkedIn.
Otherwise you have the xkcd problem: http://xkcd.com/927/
It's boring and tedious work, and the number of edge cases will multiply geometrically, but it's likely the only kind of thing that would make this take off.
P.S. Why not YAML?
I agree that making it interchangeable is best overall (especially since there is a 1:1 convertibility between the two languages).
Perhaps the brand should actually reflect this instead. JSON is preferable in a data interchange scenario, but for keeping or displaying a human readable version, YAML is better.
As before, though, it's not YAML/JSON - it's the richness of the import/export filters that will make this idea float or die. Nobody much is going to want this so that they can publish their resume on jsonresume.org. People will want to use it so they can efficiently and easily import their linkedin resume and upload it to [insert fortune 500] company's custom HR portal / top 7 job sites.
I feel like it would be a much better way of handling resume type data if it was self describing rather than using a very specific schema that ties you into a data structure that may not make sense in many cases. In that case you could simply look for different types of data to display versus a very specific format that won't hold up to every use case.
Some thoughts:
- Eliminate first/last name distinction, and let people just put in their full or legal/passport name. Names are very crazy across cultures, as in some people don't have first or last names, so might as well just let them enter free form text as their name.
- Include a "Preferred name" field, also as freeform text. Some people like to go by nicknames, or shortenings of their names, and it will help out.
- Collapse location region and state into a single field.
- If "websites" is a hash with only a single field, call it "website" and make it a string.
Will create issues for your other feedback -> https://github.com/jsonresume/resume-schema