Ask HN: What open source project, in your opinion, has the highest code quality? - <AUTHOR> <comment><USER2> I hold the source code of Go standard library & base distribution (i.e. compiler, etc.) in very high regard. Especially the standard library is, in my opinion, _stunningly_ easy to read, explore and understand, while at the same time being well thought through, easy to use (great and astonishingly well documented APIs), of very good performance, and with huge amounts of (also well readable!) tests. The compiler (including the runtime library) is noticeably harder to read and understand (especially because of sparse comments and somewhat idiosyncratic naming conventions; that's partly explained by it being constantly in flux). But still _doable_ for a human being, and I guess probably significantly easier than in most modern compilers. (Though I'd love to be proven wrong on this account!)

At the same time, the apparent simplicity should not be mistaken for lack of effort; on the contrary, I feel every line oozes with purpose, practicality, and to-the-point-ness, like a well sharpened knife, or a great piece of art where it's not about that you cannot add more, but that you cannot _remove_ more.

<comment><USER3> I'd agree, but only as far as aesthetics go. When you have to understand the time complexity and runtime characteristics of the standard library sorting algorithms, I think Go does a very bad job - the standard `sort.Sort(data sort.Interface)` will run poorly if the data is already mostly sorted. I expect these kinds of things to be documented properly.

<comment><USER4> I was pretty certain most libraries shuffle then quicksort. No need for documentation. Does go not do this?

<comment><USER5> Ever heard of Timsort?

<comment><USER6> People were still finding bugs in common implementations of timsort as of 3 years ago. It's not unreasonable to stick with a somewhat more conservative choice for a core library function until there's more reason to have confidence in the implementations of timsort.

