Ask HN: What are examples of GitHub repositories with high code quality?

Whilst it may well well engineered as a project of this size, the code I have seen leaves a lot to be desired.

Cases that spring to mind are the mm code and cgroups where, as an outsider, I got the impression of a large codebase where the patch delta is kept to a minimum -- perhaps so as not to introduce new bugs as features are added. But this doesn't necessarily mean the resulting code has a logical structure or layering; it means deciphering it involves as much studying of the Git history as it does of the (sparsely commented) code on the screen.

In contrast, my experiences in the FreeBSD code have been much better, with less spaghetti and even to the point of maintained man pages for key internal functions.

For high quality JS, I would look to some of the major frameworks out there:

https://github.com/facebook/react

https://github.com/angular/angular.js

https://github.com/angular/angular

There is a lot one can learn about software design by reading the source code of major libraries, and is far more reliable than any third party library in the ecosystem.

To me the Spring Framework represents everything wrong with the Java way of doing things.

Numerous functions missing essential code documentation all spread in a single file, with commented out code committed in git.

    #ifdef VXWORKS

Where do you see a loss in quality?

https://talks.golang.org/2015/gofmt-en.slide ("The Cultural Evolution of gofmt) (2015)

"Evolution in programming culture:

-gofmt is significant selling point for Go

-Insight is spreading that uniform "good enough" formatting is hugely beneficial.

-Source code manipulation at AST-level enables a new category of tools.

-Others are taking note: Programming culture is slowly evolving. "

But there's some parts in there I certainly wouldn't call elegant. For example, if you trace function calls from http.Get() you end up in a lovely function called doFollowingRedirects()[0] which is where the actual request is made inside of a for {} loop.

Be it efficiency, some stylistic tendency I'm unaware of, or some contrived excuse that doesn't make any sense, at the end of the day I'm not likely to look for a function called doFollowingRedirects when I want to see where the initial (and likely only) request is made.

[0]: https://github.com/golang/go/blob/master/src/net/http/client...

https://github.com/richeterre/SwiftGoal

ReactiveCocoa 4, Swift 2.2, MVVM architected, full test suite.

- https://github.com/suseika/inflectible

> Let's get back to class names. When you add the "-er" suffix to your class name, you're immediately turning it into a dumb imperative executor of your will. You do not allow it to think and improvise. You expect it to do exactly what you want — sort, manage, control, print, write, combine, concatenate, etc.

For the curious, the conundrum can be trivially solved via ```apples.min```, or perhaps ```Collections.min(apples)``` in a noun-biased language.

I personally think the variable name length should match the scope size, bu then I'm reasonable like that.

A tip is to look at the function declaration in the header files. There I, at least, use somewhat longer parameter names for descriptive purposes (along with documentation) but usually use short ones in the function bodies.

So, if your functions are short and to the point (low coupling, high cohesion, in Coding Complete parlance), then I consider short parameter and variable names a good style. But it's just one ingredient in good code.

Unless you're looking at competitive programming, I feel the best programmers make clear code with short names.

Short variable names work less well when you have more than about 4 of them in the same function/block or there is no common convention suggesting what the variable might be from its name alone.

Short variable names are also not good for globals or struct members, because those names are used across many contexts. Combine this convention with a short local variable name and you end up getting things like:

    typedef struct {
      int retry_count;
    } connection_t;

    // If "connection_t" is used widely throughout your codebase,
    // you get used to seeing a variable "c" that is a connection.
    void func(connection_t *c) {
      fprintf(stderr, "Retry count: %d\n", c->retry_count);
    }