Ask HN: What code do you frequently read?

Usually you don't just go read source code for the heck of it. You read the source code either to contribute a feature or fix a bug. There's no point in reading the src otherwise because you won't find a good enough reason to try to fully understand it.

Golang stdlib is an excellent reference for how to write idiomatic Go code https://github.com/golang/go/tree/master/src

I pretty much read the code for every dependency I use. It helps me understand how it works and what the docs are fibbing about.

If I can't read the code because it's proprietary, I always strace it to see what it's doing.

For me, it makes it easier to reason about the behavior of my program.

Currently my favorite code to read includes: key/value databases written in C and other "lower level" languages, and the golang standard library packages.

My goal is to complete a game in C++ using SDL2 this year, so i've been reading a ton of that on Github just to see how other people do it.

If I am returning to a piece of code frequently it's not because the code is good, but because the documentation is bad.

Aaron Swartz thought we should read djb's code: http://www.aaronsw.com/weblog/djb

I haven't gotten to it yet, but hope to!

I like looking at OdinMS's source for nostalgia.

When I feel burnt out, I find it refreshing to take a break and look at something I've already accomplished. Sometimes that means source code I've written.

Looking through my code reminds that I can do hard things. I can solve hard problems, even elegantly. Other times it reminds me how painful a project was to finish or I chuckle at how BAD of a coder I was back then compared to now. It helps me feel like I'm making progress despite the relentless stack of issues, problems, and assignments.

And when I do feel motivated to be a better coder, I try to explain somebody else's source code to somebody else. It helps me be a better reader and writer.

The shitty legacy code people that worked at whatever company i'm working for wrote before me, and usually didn't document...

Several hundred of the examples on http://bl.ocks.org/mbostock

Django and Django Rest Framework. DRF docs are pretty bad (though as the saying goes, better than none at all), so I end up reading the code to figure out how to do what I need.

I read Django code when things go wrong or to implement e.g. an auth backend, or see how come get_by_native_key() doesn't always need to take a native key as a parameter.

The code I happen to use at work. This might sound silly, sometime I read code just to understand one specific behavior, say one method and come back to it later because I need to know something else.

I have this data access library I've been chipping away at for about 7 years now. Started it when .NET 2 was fresh and hip and we were still stuck on .NET 1.1 at work. I really started it because my coworkers couldn't be trusted to dispose of their command and connection objects correctly. But I've kept using it because I keep finding ways to add features to it to make my next project very productive.

So, about once every 6 months I read through it to see if there are any obvious features I can add. Then I read through it to see if there are features I can collapse. It's been interesting to see the features grow linearly, but the code base grow logarithmicaly.

People have asked me why I didn't just use LINQ to SQL or Entity Framework or whatever, but I don't think they understand that A) those things didn't exist at the time, and B) there's something about having a tool that you know inside-out.

I read lodash's source to get a feel for how to write fast, high-level, bug-avoiding js. There are a few good ideas in it, like aliasing base methods like 'Array.splice' to a function 'splice' to prevent someone breaking your code by cloberring/overriding these methods.

AOSP https://source.android.com/

I re-visit my old code. Due to how I'm constantly thinking about how much better it could have been. Not that I doubt my abilities. Its just that I wish I knew back then what I know now. Not only my coding skills, but about the problem I was trying to solve.

Website code from the Dev Console / Element Inspector in Chrome.

In terms what I return to, I refer to the LZ algorithm quite often. LZ77 and LZ78 are beautiful in the simplicity and power of their logic. I used to like to look at PRNGs, for example the one in RC4, and hashes. I like the question -- "How do they get so much entropy from so few lines?"

Occasionally I'll look at a one or two line functional programming routine in Python to see about the question, "How can this be done more neatly, elegantly, simply or quickly?"

Algorithms are beautiful, not the code. Code is just worldly forms, which are all an illusion.

Other people's examples!

I frequently search Google for a class name and append 'site: github.com' in order to search all the source hosted on GitHub for examples on how others are using said class.

I enjoy reading well-written C code, and in my opinion, two very good examples are redis and the Quake 3 source (the same goes for all other id/Carmack code).

Reading the Quake stuff is doubly enjoyable thanks to Fabien Sanglard's excellent Code Review series: http://fabiensanglard.net/quake3/ (he's also done them for many (all?) of the other open sourced id games.

I used to read the Neo4j source (I wanted to write my own graph database). Then I was always reading the Django ORM source as reference for a Neo4j / Django ORM integration I was working on (https://github.com/scholrly/neo4django).

I've found that diving into a code base is a great way to learn about a new topic or language, and to get rid of the "magic".

I can't think of any code which I read and reread. For that matter, there are few books that I reread frequently.

The closest is for a software library which I use only occasionally, where it takes a few non-intuitive lines to get things set up correctly. Someone developed an easier API for it, which is closer to the way I think about the problem. When I need to X, I consult that software to see how to implement it.

Back when I was playing with PLDI, I would read the source code for the simpler garbage collectors out there as well as several I wrote myself. Amazing how touchy and error-prone it can be. It taught me a lot, because programming a garbage collector is as one source who I can't remember off the top of my head put it: programming with your back against the wall. Every memory allocation is serious business.

I read the express.js source quite a few times. I wanted to reason out how one goes from raw node to something like express. I found it well written, but to really understand it I found myself making toy versions of each functionality. http://www.nickstefan.net/blog/view/express-under-the-hood

I read a lot of JRE/JDK source code (through IntelliJ, which probably comes from OpenJDK) just to see how they implement their classes. For example, I found out a few days ago that Collections.sort uses a dual pivot quicksort that I had never heard about before. I'm going to check out some Go stdlib next, I had no idea that was open source. Oh, and possibly the OpenBSD kernel.

I read Magento's code (both 1.x and 2) every time I implement something for it. I seen some developers just started to write something, resulting the coding style been quite different than it should be. Reading the core also helps to get comfortable with the coding standard and naming conventions.

Also, Magento 2's code is beautiful, despite it's written in PHP :)

The Stripe bindings (primarily Ruby, Node and PHP). The API docs don't show how to do anything so being able to see what is expected and the format from the function header is very helpful when helping out in IRC. Reading through the pull requests is also helpful in learning / speculating on some new features (this is pretty rare though)

Decompiled ActionScript looking for vulnerabilities. Using https://www.free-decompiler.com/ to decompile and analyzing the code in my own tools.

I really love the clean code the decompiler gives you, compared to packed JavaScript which is just a pain to read for a human.

Learning Android on the side so I read simple projects to see how activities or fragments are implemented, etc.

The Scala Standard Library: https://github.com/scala/scala/tree/2.11.x/src/library/scala

My goto codebase to reference java is https://github.com/elasticsearch/elasticsearch

I've been using http://referencesource.microsoft.com quite frequently.

As a C# developer, I used to read the mono code base a lot. There are so many things about the CLR I've learned from reading it.

Lately I've been sifting through the OpenBSD kernel's source code. I'd like to write a driver or two for it some day.

I read a lot of my old Python whenever I need to cheer myself up. Not sure why it helps.

Broken code.

For some reason I've always thought that recursive coding is the most beautiful.

Function Pearls. Generally code in papers.

django and AOSP