<comment><USER7> This comment got me looking into timsort bugs. This was a really interesting read: [http://envisage-project.eu/proving-android-java-and- python-s...](http://envisage-project.eu/proving-android-java-and-python- sorting-algorithm-is-broken-and-how-to-fix-it/)

</comment></comment></comment></comment></comment></comment><comment><USER8> SQLite.

and for this reason alone!

[https://www.sqlite.org/testing.html](https://www.sqlite.org/testing.html)

        As of version 3.23.0 (2018-04-02), the SQLite library consists of approximately
        128.9 KSLOC of C code. (KSLOC means thousands of "Source Lines Of Code" or, in
        other words, lines of code excluding blank lines and comments.)

        By comparison, the project has 711 times as much test code and test scripts -
        91772.0 KSLOC.

<comment><USER9> Automated testing is useful and good. But I really feel it's reached a lever of fetishisation that is quite concerning.

Testing code is code which needs to be written, read, maintained, refactored. Very often nowadays I have to wade through tests which test nothing useful, except syntax. Even worse, with developers who adopt the mock-everything approach, I often find tests which only verify that the _implementation_ is exactly the one they wrote, which is even worse: it makes refactoring a pain, because, even if you rewrote a method in a better way which produces exactly the results you wanted, the test will fail.

So, the ratio of testing code vs implementation code is a completely wrong proxy for code quality.

EDIT: I'm not criticising SQLite and their code quality - which I never studie - but the idea that you can judge code quality for a project just by the ratio of test code vs implementation code.

<comment><USER10> They actually have to test to that degree to follow aviation standards (DO-178b [0]) because they're used in aviation equipment.

Dr. Hipp said he started really following it when Android came out and included SQLite and suddenly there were 200M mobile SQLite users finding edge cases: [https://youtu.be/Jib2AmRb_rk?t=3413](https://youtu.be/Jib2AmRb_rk?t=3413)

Lightly edited transcript here:

> It made a huge difference. That that was when Android was just kicking off. > In fact Android might not have been publicly announced, but we had been > called in to help with getting Android going with SQLite. [Actually], they > had been publicly announced and there were a bunch of Android phones out and > we were getting flooded with problems coming in from Android.

> I mean it worked great in the lab it worked great in all the testing and > then [...] you give it to 200 million people and let them start clicking on > their phone all day and suddenly bugs come up. And this is a big problem for > us.

> So I started doing following this DO-178b process and it took a good solid > year to get us there. Good solid year of 12 hour days, six days a week, I > mean we really really pushed but we got it there. And you know, once we got > SQLite to the point where it was at that DO-178b level, standard, we still > get bugs but you know they're very manageable. They're infrequent and they > don't affect nearly as many people.

> So it's been a huge huge thing. If you're writing an application deal ones, > you know a website, a DO-178b/a is way overkill, okay? It's just because > it's very expensive and very time-consuming, but if you're running an > infrastructure thing like SQL, it's the only way to do it.

[0]: [https://youtu.be/Jib2AmRb_rk?t=677](https://youtu.be/Jib2AmRb_rk?t=677) "SQLite: The Database at the Edge of the Network with Dr. Richard Hipp"

<comment><USER11> SQlite is very high quality software, but they use DO-178b "inspired" testing process. As far as I know they don't have version of software that is or can be used in safety critical parts despite their boasting.

They say in their site that:

> Airbus confirms that SQLite is being used in the flight software for the > A350 XWB family of aircraft.

Flight software does not imply safety critical parts of avionics. It can be the entertainment system or some logging that is not critical.

<comment><USER12> Correct. The key word is "inspired". Multiple companies have run a DO-178B cert on SQLite, I am told, but the core developers did not get to participate, and I think the result was level-C or -D.

While all that was happening 10+ years ago, I learned about DO-178B. I have a copy of the DO-178B spec within arms reach. And I found that, unlike most other "quality" standards I have encountered, DO-178B is actually useful for improving quality.

I originally developed the TH3 test suite for SQLite with the idea that I could sell it to companies interested in using SQLite in safety-critical applications, and thereby help pay for the open-source side of SQLite. That plan didn't work out as nobody ever bought it. But TH3 and the discipline of 100% MC/DC testing was and continues to be enormously helpful in keeping bugs out of SQLite, and so TH3 and all the other DO-178B-inspired testing and refactoring of SQLite has turned out to be well worth the thousands of hours of effort invested.

The SQLite project is not 100% DO-178B compliant. We have gotten slack on some of the more mundane paperwork aspects. Also, we aggressively optimize the SQLite code base for performance, whereas in a real safety-critical application the focus would be on extreme simplicity at the cost of reduced performance.

However, if some company does call us tomorrow and says that they want to purchase a complete set of DO-178B/C Level-A certification artifacts from us, I think we could deliver that with a few months of focused effort.

<comment><USER13> I just bought a copy of DO-178C after reading these posts here and the Wikipedia article on it. $290, but if it's good, it should be worth it, right?

<comment><USER12> I haven't seen -C only DO-178B, though I'm told there isn't much difference. It is not a page-turner. It took me about a year to really understand it.

</comment></comment></comment></comment></comment></comment></comment><comment><USER14> OpenBSD and Co. (OpenSSH, etc.)

* [https://cvsweb.openbsd.org/src/](https://cvsweb.openbsd.org/src/)

* [https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/](https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/)

* [https://www.libressl.org/](https://www.libressl.org/)

* [https://cvsweb.openbsd.org/src/usr.sbin/ntpd/](https://cvsweb.openbsd.org/src/usr.sbin/ntpd/)

<comment><USER15> for sure not. OpenBSD makes no attempt to use proper performance which is critical for a kernel. there are so many naive ad-hoc data structures and algos, it's a shame to walkthrough.

<comment><USER16> How is performance related to code quality. That makes no sense. If anything, if you had to inline ASM for example, the code would suffer from readability.

<comment><USER17> Shouldn't good performance be one of the goals of good code?

<comment><USER14> Depends on the design goals. If you want secure code, you'll make it readable. Here's true(1):

      :

A single "noop" in a 755 file.

A C true would be: [https://cvsweb.openbsd.org/src/usr.bin/true/true.c?rev=1.1&c...](https://cvsweb.openbsd.org/src/usr.bin/true/true.c?rev=1.1&content- type=text/x-cvsweb-markup)

Here's a much faster true(1) if you need it: [https://github.com/coreutils/coreutils/blob/master/src/true....](https://github.com/coreutils/coreutils/blob/master/src/true.c)

<comment><USER18> How is the coreutils true faster?

I would expect the openbsd true to be the fastest, it doesn't need to spawn a subshell and it doesn't do more than the posix specification requires (afaik --help/\--version should be ignored).

<comment><USER14> Experience shows it's faster. It's just weird, but it's like that.

      time { for i in $(seq 1 10000); do /path/to/true; done; }

<comment><USER17> What are you comparing against what there? Two C executables with the same compiler flags on the same OS?

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER19> NetBSD.

Why? I was able to do substantial changes to the kernel when I was a teenager (late 90s), mostly on my first try. There was no giant wall of abstraction I had to climb over or some huge swath of mutually interacting code I had to comprehend. There was also nothing that required fancy code navigation and the creation of something like the ctags database in order to find out what on earth was happening.

No action at a distance or lasagna style dereferencing or mysterious type names that are just typedef'd and #define'd around dozens of times back to something basic like char. No fancy obscure GNU preprocessor extensions or exotic programming patterns.

Nothing had obtuse documentation that tried my patience or required much more than enthusiasm and basic C knowledge.

I did things like got a wireless card working from code written for one with a similar chipset and got various other things like the IrDA transmitter on my laptop at the time to do a slattach and thus work as a primitive wireless network - all in the late 90s.

I likely had no idea what, say, the difference between network byte order and host byte order was at the time or how the 802.11b protocol worked or what a radiotap header was or any of that. The separation of concerns was so good however, that none of that knowledge was actually needed.

Compare that to say, the Qualcomm compatible WWAN I just dealt with over the past few weeks where I needed to have in-depth knowledge of an exhaustive number of things (very specific chipset and network details) to get a basic ipv4 address working. Then I needed to read up on GNSS technology and NMEA data to debug codes over USBmon to get the GPS from the wwan working. Then after I had the qmi kernel modules doing what I wanted and the qmi userland toolsets, I had to write some python scripts to talk to dbus to get the data from the modemmanager that I needed in order to log the GPS. All the maintainers of these pieces were very nice and helpful and I have nothing negative to say. This is just how it usually is these days.

Back then however, I wasn't a good programmer, I was likely pretty terrible in fact but with the NetBSD codebase I was able to knockout whatever I wanted every time, fast, on a 486.

I miss those days.

<comment><USER2> What's your relation with it nowadays? I'm very curious about NetBSD but never tried it yet. I sincerely wonder what's your opinion on it now, and why you speak about the situation only as "those days" now? :)

<comment><USER19> I have no idea, haven't kept up with it. I'd recommend 1.x (<=4) any day though, simply for the education alone.

I don't really use it these days because I need systems that future cheap devs can maintain and once you enter userland it takes commitment and time I simply don't have to stay with netbsd.

Debian permits me to usually not have to care and that's pretty invaluable

</comment></comment></comment><comment><USER20> Its older than some HN posters, but the GPLed DOOM source code was one I liked.

The performance reached by the game was considered impossible until Carmack did show us otherwise. So I expected lots of ASM and weird hacks, especially as compiler optimization wasnt as good as it is today.

Surprise, surprise, the thing was easy to read, easy to get going, easy to port, reasonablye documented . It has shown me what a goog balance between nice code and usable code is.

If you want tho browse: [https://github.com/id- Software/DOOM](https://github.com/id-Software/DOOM)

<comment><USER21> FYI, "Surprise, surprise" is generally meant sarcastically. I think you mean "Surprisingly".

[https://www.merriam- webster.com/dictionary/surprise,%20surpr...](https://www.merriam- webster.com/dictionary/surprise,%20surprise)

<comment><USER20>
      I can speak English!  I learn it from a book!

Though not always very good. Thanks for the bugfix.

</comment></comment></comment><comment><USER22> This is not necessarily about the code, but I've been really impressed for a while by the lodash project and its maintainer's dedication to constantly keep the number of open issues at 0. Any issues get dealt with at record speed, it's quite a sight to see.

[https://github.com/lodash/lodash/issues](https://github.com/lodash/lodash/issues)

<comment><USER23> Not necessarily relevant, but 15% of the issues are labeled "wontfix".

<comment><USER24> With such a big project, being quick to hand out wontfix isn't necessarily a bad thing. To be honest, seeing as this project is used by a huge part of the… rather diverse JS crowd, 15% wontfix is _astoundingly low_.

</comment></comment></comment><comment><USER25> Strictly talking about code quality, I will nominate RCP100, which is a small, virtually unknown, now-abandoned routing software written in C [0]. I started programming with C way back in the 90s, and this is one of only _two_ projects I can recall being immediately struck by the beauty of the code (Redis being the other). I know almost nothing about the author but he seems not to want to be known by name. You can browse the source on Github [1], which I uploaded myself, since you can only get a tarball from sourceforge. Anyway, as someone else mentions, C is usually a mess, but RCP100 struck me as beautiful.

[0] [http://rcp100.sourceforge.net/](http://rcp100.sourceforge.net/)

[1] [https://github.com/curtiszimmerman/rcp100](https://github.com/curtiszimmerman/rcp100)

<comment><USER26> Maybe you just send the guys an email ;)

<comment><USER25> I actually did send fan mail to the author, heh, thinly-disguised as a courtesy to let them know that I mirrored their project on Github.

</comment></comment></comment><comment><USER27> I'm surprised no one has mentioned the Linux Kernel!

[https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/lin...](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/)

It is quite clean when you consider the task that it accomplishes.

Being able to compile across multiple architectures/endian- ness,32/64-bit/scale up/down from server/desktop/router/phone while accepting contributions from thousands of people..

<comment><USER28> It's not clean at all. Thousands of different styles, no single convention on function-naming, etc.

Want a clean kernel, go look at the BSDs.

</comment></comment><comment><USER29> Going to throw Elixir Lang into the mix.

\- The tooling is excellent.

\- The code is well-documented and readable.

\- The core team committed to never needing to introduce breaking changes.

The Elixir community tends to produce work that is actually considered "Done". An elixir package is not stale when it hasn't seen a commit in a few months. Instead, the feeling is: "It's feature complete and only needs maintenance from here on out."

[https://github.com/elixir-lang/elixir](https://github.com/elixir-lang/elixir)

<comment><USER30> > The core team committed to never needing to introduce breaking changes.

Is this why Elixir seems to have many different ways of doing the same thing though?

<comment><USER31> I think that's one reason. The other is that classic erlang (Elixir is built on top of the erlang beam vm) sometimes does things one way but elixir has a more elegant way of doing the same thing, however, in elixir you can still call into erlang libraries to achieve the same thing if that's more familiar to you.

</comment></comment></comment><comment><USER32> Scikit Learn comes to mind - not just because I can dig into the source code and immediately know what's happening, but also for the stellar documentation that goes above and beyond telling your what the functions do.

For example their Cross Validation documentation is amazing:

[http://scikit- learn.org/stable/modules/cross_validation.html...](http://scikit- learn.org/stable/modules/cross_validation.html#cross-validation-iterators)

</comment><comment><USER33> When we take the language into consideration, unwound like to mention Redis.

Often codebases written in C are a a mess to understand, a mess to read. The Redis Source Code is understandable even without deep knowledge of C

<comment><USER34> Yep. I was going to say Redis and SQLite. Both are really well commented. They almost read like a manual.

<comment><USER35> Although still in beta, I'd like to add BearSSL to the mix of well written and documented C libraries. In particular compared to the OpenSSL "documentation". It's also nice to see an TLS implementation without any memory allocations at all.

</comment></comment></comment><comment><USER36> I'd prefer if people said _why_ they consider the code good, instead of throwing out a bunch of random projects.

</comment><comment><USER37> Python: I really like requests, scikit-learn, the Path module from the stardard library, Keras, Django.

C: Redis, SQLite, LUA.

Java: Joda Time, Guava

<comment><USER38> Joda Time is one of my all time favourite libraries.

After struggling with JVM stdlib time nonsense, JodaTime was a breath of fresh air and actually made programming with time fun.

<comment><USER39> Java 8 time module is now considered the replacement for JodaTime for new projects. It is separate from the older Java time libraries, and fixes many of the problems in Joda. Give it a try!

</comment></comment></comment><comment><USER40> ARM mbed TLS [1], Amazon S2N [2], nginx [3] have a super consistent code style throughout and are prime examples of how C application programming should be done (in my opinion).

[1] [https://github.com/ARMmbed/mbedtls](https://github.com/ARMmbed/mbedtls)

[2] [https://github.com/awslabs/s2n](https://github.com/awslabs/s2n)

[3] [https://github.com/nginx/nginx](https://github.com/nginx/nginx)

<comment><USER41> +1 for s2n. It's one of the select few C codebases that is actually a pleasure to read.

</comment></comment><comment><USER42> There are too many in very different domains and languages.

However, I opt for jQuery here. It is one of the greatest examples of how constant refactoring and thoughful usage of design pattern get you a very long way.

If you are designing JavaScript libraries, pls have a look at jQuery. So many great design decisions aka great code quality.

<comment><USER43> Pushing all dom manipulation through global evals seems like the exact opposite of thoughtful design to me. I have a long list of places where I want to implement strict CSPs, but can't purely for minor use of jQuery.

</comment></comment><comment><USER44> Sequel, a database ORM for Ruby: [https://github.com/jeremyevans/sequel](https://github.com/jeremyevans/sequel)

The quality of the code is amazing, it's simple to use and even simpler to look through the docs to reason about.

I also want to praise the author of the library (Jeremy Evans), his support through the IRC is second to none, you can talk directly with him pretty much on a daily basis.

And even after 8+ years, the project is still constantly being updated (last commit 4 days ago). I haven't seen too many project of this calibre especially when it is ran mostly by a single person.

</comment><comment><USER45> Julia. Julia / Julialang is so pedantically tested and the names are pretty meticulously chosen. The algorithms in Base are almost all generic and handle a very wide variety of inputs without catering to them. If you want to learn Julia, along with good software engineering, looking at the Base library is quite recommended.

<comment><USER46> Did not look to much into it but at least a packager from Alpine Linux does not think Julia's compiler ecosystem is clean/easy to work with: [http://lists.alpinelinux.org/alpine- devel/6248.html](http://lists.alpinelinux.org/alpine-devel/6248.html)

But as said, I did not really checked this claim for validness myself...

<comment><USER45> Julia requires patched versions of things like LLVM in order for all tests to pass because upstreaming bugfixes take time. This has given some Linux package managers an issue since they try to build using system LLVM/OpenBLAS/etc. with the known bugs. I agree this does cause some distribution problems, but as a scientist and mathematician I do like that the standard distribution of Julia uses the most numerically correct versions (as of current knowledge) of the dependencies as it can, and has a test to identify known potential issues. To me this is good practice.

But anyways, I was talking about the Julia Base library and its numerical routines. I just look at the Julia code and don't touch the build systems.

</comment></comment></comment><comment><USER47> Does assembly count? Prince of Persia's source code (not really open source...): [https://github.com/jmechner/Prince-of-Persia-Apple- II](https://github.com/jmechner/Prince-of-Persia-Apple-II)

One look at any of the assembly files and you can get a sense of how properly organized the source code is.

<comment><USER48> Thanks for that! I love looking at historical game code.

</comment></comment><comment><USER49> I'm a bit surprised nobody mentioned qmail yet: [https://cr.yp.to/qmail.html](https://cr.yp.to/qmail.html)

<comment><USER50> I don't know about qmail, but postfix sources are really nice.

<comment><USER51> They're better than most C software of the era, but not better than qmail --- qmail has a better vulnerability record than Postfix does (perhaps because it does less, but that's beside the point).

</comment></comment></comment><comment><USER52> Granted I haven't read much open source code but when I was working in Flask, I found the source code to be awesomely clear and well-documented. I actually learned quite a bit about Python by reading Flask code. Also, no-one could explain "g" in a way that made sense, but the source code made it obvious. Would recommend reading it if you're into Python at all.

<comment><USER53> g?

<comment><USER54> The global request object if I recall properly.

</comment></comment></comment><comment><USER55> I'd like to suggest;

1\. Don't simply list projects.

2\. Give some notion of _why_ you're nominating code.

3\. A sense of what you consider to be quality.

Enough to spark discussion, inquiry, or comparison. Doesn't have to be much.

This is rudimentay. But affords purchase; [https://news.ycombinator.com/item?id=18037815](https://news.ycombinator.com/item?id=18037815)

This does not: [https://news.ycombinator.com/item?id=18038047](https://news.ycombinator.com/item?id=18038047)

(Both reference the same project.)

</comment><comment><USER56> Both Vue and PostgreSQL. Both have great code base. Amazing documentation. And amazing communities.

<comment><USER57> Nice to see you include / mention docs and community. I believe a code-based product has a UX. That UX is the code (with comments), documentation and community. That UX is your (i.e., a dev / engineer) end to end experience with "the product." It's not simply the code.

Put another way, there's more to a product that's easy and sensible to work with than code quality.

</comment></comment><comment><USER58> I'm suprised nobody cited TeX from Knuth. It's an absolute standard in quality of implementation, documentation and computer science background. Perhaps unsurpassed.

</comment><comment><USER59> I definitely admired PostgreSQL's code when I first looked at it.

Projects written in C require a fair amount of care and discipline to be scaled up to larger codebases and teams. PostgreSQL is such a codebase.

I've also seen various parts of Spring's codebase and found all of it to be consistently solid and careful. They take a lot of care to structure carefully and comment immaculately.

Disclosure: I work for Pivotal, which sponsors Spring. Which is why Spring is highly visible in my working life.

</comment><comment><USER60> Typescript

Even though it's a fairly complex transpiler, the authors did a good job modularizing and leaving lots of contextual comments on what each part does.

Also typescript baseline tests are a simple but very effective way to get lots of coverage on the compiler.

I've read source code for Babel, typescript, coffeescript and flow. Typescript architecture stands out.

Typescript not only does fascinating things like magical code completion abilities and great tooling for IDEs but their codebase has been an inspiration for me to build better front end code.

I may be a bit biased since I've worked at Microsoft before.

<comment><USER61> I found the TypeScript type checker pretty hard to read through, though it may be my lack of, well, almost any knowledge about type theory. I didn't dig much into the other parts of the codebase however. What parts of it do you enjoy reading?

<comment><USER60> While submitting a PR, the parser, Lexor and emitter were fairly easy to understand.

</comment></comment></comment><comment> daniel-levin LLVM and associated projects such as clang. Bazel is good too. OkHttp and Retrofit by Square.

<comment><USER62> I've been working with LLVM for a few years and I still find the code difficult to navigate and badly documented. And every single function's argument list is a random jumble of pointers and references (almost all arguments _should_ be references, but many aren't).

<comment><USER63> Indeed. And it's not just medium to low-level stuff that's not well documented, it's the high-level stuff too. I personally don't mind that much if I have to spend a few minutes to understand something on a a very local scope, but if the bigger picture is unclear, that's quite bad. For LLVM one largely has to grep for a bunch of other users and try to figure it out from that.

While I think it has some clear deficiencies, I found a lot of e.g. the optimization passes in GCC a lot easier to read. It's probably above par, but e.g. [https://github.com/gcc-mirror/gcc/blob/master/gcc/gimple- ssa...](https://github.com/gcc-mirror/gcc/blob/master/gcc/gimple-ssa-store- merging.c) is really well explained imo.

</comment></comment></comment><comment><USER64> The requests codebase is really well written and it has a beautiful api

[https://github.com/requests/requests](https://github.com/requests/requests)

<comment><USER65> I like Kenneth's comments: [https://github.com/requests/requests/blob/master/requests/pa...](https://github.com/requests/requests/blob/master/requests/packages.py)

</comment></comment><comment><USER66> Tcl! See [https://www.tcl.tk/doc/engManual.pdf](https://www.tcl.tk/doc/engManual.pdf) to start to understand why. (For code written in Tcl itself there's also some proposed conventions: [https://www.tcl.tk/doc/styleGuide.pdf](https://www.tcl.tk/doc/styleGuide.pdf))

</comment><comment> a-saleh I really liked the clojure core, I read it quite a lot when learning the language.

I have heard good things about sqlite, and some day, I plan to read it :-)

</comment><comment><USER67> Dolphin Emulator

[https://dolphin-emu.org/](https://dolphin-emu.org/)

<comment><USER68> We try to keep up, but the truth is that it's a 15 years old C++ codebase implementing some weird hardware in even weirder ways. We're far from where we'd want to be code quality wise -- close to no automating testing infrastructure, code is full of module-level globals, inconsistent conventions, etc.

<comment><USER69> How would you even test an emulator except manually? It seems like automated website testing, but even worse. I guess screenshots + scripted input?

That seems like it'd be terrible to try to get running reliably.

</comment></comment></comment><comment><USER70> The JUCE C++ library is very nice: [https://github.com/WeAreROLI/JUCE](https://github.com/WeAreROLI/JUCE)

</comment><comment><USER71> I'm no C expert so I'm somewhat guessing, to me, PostgreSQL source looks remarkably clean, well structured and nicely commented.

</comment><comment><USER72> The Quake 3 source was fairly good...

<comment><USER73> As a C beginner getting into writing larger projects, especially in that sort of context, the quake source has been my reference on how to structure my code.

</comment></comment><comment><USER74> I was going to say the GNU version of /bin/false and /bin/true, but I actually took a look at the source and it is terrible.

<comment><USER75> The original /bin/true is probably the highest quality code ever written, but unfortunately I don't think the license is OSI approved: [http://trillian.mit.edu/~jc/%3B-)/ATT_Copyright_true.html](http://trillian.mit.edu/~jc/%3B-\)/ATT_Copyright_true.html)

<comment><USER76> Gosh, it seems like copyright lawyers will stop at nothing.

</comment></comment></comment><comment><USER77> Python core libraries have great code. You can open pretty much any module and be able to understand the source without much context.

<comment><USER78> I don't know how you can say this. The standard lib isn't even very pythonic, let alone "great" along other dimensions.

<comment><USER79> Agreed. Almost every time I've looked deeply into stdlib code I was surprised by how hard to follow it is and how frequently antipatterns are employed. Doubly so for anything near a C module.

I consider the Python stdlib in a similar vein as the C++ stdlib or Boost: Yes, some useful bits in there, but (1) lots of rot (2) you don't want to have your code look anything like it.

</comment></comment></comment><comment><USER80> In PHP land where I spend time for work.

Hands down Symfony.

</comment><comment><USER81> Golang and Kubernetes have been highly regarded as high quality. I particularly found the Golang code for Kubernetes to be well documented and well architected.

</comment><comment><USER82> Knuth did a good job on TeX, and it has been closely examined for many years since so there are very few bugs.

<comment><USER50> The TeX language itself, and the logs and error messages of TeX are so bad, that I would hardly believe it.

<comment><USER83> Are you sure you aren't thinking of LaTeX?

TeX (plain TeX, not LaTeX) has phenomenally good logging and error messages IMO — everything you need is there, each error message comes in a "formal" and "informal" form and points you to exactly the place the error happened, and TeX lets you fix things on-the-fly without restarting the program. All this of course assumes you use TeX the way it is described in the manual (The TeXbook). The experience is opposite with LaTeX, so I find it worth giving up all the convenience of LaTeX just for the wonderful experience with TeX.

As for "the TeX language", there is no such thing. As Knuth has said many times, TeX is designed for typesetting, not programming. Sure it has macros to save some typing, but if you're writing elaborate programs in it (as is nearly inevitable if you're using LaTeX) you're doing something wrong. Knuth said:

> When I put in the calculation of prime numbers into the TeX manual I was not > thinking of this as the way to use TeX. I was thinking, "Oh, by the way, > look at this: dogs can stand on their hind legs and TeX can calculate prime > numbers."

But of course LaTeX does every such thing imaginable :-)

More on TeX not being a programming language: [https://cstheory.stackexchange.com/a/40282/115](https://cstheory.stackexchange.com/a/40282/115)

On the TeX error experience: [https://news.ycombinator.com/item?id=15734980](https://news.ycombinator.com/item?id=15734980)

<comment><USER84> _Plain TeX_ is different to _TeX_ :

..."virgin" TeX...knows just primitive commands, no macros. Plain TeX is the set of macros (developed by Knuth) which makes TeX usable in everyday life of a typist. ... The available commands can be classified into primitive commands and macros. ... The "virgin" TeX knows only the primitive commands. ... Formats (plain TeX, LaTeX, etc.) extend TeX's vocabulary by defining macros. ...For example, plain TeX defines macros \item, \rm, \newdimen, \loop, etc. Plain TeX defines about 600 macros.

[https://tex.stackexchange.com/questions/97520/what-is- plain-...](https://tex.stackexchange.com/questions/97520/what-is-plain-tex)

<comment><USER83> Yes of course; see this answer I wrote about typesetting with "virgin" TeX: [https://tex.stackexchange.com/a/388360/48](https://tex.stackexchange.com/a/388360/48) (it's not easy). "Virgin" TeX is never (and was never) used by typical users, and is used only by the system administrator (or these days, the people behind the TeX distributions) to pre-load formats (like plain or LaTeX).

Knuth wrote both the TeX program and the "plain" set of macros; when you start `tex` it is with `plain` that it starts up, and _The TeXbook_ describes both the TeX program and the plain format without being careful to distinguish what comes from where (you have to look at Appendix B to see the proper definition of plain.tex), so when we speak of TeX as Knuth intended/imagined it to be used, it is plain TeX that is meant.

</comment></comment></comment></comment></comment><comment><USER85> OpenBSD

[https://www.openbsd.org/goals.html](https://www.openbsd.org/goals.html)

</comment><comment> DanWaterworth<USER12>
</comment><comment><USER87> Lua: [https://www.lua.org/](https://www.lua.org/)

</comment><comment><USER88> To me that would be Appleseed rendering engine.

[https://github.com/appleseedhq/appleseed](https://github.com/appleseedhq/appleseed)

Even though I can't code C++, I can read it here and understand most of it (besides the maths).

</comment><comment><USER89> I particularly like reading code from Upspin (upspin.io). Its probably partially because I think the project design is interesting and write go. Regardless, its a great ground up Go project by some of the original Go authors and contributors.

Very well organized code and it feels like they got the project off the ground, fixed bugs for a few months, and now have largely trailed off from maintaining it largely because it just works (I use it) which lends some credibility to their coding style. Of course, I'd like to see the project evolve conceptually, but, right now it does what it says it does reliably for a project that hasn't even cut a single release.

</comment><comment><USER90> radare2 - [https://github.com/radare/radare2/](https://github.com/radare/radare2/) More GNU than actual GNU sources, more UNIX than the linux kernel. Huge codebase but extremely easy to get involved with, orthogonal design with no compromise on speed. Best codebase I ever encountered

</comment><comment><USER91> PostgreSQL and Quake3 are good candidates. Both are C codebases which are surprisingly readable even by relative novices.

</comment><comment><USER92> I think musl libc [1] has good quality code. If anything their build system is great. It makes the code much easier to navigate.

[1] [https://www.musl-libc.org](https://www.musl-libc.org)

<comment><USER93> [https://git.musl- libc.org/cgit/musl/tree/src/string/strcspn....](https://git.musl- libc.org/cgit/musl/tree/src/string/strcspn.c#n14)

[https://git.musl- libc.org/cgit/musl/tree/src/stdio/vfprintf....](https://git.musl- libc.org/cgit/musl/tree/src/stdio/vfprintf.c#n561)

ah yes, good quality code

<comment><USER94> I still think musl overall is quite readable, but my goodness, that switch statement in your second example. What a monster. I didn't think it was possible to be this confusing without the preprocessor.

</comment></comment></comment><comment><USER95> On the JavaScript side I've enjoyed reading the code for Backbone and Underscore, helped also by the awesome in-line documentation. Very easy to see what is going on.

Also big fan of Sidekiq for similar reasons.

</comment><comment><USER96> BabylonJs is a wonderful clean code. Made to write 3D on the Web. [https://www.babylonjs.com/](https://www.babylonjs.com/)

</comment><comment><USER97> most people are talking about clean code, good design constructs, but i feel that many are missing the point, we're talking about code quality here, design is the grit and grind that all developers go through to develop great software, certainly there are better designed software projects out there that leaves them more maintainable and prone to less bugs, but the fact of the matter is that for complicated code, designs go through many iterations and refactorings over time e.g. linux kernel, all software projects have bugs, even well designed or well tested software. but the significance of good testing and good processes are not being highlighted here, unit testing, code coverage, functional testing, end to end testing,scale testing, performance testing, code review, fault injection, debuggability, test automation, static code analysis, etc, i am shocked not to see lots of discussion on these things (aside from the sqlite mention) and testing techniques. probably a more developer friendly crowd here at hn, but testing is a significant and game changing part of what separates developers from great developers.

</comment><comment><USER98> I like the Laravel framework. It has a clean style to it.

</comment><comment><USER99> Postgres.

<comment><USER100> Definitely agree with this. Both the documentation and code are of excellent quality. Others that come to mind are sqlite and zeromq.

</comment></comment><comment><USER101> my first experience with high quality code was with tge quake2 engine.

i was both amazed by the simplicity of the architecture (a huge single event loop), and the attention to code presentation and indentation.

<comment><USER102> Interesting to see so many John Carmack projects in this thread. He's a good candidate for "best programmer of all time", if there were such a thing.

</comment></comment><comment><USER103> Gambit, Chicken, Racket, Chez and Guile Schemes

</comment><comment><USER104> Does 'Physically Based Rendering' count? It's a book... which is also source. It was written as only the 2nd work of true 'Literate Programming' that I know of. I believe Knuth wrote a book about TeX which was the first example. But basically it is prose interleaved with source, readable as a book.

</comment><comment><USER105> Twisted. Not only highly organized and sensibly delineated, but also a lot of fun to read - borderline comical at places.

<comment> iso-8859-1 How do you think the asyncio (formerly Tulip) sources compare?

<comment><USER105> asyncio is more modern, more stylish, and more concrete.

Twisted is more timeless, more patterned, and more self-aware.

I can imagine Twisted's asyncio reactor becoming its default (and the Twisted flow control slowly declining in importance), but Twisted's protocols, control structures, and execution models becoming more popular.

Twisted has undergone a great resurgence in quality engineering since asyncio became more viable - this was surprising to me, but is actually probably reasonably consistent with the way the historical influence of the standard library.

Overall, I think that Twisted is a great project; I almost always reach for it when my python codebase becomes mature enough to need more thoughtful abstractions around network I/O.

</comment></comment></comment><comment><USER106> Actually, I think early versions (like from pre-1.0 through maybe 1.5 or so) of Docker had some very high quality code and was also very pleasing to look at. It was very clean and super approachable and readable, and I felt sort of like how the NetBSD commenter felt as described in their comment.

</comment><comment><USER107> "Highest" I don't know, but "code whose quality I look up to", then:

For C: Process Hacker and some similar code that is designed like and written around Windows kernel APIs: [https://github.com/processhacker/processhacker/blob/master/p...](https://github.com/processhacker/processhacker/blob/master/phlib/basesup.c)

For C++: Some of the Boost code, and stuff like it, such as P-Stade Oven: [https://github.com/himura/p-stade/blob/master/pstade/pstade/...](https://github.com/himura/p-stade/blob/master/pstade/pstade/oven/detail/concat_iterator.hpp)

For others: (need to look later, I forget)

</comment><comment><USER108> Can't say I've seen enough to be confident on the best library but redux ([https://github.com/reduxjs/redux](https://github.com/reduxjs/redux)) is just so simple, and has great, readable/understandable code.

<comment><USER109> In Dan Abramov's excellent egghead redux course [0] he implements the `createStore` from scratch which is the core of redux, it's simple enough to post here:

      const createStore = (reducer) => {
        let state;
        let listeners = [];

        const getState = () => state;

        const dispatch = (action) => {
            state = reducer(state, action);
            listeners.map(listener => listener());
        };

        const subscribe = (listener) => {
            listeners.push(listener);
            // unsubscribe
            return () => {
                listeners = listeners.filter(l => l !== listener)
            };
        };

        // populate initial state
        dispatch({});

        return { getState, dispatch, subscribe };
      };

[0]: [https://egghead.io/lessons/react-redux-implementing-store- fr...](https://egghead.io/lessons/react-redux-implementing-store-from-scratch)

</comment></comment><comment><USER110> After spending about a month of concerted effort pouring through the zlib sources, looking for vulnerabilities, I can say that zlib is the most astonishingly bug-free code I've ever seen. But in the conventional understanding of "code quality", it's pretty bad.

<comment><USER111> Julian Storer (JUCE library) did a talk on code quality using zlib as an example. Might be interesting to you if you've not seen it already.

[https://www.youtube.com/watch?v=SIAAvv1O7Gg](https://www.youtube.com/watch?v=SIAAvv1O7Gg)

</comment></comment><comment><USER112> I'd have to go with Monocypher. It makes very tasteful use of comments, functions and macros to maximize readability and clarity.

[https://github.com/LoupVaillant/Monocypher](https://github.com/LoupVaillant/Monocypher)

</comment><comment><USER113> Toybox by Landley([https://github.com/landley/toybox](https://github.com/landley/toybox)) is probably the best example of a modern c implementation I have ever seen. Surprised no one has mentioned it yet.

</comment><comment> ezequiel-garzon I admit I don't have the knowledge to make my own assessment, but I've read some downright poetic praise on djb's work [1], and more than once.

[1] [https://cr.yp.to/](https://cr.yp.to/)

</comment><comment><USER114> For _Rust_ , many say that the regex crate sets a high standard for excellence: [https://github.com/rust-lang/regex](https://github.com/rust- lang/regex)

</comment><comment><USER115> I study codebases as a hobby. I highly recomend Seastar, Folly, Aeron and Disruptor, SQLite, PostgresSQL, LMDB, Tensorflow, Hashicorp's vault, and the Linux Kernel projects as prime examples of high quality codebases.

</comment><comment><USER116> For clean C++, I like leveldb (a key-value DB library) and re2 (a regex engine). Random files from each of them:

[https://github.com/google/leveldb/blob/master/table/table_bu...](https://github.com/google/leveldb/blob/master/table/table_builder.cc)

[https://github.com/google/re2/blob/master/re2/nfa.cc](https://github.com/google/re2/blob/master/re2/nfa.cc)

</comment><comment><USER117> I really like the source code of prosemirror:

[https://github.com/ProseMirror/](https://github.com/ProseMirror/)

It's not typical js, but very good none the less

</comment><comment><USER118> The open source code I know from web development has to be fixed with various hacks - PHP and the frontend javascript that goes with it. Therefore the code I know is not 'highest code quality'. If it was 'highest code quality' then I would not know the code.

Therefore the highest code quality is likely to be in projects where I do not have to go under the hood, e.g. the Chromium project where all contributors are vastly more educated and capable than myself.

</comment><comment><USER119> Libuv is one of my favourites [https://github.com/libuv/libuv](https://github.com/libuv/libuv)

</comment><comment><USER120> Good code bases that inspired larger projects: MINIX, KHTML

</comment><comment><USER121> with respect to the C++ Language: there was a book published in 1996. Large- Scale C++ Software Design by John Lakos. He's about to publish the second edition of the book while also expanding it's reach to span two volumes.

Anyhow, while we await the publication of that book, John has been working at bloomberg. some of the code written there has been published to github[1]. He's also done a five hour lecture series [2] available on safari-online (paid service) that cover the topics of his book, and introduce the open source bloomberg repo as an example of code written in that style.

I can't offer you a review as I've just found this all myself, but I'll be eagerly studying it along with some of the other items mentioned here.

[1] [https://github.com/bloomberg/bde](https://github.com/bloomberg/bde) [2][https://www.safaribooksonline.com/videos/large-scale-c- livel...](https://www.safaribooksonline.com/videos/large-scale-c-livelessons- workshop/9780134049731/)

</comment><comment><USER97> linux kernel, purely the reasoning being that it's probably one of the most used pieces of software out there, along those lines, probably the kernel libraries and user libraries like libstdc that are a part of it. i dont know how the linux kernel is tested, but i know that production testing of the kernel on different platforms, at large scale is probably the most used open source in the market.

</comment><comment><USER122> I would not judge things on aesthetic quality, but simply on results. In general code faces difficulties that grow exponentially with with time, size, and the number of contributors. Millions of lines code, thousands of contributors, decades of development and it's still at the top of its game? In spite of its complete lack of aesthetic appeal, that's the Linux kernel.

</comment><comment><USER123> High quality code and one of the best APIs i ever used: [https://github.com/requests/requests](https://github.com/requests/requests)

Best source code layout, architecture, maintainability: [https://github.com/rg3/youtube-dl](https://github.com/rg3/youtube-dl)

</comment><comment><USER124> As far as C++ code goes, the Lean Prover is really well maintained: [https://github.com/leanprover/lean](https://github.com/leanprover/lean)

I'd also say GHC is quite good.

And Pandoc as well.

I don't think I can compute enough variables to consider the "highest" though... so the aforementioned are only examples of what I think are good.

</comment><comment><USER125> The Linux kernel of course. In userland I have to say lib QT. I've used a lot of APIs and QT is always a pleasure to work with.

<comment><USER102> I'm a Linux fanboy myself but come on - we're talking about nearly 30 years' worth of commits from thousands (tens of thousands?) of developers.

The only thing I can say is that with this in mind it's actually a lot better than I'd expect - testament to Linus's iron fist, perhaps.

</comment></comment><comment><USER60> Redis. I have to say antirez not only is an amazing engineer but from the way the code is written, you can see he is a very clear thinker.

I hold Redis codebase as an example of what good C code should be. On the other hand opencv codebase as an example of what C could should not be. Opencv codebase is really inconsistent with quite a bit of unreadable spaghetti sauce.

</comment><comment><USER126> CVEdetails.com lists the number of (reported) vulnerabilities by year for software projects that have a CVE identifier.

Here's bitcoind: [https://www.cvedetails.com/product/22744/Bitcoin- Bitcoind.ht...](https://www.cvedetails.com/product/22744/Bitcoin- Bitcoind.html?vendor_id=12094)

</comment><comment><USER127> XMonad window manager written in Haskell.

<comment> iso-8859-1 What do you think about the GHC sources in comparison?

</comment></comment><comment><USER128> I am surprised no one mentioned SycallaDB([https://github.com/scylladb/scylla](https://github.com/scylladb/scylla)) . Redis and SycallaDB have often been pointed out as examples of good codebases to look at for C/C++ Devs.

</comment><comment><USER129> Gensim : [https://github.com/RaRe- Technologies/gensim](https://github.com/RaRe-Technologies/gensim)

[Can't speak for the 'highest' part of the qn, but Gensim upholds very high code quality standards]

</comment><comment><USER130> I like Spectrum for both their architecture and code quality. Node.js/JavaScript.

[https://github.com/withspectrum/spectrum](https://github.com/withspectrum/spectrum) Https://spectrum.chat

</comment><comment><USER131> Referred by thousands and available since 2004 without one single bug reported in the last decade: [http://users.telenet.be/AphexSoft/](http://users.telenet.be/AphexSoft/)

It is not yet on Github.

</comment><comment><USER132> Pretty sure PostgreSQL will have a place at the top quarter of this page.

</comment><comment><USER133> Pari:

[http://pari.math.u-bordeaux.fr/git/pari.git](http://pari.math.u-bordeaux.fr/git/pari.git)

I prefer the early versions, before it was softened up for the vulgo.

</comment><comment><USER134> GTKmm. GTK uses GObject to implement inheritance between C structs and it's easy to go wrong when extending. GTKmm wraps GTK in C++. It's a joy to use and is safer.

</comment><comment><USER135> I like the design philosophy behind BoringSSL:

[https://boringssl.googlesource.com/boringssl](https://boringssl.googlesource.com/boringssl)

If some portion of the library is overly complex, look into the use case and delete it wherever possible. It maintains a long-term bound on code complexity, which I quite like.

Edit: a nice explanation on the design philosophy here [https://www.imperialviolet.org/2015/10/17/boringssl.html](https://www.imperialviolet.org/2015/10/17/boringssl.html)

</comment><comment><USER136> I am very lucky that there are too many great open source libraries out there to label one with the "highest" quality.

</comment><comment><USER137> Any React and React Native suggestions?

</comment><comment><USER138> Spring Framework

1\. Elegant structure 2\. Strict code style 3\. Project size is not too large 4\. Have detailed documentation

</comment><comment><USER139> For Java I would say H2 SQL DB. It is small, compact, packed with features and good abstraction.

</comment><comment> tom-jh Nobody mentions Android. Any examples good quality code on Android?

</comment><comment><USER140> I guess my vote for Matt's Script Archive is going nowhere..

</comment><comment><USER141> I would suggest Laravel!

</comment><comment><USER142> Torch has the best code of DNN libraries I have seen so far.

</comment><comment><USER143> A lot of the KDE source code is well written and maintained.

<comment><USER144> Qt sources too (which has a lot of overlap in people and mindshare with KDE). Mostly.

</comment></comment><comment><USER145> zeromq. Both the code and documentation are very good.

</comment><comment><USER146> Postgresql, llvm, Python, sqlite are pretty up there.

</comment><comment><USER147> Debian is the best with its rigid QA procedures.

</comment><comment><USER148> My nomination would go to the chromium project.

</comment><comment><USER149> Any iOS swift/objc releated projects?

</comment><comment><USER150> Kubernetes is extremely well designed.

</comment><comment><USER151> Python (official cpython)

<comment><USER152> There's a nice introductory lecture series on CPython internals on Youtube that tries to cover how the interpreter works and how the python code maps to bytecode by going trough the cpython source: [https://www.youtube.com/watch?v=LhadeL7_EIU](https://www.youtube.com/watch?v=LhadeL7_EIU)

</comment></comment><comment><USER67> LibreOffice

</comment><comment><USER153> xv6

</comment><comment><USER154> Linux

</comment><comment><USER155> Lua. It's has everything a good C project should have: small size, simple build system, portability by using the simplest constructs and not ifdefs, a clear and well define scope that none dares trespassing.

<comment><USER156> You can see a mirror of Lua here! [https://github.com/lua/lua](https://github.com/lua/lua)

</comment></comment><comment><USER157> openbsd

</comment><comment><USER158> Start by defining quality.

<comment><USER126> Software quality: [https://en.wikipedia.org/wiki/Software_quality](https://en.wikipedia.org/wiki/Software_quality)

Software metric: [https://en.wikipedia.org/wiki/Software_metric](https://en.wikipedia.org/wiki/Software_metric)

''' Common software measurements include:

\- Balanced scorecard \- Bugs per line of code \- Code coverage \- Cohesion \- Comment density[1] \- Connascent software components \- Constructive Cost Model \- Coupling \- Cyclomatic complexity (McCabe's complexity) \- DSQI (design structure quality index) \- Function Points and Automated Function Points, an Object Management Group standard[2] \- Halstead Complexity \- Instruction path length \- Maintainability index \- Number of classes and interfaces[citation needed] \- Number of lines of code \- Number of lines of customer requirements[citation needed] \- Program execution time \- Program load time \- Program size (binary) \- Weighted Micro Function Points \- CISQ automated quality characteristics measures '''

Category:Software metrics [https://en.wikipedia.org/wiki/Category:Software_metrics](https://en.wikipedia.org/wiki/Category:Software_metrics)

</comment></comment><comment><USER159> well, if trolling is permitted, I would say that "Hello World" example has the most exquisite code.

in most cases "Hello World" is open-source, but I still don't know if can be named "project"

</comment><comment><USER160> It's funny to see nobody is even questioning the question.

What does it even hold as a value to be the project of the highest code quality in the world ? How can it exist as a consensus if we can't even agree on best practices ?

If it's for learning purposes, why even look for the ONE project with the HIGHEST quality ? Just go by any GOOD ENOUGH project.

I see this all the time: what's the best editor, the best color scheme, the best font, etc.

How about we just start saying: what's a good enough X for my purpose ?

<comment><USER161> Sometimes you need a recipe book, other times you want to lose yourself in a masterpiece.

</comment></comment><comment><USER76> Just wanted to mention some bias in successful open source projects: they are often structured as a number of similar plug-in pieces, like youtube-dl for different video publishers.

This is great for open source, because you can easily discover and navigate to the part you want, and change it. You might need to understand the plugin interface - or you might not. This flat architecture makes it easy for people to contribute, an important aspect of a successful open source project.

But it's not the ideal architecture for every project. In some cases, a cleverer, harder to understand approach is more elegant, shorter, more efficient, simpler.

Of course... one might argue that ease of understanding is more important than anything else.

<comment><USER162> the only thing more important than understanding is shipping on time. but how are you going to ship on time if you can't understand it?</comment></comment>


PDF-Viewer from the makers of PSPDFKIT - <AUTHOR> https://pdfviewer.io <comment><USER2> The apps are also listed on Product Hunt: [https://www.producthunt.com/tech/pdf- viewer](https://www.producthunt.com/tech/pdf-viewer)</comment>


Sony loses 12,700 credit card numbers - <AUTHOR> http://www.joystiq.com/2011/05/02/sony-hit-with-second-attack-loses-12-700-credit-card-nu/ <comment><USER2> _Sony has repeatedly stated that its PSN servers and SOE servers are not part of the same network, so it remains unclear just how these two attacks are tied together_

then Sony says:

 _"While the two systems are distinct and operated separately, given that they are both under the SONY umbrella, there is some degree of architecture that overlaps."_

This my friends is back-peddling 101. Also known as "Sony can't give a straight answer on whether their PSN and SOE networks are connected or not"

<comment><USER3> "Overlapping architecture" is not the same thing as "same network." They might just mean that the two networks are built out of the same brands of hardware and same versions of the same software, which gives them similar vulnerability profiles.

</comment></comment><comment><USER4> The scary part here is that this intrusion was only found because of a security review due to the PSN intrusion. If that hadn't of happened, who knows when/if they would have figured it out.

How often does this type of thing happen and no one has ANY idea?

<comment><USER5> Speaking as a "security person", it is really difficult to get anyone to care about security until it is too late. My estimate is that 999 or more of the Fortune 1000 are either owned, or just really lucky.

</comment></comment><comment><USER6> i never understand why we all so easily trust creditcards. i also do it.

a system that basically needs an attacker to just see'n'remember both sides of your card (that you need to keep with you and not is safe) in order be able pay with your money until the card gets disabled or expires.

i noticed in the US people use it to pay by phone, and shops tend to keep that data for convenient repeat purchases.

i need a card for payments online and visits outside europe (especially visits to the US). i'm glad that i have one for those occasions, but i cannot say i think it is a safe system -- it is also constantly under attack.

in the netherlands there's a payment system that most-if-not-all webshops are subscribing to. it redirect you from the shop to the internet banking app of your own bank, there you pay (with some 2-factor kind of authentication), after which you're redirected back. i cannot help feeling a lot safer. :)

<comment><USER7> In the US, at least, it's largely a matter of incentives.

By law, consumers are liable for at most $50 if their credit card info is used fraudulently by someone else.

Credit card companies validate transactions against statistical models in an attempt to head off anything suspicious. EDIT: Thanks for reminding me of this, nialo.

But often, it's the merchants who bear the cost of a fraudulent transaction. They have the least power to encourage more secure alternatives, because everyone already expects to be able to buy online with a credit card.

Card companies in the US do have something similar to the system you mention called 3-D Secure[1], but it hasn't gained wide traction. The interface is implemented so badly and inconsistently that it looks like a phishing scam. But more fundamentally, consumers have no incentive to use it, since it shifts _more_ liability onto them.

[1] <http://en.wikipedia.org/wiki/3-D_Secure>

<comment><USER8> This is now compulsory for all online transactions in India. Lot of people complain about this saying its one extra step, but for me I don't mind losing a bit of usability if it can add one extra safety net.

<comment><USER9> I'd be fine with it, but the US implementation was truly awful.

</comment></comment></comment></comment><comment><USER10> Oh, come on. It's not like Sony LOST them. I mean, they got copied, but Sony still has them, right?

<comment><USER11> I don't think anyone is particularly concerned about whether or not Sony still has access to them. "Lost" in this case means "no longer has control of them." They have a copy, but so does someone else.

<comment><USER12> The op comment was presumably a joke on the theme of theft vs. copyright infringement.

<comment><USER13> obviously. yes. it was _obviously_ a joke.

</comment></comment></comment></comment><comment><USER14> What's happened here is that Sony has discovered a previously undetected attack that occurred in April. So this second attack is not as new as one might think.

</comment><comment><USER15> > 12,700 non-US credit or debit card numbers and expiration dates [...] > apparently from "an outdated database from 2007"

Fortunately that means ~100% of those numbers are expired by now. Can expired numbers be used for anything evil?

<comment><USER16> Credit cards expire, but frequently the number remains the same. It's quite possible to just add four years to the expiration date and have a valid card. You still wouldn't have CCV, of course.

<comment><USER17> I was recently looking up some guidelines on storing credit card information, and according to section 3.2 of the official PCI guidelines ([https://www.pcisecuritystandards.org/documents/PCI%20SSC%20Q...](https://www.pcisecuritystandards.org/documents/PCI%20SSC%20Quick%20Reference%20Guide.pdf)), CCV is not allowed to be stored, along with PIN or Full Magnetic Stripe data. Hopefully, Sony didn't do that or they will also face hefty fines in addition to bad PR and lawsuits.

<comment><USER18> Lows and rules don't apply to mega-corps like Sony, Amazon, Ebay/PayPal, Google, Apple, etc. They all have no problem storing all this together with address, SSN and everything else.

<comment><USER19> You can't make allegations like that with zero supporting evidence. I mean you _can_... but you'll look silly.

</comment></comment></comment></comment></comment><comment><USER20> Sony has just never got the hang of digital. They used to have great radios, TVs, and decent audio equipment. You young'uns probably don't remember the Walkman but it was revolutionary. It was a highly portable cassette player, basically the ipod of its day. It's been downhill for Sony since then. To wit:

\- Minidisc \- Memory stick \- The 2005 audio CDs with bonus rootkit \- PSN breach \- SOE breach

<comment><USER21> There are a few negatives there for sure, but I think you're missing a couple of the ups too. The playstation for example was very successful, and is often credited as making gaming more popular and cool with 'normal' people.

They've messed up a few things, but they still make good consumer products. I purchased a SONY TV and Blu Ray a year or two ago and I'm very happy with it.

They're clearly not perfect, but to say everything they've done since the walkman has been a disaster isn't really fair.

<comment><USER22> Oh come now. Their products mostly suck. Their support sucks. The Playstation, they did okay on, only now it turns out that if you bought one, crooks have your personal information. They cut corners on consumer security.

Their laptops have tremendous numbers of mechanical failures. Their eReaders are slow, have glare, and have serious usability issues -- e.g. the page turn buttons are located in a spot where you can't comfortably press them. They bought Minolta, and ran it into the ground -- they've been promising a successor to the a700 for close to 5 years now without being able to ship. The lower-end cameras are innovative, but have serious, serious usability issues. The Minolta 5D was a wonderful camera. The early Sony successors copied and improved on it (a700 was the most usable camera ever made -- and the only one with a useful auto mode). The current ones made a new, broken interface. The support is gone -- warranty issues don't get fixed, and if you buy from Sony direct, heaven help you if you want a return.

Your TV and Blu Ray aren't bad, but a bit overpriced and slightly lower quality relative to the competition.

But that's not the point. 20 years ago, Sony was like Apple or Trader Joes. You couldn't go wrong buying from them. The quality was spectacular. Sony products didn't break. Today, you go wrong buying from them 95% of the time. 5% of their products are market-leading. They ship known defective products. It's a very different company.

In terms of bringing gaming to the masses, you're thinking of the Nintendo, first with the NES, and many years later with the Wii.

<comment><USER21> No I was definitely thinking of the PlayStation. The first playstation during the 90s was often found in nightclubs and places you would never previously have seen a console. They made it look cool to ordinary people.

The playstation 2 is still the most successful console with 150million units sold ( [http://en.wikipedia.org/wiki/List_of_best- selling_game_conso...](http://en.wikipedia.org/wiki/List_of_best- selling_game_consoles) ). I'd say to get figures like that you need to have had mainstream success.

I can't speak for all of their products, I only have a couple, but I've never had a reason to complain.

I'm not apologising for them, they really have screwed up with this security thing, but I think it's disingenuous to claim they've only made crap for the past 20 years when there are some very obvious exceptions.

<comment><USER22> You are correct -- there are a few exceptions, and the Playstation was definitely one. Therein lies the difference:

1960-1985: Sony is the gold standard for quality

1995-2010: Sony makes crap, with a few exceptions

Out of context, this may seem like a small difference, but the difference is huge. In the late 50s and early 60s, Sony did not ship a color TV for over a decade because they weren't convinced they could get the quality good enough. When they finally shipped in 1966, Trinitron had brighter pictures than the competition, and the TV sets never broke. The things were expensive, but they were built like a tank. Until the mid-90s or so, every Sony CRT had a full metal cage. You paid a premium, but you got quality.

Today, the majority of Sony products shipped are overpriced lemons. The Sony of yesteryear would never have shipped them.

<comment><USER23> I think you are going a bit overboard, sure Sony may not be the Sony they were in the 80s or 90s, but they do still make quality hardware.

The Playstation 3 is probably the most reliable console (hardware wise) out of the current generation consoles, I have not had any issues with mine and neither has anyone that I know personally, I can't say the same for the Xbox 360.

I bought a Sony Vaio Z 13" a few years ago and it has stood up to a lot without any issues, sure it may be very light and feel a bit "plasticy" but it is surprisingly tough.

Both of my brothers bought Sony LCD's a few years ago and they have not had any issues.

A friend of mine works in the geek squad as a home theater installer and by far the least reliable name brand TV's are made by Samsung, Sony is one of the more reliable brands.

</comment></comment></comment></comment></comment></comment><comment><USER24> Update, 9:03PM EST: "This is NOT a second attack; new information has been discovered as part of our ongoing investigation of the external intrusion in April."

</comment><comment><USER25> Can someone please remind me to only deal with Sony in cash from here on out?

If they 'lose' that it isn't my problem.

<comment><USER26> Time to pass around those redeemable voucher card Amazon affiliate links.

I think that's going to be the only way I'll by something from there.

</comment></comment><comment><USER26> Let this be a reminder to always check your monthly credit card statements.

</comment><comment><USER27> Just to clarify Sony was just clarifying the initial attack's results. This isn't a second attack.

</comment><comment><USER28> What's going on Sony?

<comment><USER29> They were forced to do an audit, and lo and behold, they'd been hacked and hadn't noticed. The same thing would no doubt be true of most large corporations.

<comment><USER30> I have a feeling there might be more, as they refused to participate in the US Senate hearing..

</comment></comment></comment><comment><USER31> Sort of off topic, but is there anyone else getting a lot of telemarketed automated calls recently --- any correlation with the sony attack?

</comment><comment><USER32> Credit card numbers were lost? Do they know that you can "take" data from computers without destroying it?

<comment><USER33> Semantics. We all know what they meant, and the colloquial usage of "lost" is valid here - (i.e., "lost" as in lost control. You can "lose control" of your car without the steering wheel disappearing on you).

<comment><USER34> Or the hard drives were actually stolen.</comment></comment></comment>


Not sure how effective the Google algorithm change was... - <AUTHOR> http://imgur.com/YdNth

<comment><USER2> lol, and I am pretty certain that answers.com link is 100% worthless!</comment>


Books Like 'Expert C Programming: Deep C Secrets' for React - <AUTHOR> 'Expert C Programming: Deep C Secrets' was probably the best programming book I've ever read because it goes really in depth on edge cases and unintuitive behaviour (as well as coupling them with anecdotes), are there any such books for React? <comment><USER2> I'm not sure the same type of book is possible for React.In C, edge cases are part of the formal specification. Beyond the edge cases is the formal concept of undefined behavior. In C, undefined behavior depends on implementation. React on the other hand does not have a formal specification. All of the edge cases arise from implementation. Also C is about forty years old. There's a long history of books about C -- it started with a book. React is much newer and changes rapidly.</comment>


Show HN: Tubalr.com, taking advantage of all the great music content on YouTube. - <AUTHOR>

www.tubalr.com - any feedback and suggestions are greatly appreciated.<p>code: https://github.com/cjstewart88/Tubalr <comment><USER2> This is really cool - do you think it would be possible (I'm not necessarily suggesting you implement it) to do some basic NLP to get artist/title from YouTube video names, meaning you could search for an artist and see what's available?

Clearly it wouldn't be perfect, but a reasonably consistent format seems to be <title - band>. It might be possible to use a combination of "links to" and video viewcounts to acts as indicators of authenticity? I mean, I've hardly done much research into this, but I know when I look for music on youtube I almost always use those metrics to determine which videos I'm going to listen to, as it were.

<comment><AUTHOR> I might could throw in suggestions as your typing your search, so if you started typing "Band of Horses" it would hit last.fm and pull back a handful of their song titles and allow you to quickly choose from those if you wish. Let me know if this is kind of what your talking about or if im way off. Thanks a lot for the feedback.

<comment><USER3> Since you're already using the last.fm api, might I suggest you add a simple scrobbling feature. If I were to use Tubalr often I would really want to be able to scrobble all the songs I've listened to through it.

<comment><AUTHOR> I'm thinking about adding a set of features that allow you to register, login, and favorite songs. Maybe when you favorite songs they can also be "scrobbled" if your account is connected with last.fm.

</comment></comment></comment></comment><comment><USER4> Songza.fm allowed you to listen to music from YouTube in 2007, although lacked the Pandora-like features. In 2010, YouTube blocked their use of the API.

Interestingly, they pivoted into a 'better Pandora' where they license music, allow playing similar songs, but also let users hand-pick songs for playlists (that for licensing reasons can only be played by other people).

[http://evolver.fm/2011/03/30/songza-attempts-to-reinvent- net...](http://evolver.fm/2011/03/30/songza-attempts-to-reinvent-net-radio- despite-heavy-competition/)

</comment><comment><USER5> Very cool, good job. Clickable <http://www.tubalr.com>

</comment><comment><USER6> Very nice, a good idea cleanly implemented. One suggestion would be to query amazon recommendations for similar artists to help work out what to play. This is only because then you could also possibly allow people to buy or add things to their wish list from your site. If you were thinking about revenue that is.

Good work.

<comment><AUTHOR> Good idea, I'll look into that, I've been thinking about putting a link to either Amazon or iTunes for those interested in purchasing music. Thanks for the feedback and I'm glad ya like it!

</comment></comment><comment><USER7> It's clean and simple and maybe useful but the only problem I see is it replaying the same popular songs over and over. I put in Mumford and Sons and Little Lion Man was in the playlist several times over just because it's one of their most popular songs and there are variations and what not. If you could put in some kind of function that doesn't show videos more than once or twice that'd be handy.

<comment><AUTHOR> I agree this can be a bit annoying, some artists/bands have better results than others. I'll look into sorting out videos that appear as duplicates and replacing them with more videos. Thanks for the feedback.

<comment><USER7> No problem. Do you have any way to weed out covers and other possibilities? I haven't seen any come up but just curious how you implemented it or if it is even a problem at all.

<comment><AUTHOR> I'll look into this, its a similar feature another user wants to filter our the words "and" and "with". I've noticed its a problem if you search for something like "Nine Inch Nails Acoustic", a lot of junk shows up that im not interested in. Thanks for the suggestion.

</comment></comment></comment></comment><comment><USER8> Wow, this is wonderful. I have always been shocked at how commonly people Youtube for music and how much better that system could be. You've chosen a great problem to solve.

Feedback:

• I love the Similar button.

• Perhaps the links to the videos could be outline or something, right now it's hard to distinguish them from eachother because it's a mass of text. I mean of course the design of this is very minimalistic and the main focus here is the function, but for now that would be my main design criticism.

• You should filter for the word "with" preceding an artist's name in the video title. Also perhaps "and", or any sort of list of names after an occurrence of "with," because I got one video for the query "Avi Buffalo" that was "Look Out for My Love Jeff Tweedy _with_ Avi Buffalo, Solid sound August 15 2010," which is of course not Avi Buffalo at all.

EDIT: Also, the ability to search while still keeping the current song playing at the top would be nice.

<comment><AUTHOR> I agree with the playlist being a litte hard to read, I'll do some research and figure out if theres a better way to show the playlist.

As far as filtering out videos with the keywords "with" and "and", I'll have to do some testing with this and see if the results are better. My concern is what happens when a user searches for something like "Coheed and Cambria", tons of the videos would be filtered out. I guess I could only filter out "with" and "and" if its not in the original search.

Can you elaborate on how you think searching while listening should work?

Thanks a lot for taking the time to give me some feedback.

<comment><USER8> Sorry, I just saw this. Searching while listening would basically work how you have now but if there's already a video playing the system wouldn't stop it and change it to the first result for the new search, until the user clicks on a link in the results.

</comment></comment></comment><comment><USER9> Noticed the footer overlaps the playlist: <http://i.imgur.com/xjUxo.png>

<comment><AUTHOR> Thanks for the tip, what resolution are you running?

<comment><USER9> 1280 x 800

<comment><AUTHOR> Thanks, I'll look into this.

</comment></comment></comment></comment><comment><USER10> This is awesome! I am trying to embed tubalr within a browser-based desktop environment and have a pair of (hopefully) quick requests:

1\. I'd like to be able to pass in something via the URL that allows me to set the wmode of the video to be opaque or transparent. This is to prevent z-index conflicts when I have two separate tubalr iframes that overlap each other when I drag those iframes around.

2\. For the initial video that tubalr loads, I'd like to be able to pass in something via the URL that controls whether the first video autoplays or not. This is to prevent multiple videos from playing at the same time when I have multiple tubalr iframes on a page.

Example Interface: <http://beta.mindcast.com/ui/4kug9iozh54y>

<comment><AUTHOR> Thanks for the feedback and interest! The YouTube player is pretty finicky with z-indexing, so I'll need to play around with what your wanting and see how I could pull it off. As far as setting an option for auto play, that should be fairly easy to throw in. If you'd like to talk more about some features your interested in seeing feel free to contact me via cjstewart AT gmail DOT com

<comment><USER10> Oh, the z-indexing worked for me with the following update to the parameters of your swfobject:

var params = { allowScriptAccess: "always", bgcolor: "#cccccc", allowFullScreen: true, wmode: "opaque" };

<comment><AUTHOR> I didnt have a way to test it besides just seeing if it didnt brake anything, and it didnt, so its pushed up to prod. Let me know if this fixes the issue for you. I also looked up the param and it does in fact seem like the solution you where looking for :) Thanks for experimenting with tubalr!

<comment><USER10> Thanks for putting that in! It's working great for me!

</comment></comment></comment></comment></comment><comment><USER11> This is pretty cool! I use YouTube for music all the time -- I'm not quite sure. I keep finding music apps that aren't quite right, and don't have what I want to hear (or not set up how I want to use them), and I end up back at YouTube, which indeed sucks for this.

No useful advice at the moment, beyond a vague suggestion to revisit the domain name choice (if somehow you're not wedded to this one by now, and you see many other folks with reactions like mine). I'm still not quite sure of the intended reading, but first I saw a slightly jumbled "tubgirl"(!), then I saw "two-baller"; now I'm stuck with a reference to "tubal" (as in tubal ligation? ...) with a flickr-style ending. Maybe just put an "about" link somewhere that gives a hint?

<comment><AUTHOR> I'm surprised your the first one to bring up the name, I've had friends question me about it... but no worries, I have a reasoning/meaning behind it.

I originally liked the word Tubular(used mostly in the 80's, or by people mocking the 80's to describe something 'awesome' or 'excellent' ie, good.); however, that domain was taken. Then I started thinking about variations of the word, and went with Tubalr. I went with this version of the word because it has the word Tuba(a musical instrument) in it and in my head sounded cool :P. So with that in mind, I thought it was cool to have a name that came from a word meaning "awesome", "excellent", or "good" AND have a musical instrument in the name.

Hope that clears up the name a tad bit. Oh, I pronounce the word something like: Tube-u-ler

<comment><USER12> "Tube" in French (from France) also means "a hit" on the radio, a top-40 song. Plus, Tubalr has great Michael Oldfield resonance (Tubular Bells was the first record I ever bought). Ace name.

</comment></comment></comment><comment><USER13> Great! Pandora(-ish) for the rest of us.

Something you might want to address : I've searched for The Prodigy, and I got "Amanda Bynes' 2010 Maxim Cover Shoot". I'm not sure where that came from!

<comment><AUTHOR> Thanks! Ya, sometimes unrelated videos will slip in, I'm always thinking of ways I can mitigate this. I'm sure you didnt mind the Cover Shoot video though ;)

</comment></comment><comment><USER14> AOL Radio used to offer single artist radio stations. Now that AOL Radio is powered by Slacker, they dropped this feature. As far as I know no other internet radio service offers this. Now your tubalr does (at least, in a sense). Which makes it stand out, at least to me. Thanks for the nice site!

EDIT: I see if you reload the site and pick the same artist again, the same videos come up in the same order. Some randomization would go a long ways.

<comment><AUTHOR> Just pushed this to prod about an hour ago, thanks for the suggestion!

<comment><USER14> Awesome! Looks like I've got a new radio station :)

</comment></comment></comment><comment><USER15> Loving the similiar feature. Already found three bands that I had never heard of before that have tunes that are right up my alley. Very nice work.

One thing and I dont' know if it's possible, but is there a way to have it where if the video is flagged as no longer there, it's not returned in the results? I get about a 25% to 50% rate where the video is listed, but doesn't play.

<comment><AUTHOR> Awesome, glad you're enjoying it! As far as filtering out the videos that dont allow embedment, I should really look into that and eliminate those out of the playlist. Thanks!

</comment></comment><comment><USER12> Cool. My first impression is that this is also a good tool to get news on artists - because the first band I looked up was the Stone Roses; and I was gobsmacked (as the English say) that the first hit was of their press conference announcing their reunion. Big news to me, and way more important than rewatching an old video!

<comment><AUTHOR> Thats pretty sweet, for the hell of it I've searched stupid shit such as "people falling" or "lol". Glad ya like it!

</comment></comment><comment><USER16> Thanks!! I have been waiting for this. There's lots of stuff on Youtube that isn't anywhere else. Suggestions: Let me search for Youtube playlists. Somehow, songs could be connected in a network of similar songs by mapping the playlists. Also, let me create link for the current playlist/song.

<comment><AUTHOR> Hey Gee, I plan on adding an easy way to get the url of the current playlist so you can share with friends. The URL's currently exist, just no way to easily copy them for sharing.

Example URLS: <http://www.tubalr.com/just/Muse> OR <http://www.tubalr.com/similar/Jack+Johnson>

</comment></comment><comment><USER4> Unfortunately, it may be against YouTube's Terms of Service since it strips the video from the content. [http://evolver.fm/2011/03/25/how-youtube-radio- disappeared-f...](http://evolver.fm/2011/03/25/how-youtube-radio-disappeared- from-the-itunes-app-store/)

<comment><AUTHOR> It appears that the app your talking about only played the audio from the video, stripping the actual video out and any ads that might have shown up. They also used YouTube in their name and where making money off the app. I'm not sure what Terms of Service I've violated, I'll have to take a closer look. Thanks for the heads up.

<comment><USER4> I think you're okay; I posted that a little hastily since it was linked to from the songza article that I posted elsewhere, but as you noted, your app doesn't have those same problems.

The one thing that I am confused about is why the old songza disappeared. If the only problem was that they weren't showing videos, they easily could have started doing so, and I remember that at least for awhile they were doing that.

Wikipedia says "However, in late January 2010 Songza had to put their music streaming service on hold due to problems with YouTube's API (which is what the site uses to play back songs), YouTube blocking the site from using its API, presumably because YouTube could be sued for supporting a free music service without adverts[citation needed]." It looks like Songza had ads, so maybe that was the issue. Regardless, you may find reading up about Songza interesting; TechCrunch reports they were acquired for high six figures to low seven figures.

</comment></comment></comment><comment><USER17> Pretty cool and simple. How do you get the "similiar Artist" feature?

Also, that is a pretty great font for your logo. For anyone else interested he uses "Pacifico": <http://www.fontsquirrel.com/fonts/pacifico>

<comment><AUTHOR> Thanks, glad ya like it. As far as how the similar search works, heres how I do it. First I hit last.fm and grab the top 20 similar artist, then I simply hit YouTube's API and grab the top video for each artist and throw all the videos into one playlist.

</comment></comment><comment><USER18> Can you make it so that I can send my friends a URL of the Artist i have chosen on Tubalr

<comment><AUTHOR> Thats on my list of things to do; however, for now you can do this:

<http://www.tubalr.com/just/Band+of+Horses> <http://www.tubalr.com/similar/Fleet+Foxes>

Also, a simple API I threw together: <http://www.tubalr.com/just/Band+of+Horses.json> <http://www.tubalr.com/similar/Fleet+Foxes.json>

Thanks for the feedback!

<comment><USER19> also, get a favicon. Nice work

<comment><AUTHOR> This is done, thanks for reminding me to do this!

</comment></comment></comment></comment><comment><USER20> very nice, simple and sleek design. I really like it.

the only downside i see which i noticed other people mentioning as well is when i search for let's say "Coldplay" the first 2-3 songs are the same which would require me to play next. it's a lot simpler than the Youtube playlist so once you add the playlist functionality and some algorithm to get rid of duplicates it'll be a very useful service.

How are you planning to monetize this? or are you doing this just as a hobby?

<comment><AUTHOR> Glad you like it. After having duplicates brought up several times over the weekend I think I'm going to make that my next task to tackle.

As far as monetizing, well... I have no clue. I started this app for practice and so I'd have something to show when I went for my first job interview, having just graduated. I messed around with adding a "Buy This Song" link that would send you to the Amazon MP3; however, I removed it because it was just more clutter I wasn't interested in, specially seeing it wasnt getting used as I thought it would. I'm open for any suggestions if ya have any :)

<comment><USER20> for starters i would keep it ad free. but once it picks up momentum and you are getting a lot of visitors, i would maybe incorporate a video advertisement in between songs. so maybe after 5 songs it would display a video/audio advertisement of some sort etc.

<comment><AUTHOR> I think I want to stay away from interrupting listening. I know there free so complaining is kind of pointless and lame, but I cant stand it in other music services. I might look into a service like <http://carbonads.net/>.

</comment></comment></comment></comment><comment><USER21> Chrome 14, 10.7 OS X. Was only able to get the first video to play when I went to ONLY. I watched a video in entirety. Clicking a video title or next would not switch videos.

</comment><comment><USER22> Where are the javascript and css files in the repo? I can make a good and quick pull request for you if they get included / I find them.

<comment><AUTHOR> public/javascripts and public/stylesheets :)

</comment></comment><comment><USER23> Needs something that signals it's processing when I enter a value, I figured it was broken as it takes ~5 seconds to respond.

<comment><AUTHOR> Just finished this about an hour ago and pushed it to prod, thanks again for the suggestion.

</comment></comment><comment><USER24> I did something similar, but, well, different ;) congrats on shipping, mine got stuck in the 'almost finished' stage.

<comment><AUTHOR> Thanks man, I find that to be one of the most difficult things when playing with a new idea, actually sticking with it until its "finished".

</comment></comment><comment><USER22> This is absolutely perfect for me. Thanks!

</comment><comment><USER25> I love how mature these api mashups are becoming. Formal deployment process and maintainable code. Well done!

</comment><comment><USER26> Nice! Mapping the right and left arrow keys to prev/next would be a small but very useful addition.

<comment><AUTHOR> Another task on my todo list! Currently the only keyboard control is 'space' to pause :)

</comment></comment><comment><USER27> Love it! The simplicity is the winning factor. I can see that I'll be using it a lot!

</comment><comment><USER28> this rocks, I wanted to make something like this in the past but the idea died I hope you get a lot of users. What I would do is add an auto complete like the one on youtube.com just to make things a lot simpler Good luck

<comment><AUTHOR> Thanks man. I'm definitely wanting to add some type of suggestions as you type or auto-completing.

</comment></comment><comment><USER29> I love using this when I'm at work and have told many co-workers about it

<comment><AUTHOR> Thanks a lot man!

</comment></comment><comment><USER30> another similar site is <http://fermademuzica.ro/> (.ro only) that has playlist, thumbnails, similar artists, top songs

</comment><comment><USER31> I like it, maybe show the thumbnails for the next videos !

</comment><comment><USER32> Really neat! Can you add a "next" button though?

</comment><comment><USER33> Very nice indeed. Simple, clean and enjoyable :)

</comment><comment><USER34> Nice and clutter free.

</comment><comment><USER35> Nice work, I dig it

</comment><comment><USER36> Freaking awesome.</comment>