How we got 1,500 GitHub stars by mixing time-tested technology with a fresh UI | Hacker News Reader

How we got 1,500 GitHub stars by mixing time-tested technology with a fresh UI

medium.freecodecamp.com

77 pointsromanhotsiy30 comments

Despite the title, the article raises an interesting point: why do we prefer new code, with less features, to old but robust projects.

> Unfortunately, we were affected by cognitive bias: old code is bad code. But the truth can be the opposite. The old code is battle-tested by thousands of users in hundreds of different projects. Most of the critical bugs have been fixed, the documentation is complete, there are tons of questions and answers on StackOverflow and Quora.

I'm quite guilty here; I've realized that I always check the date of the last commit on Github before testing a project. I feel like I do this more for small projects where documentation and use cases might be missing, and for which I'm expecting help from the community.

Old last commit date could mean two things:

1. Project left in unfinished state and development stalled, in which case it's reasonable to run away from it.

2. Project done (fulfilling it's purpose) and turned to maintenance mode, in which case I'd be quite happy (as a matter of fact I'd prefer) to use it as I know I'm dealing with a stable codebase and don't need to be afraid of breaking changes in the future.

I think it would help if maintainers would state the "completeness" in the README file.

A project could be effectively both - the developer still wants (wanted?) to add more features, but what's there is complete and stable.

Word of mouth and some good old experimentation seem to be your best options for identifying solid tooling.

I think most of the time I just assume it's #1 and then check into the issues to see the number/severity of the current problems and if any important things are being neglected.

This used to be indicated by version numbers:

- 0.x = version in some beta/alpha/unstable state

- 1.x = version in somewhat stable/complete state

I find that additionally (presuming github or similar) that looking through for any recent issues helps a lot... npm download rate is another metric for comparison. Thouse some obscure bits may not see so many downloads at all.

Maybe because we're swayed by superficial, yet impactful choices: the use of a "modern-looking webpage with a visually-attractive theme", the use of the latest technologies - or at least those the community is talking about, buzz around the project, etc.

I realize it's tedious, but even older projects could do with periodic updates to tutorials, documentation, webpage updates and outreach to draw new interest from the community.

"It may be stable, but is it pleasant?" to use, to develop with, etc. That matters. There is definitely a goldilocks zone for libraries/frameworks, where they're mature enough to be reasonable to use in production, but still recent enough to not require a lot of effort to bring up to date.

At work, we've been using Elixir. Because of the Erlang interop, I find myself looking at a lot of Erlang code that hasn't really had any reason to be touched in years. It's really bizarre seeing a project with no commits in the last few years and having to decide if it's abandoned or feature complete.

>I'm quite guilty here; I've realized that I always check the date of the last commit on Github before testing a project. I feel like I do this more for small projects where documentation and use cases might be missing, and for which I'm expecting help from the community.

I do it because of code rot. The environment you will surround the project with (runtimes, libraries, frameworks) has often changed enough in 2-4 years to render it unusuable.

Additionally a recent commit implies regular maintenance which implies that if you report it will get fixed.

Also, projects are often abandoned because there is a clearly better version out there.

Old last commit isn't a good metric for health; particularly for projects that don't go anywhere near hardware. There's plenty of time-tested and popular C libraries that only _very_ rarely see a patch suggestion, let alone a commit.

Check the mailing lists and forums; and look around for projects that depend on it.

Also their user onboarding literally forces a unknowing user to create a GitHub account then star their specific repository.

Making GitHub stars ultimately meaningless, if they ever meaned anything.

I always assumed stars were just a form of bookmarking for me to find projects again easily, since there is no other method than 'watching', which results in too much info

These guys really care about Github stars.

Hey, I'm the author of the "GraphQL Visualizer" tool (http://nathanrandal.com/graphql-visualizer/) that they mention in the article as inspiration for their project.

This new project is quite nice and definitely a step up from mine.

Also wanted to mention that there is a CLI version of the visualizer at https://github.com/sheerun/graphqlviz for when you want to quickly visualize a GraphQL endpoint for documentation purposes, etc. Keep up the good work!

But after looking at the source code we found a fatal flaw in this tool: it used Graphviz — a decades old tool written in plain C and compiled to unreadable JavaScript using Emscripten.

Are the "decades old" and "plain C" aspects supposed to be bad things? It seems like the real problem is "compiled to unreadable JavaScript". Graphviz is a great example of "if it ain't broke, don't fix it".

"Decades old" often means that it is mature, has relatively few bugs, and is not going to soon go through some major API-breaking re-architecture just because the maintainer wants to experiment with a new framework-of-the-week. "Written in plain C" means I will likely be able to call/integrate it into my project with little fuss. These are both things to actively look for when browsing for open source libraries.

Ignoring the fact that Github Stars are a aweful metric for anything else than vanity, "More bells and whistles" feels like a terrible advice and you should much more focus on a "easy-to-get-started" readme with just the minimal amount of beels and whistles to effectively communicate what your thing is really about.

I'm extatic one of my project reached 100 stars. Sometimes we need to feel good.

Agreed. I also think there's a lot of satisfaction in knowing that you got those stars in a completely organic manner.

How much do github stars sell for these days?

Apparently, around $325 for 1500 stars: hxxp://githubstars.com/

http://githubstars.com this a really helpful site. curl project got 5k stars from it :p

I believe your parent comment censored censored the link to avoid boosting the site's page rank. You may want to edit your comment (or not).

Can you explain what that means/what happens?

Search engines rank sites (in part) according to the number of other sites that link to them. Wikipedia is ranked very highly in Google largely because many, many sites link to Wikipedia.

The PageRank algorithm to compute these kinds of rankings was one of Google's early innovations, and was the secret to its initial dominance over the early-2000s search engine market.

But the links all have rel="nofollow"

FWIW, it looks like HN now adds rel="nofollow" to links in comments. So, it shouldn't matter either way.

confused. it is just a funny website.

Or how about simply not succumbing to the latest UI trends, which will be different next year anyway?

Reply on news.ycombinator.com