Ask HN: Brag about open-source projects you're proud of - <AUTHOR> Do you have a github project with hundreds of commits, meticulous documentation, but only a handful of stars? Feel like you can't get the marketing sauce right?
I've talked with many developers who have been maintaining passion projects for years without any decent recognition of their efforts.
I'd like to do a little to change that!  Please list the projects you are most proud of along with their project URLs. Go ahead and say why it's awesome.
I want to give a way (right in this comment thread) for people to self-promote those things that get overlooked.
Thanks. <comment><USER2> WebODF.

[http://webodf.org/](http://webodf.org/) [https://github.com/kogmbh/WebODF](https://github.com/kogmbh/WebODF) [https://adityabhatt.wordpress.com/2013/12/16/bringing- opendo...](https://adityabhatt.wordpress.com/2013/12/16/bringing-opendocument- to-the-web/)

A js library that renders OpenDocument Format docs in the browser, and lets you edit them collaboratively in realtime - with lovingly, meticulously crafted OT.

We worked on this with 2 years of active development - it is HARD to build a full richtext editing engine from scratch! - but it has recently been suffering from a lack of enough funding to keep the work going. I no longer get paid to work on this, so now there is only one person working on it full- time.

It deserves funding and support. As far as I know there isn't any other project that comes this close to building a full blown FOSS Google Docs text editor replacement.

:)

<comment><USER3> Darn, I actually went to the site looking for a 'donate' button, but it looks like it's commercially backed. I definitely want something like this to exist.

<comment><USER2> The project can take donations and we did work supported by grants from the NLNet Foundation ([http://nlnet.nl/](http://nlnet.nl/)) for a while. It is commercially controlled in the sense that KO GmbH has a CLA that contributors sign. But the project itself is AGPL (with pretty standard dual-licensing).

Thanks for the kind words! :)

</comment></comment></comment><comment><USER4> Django Baker

Adds a management command that generates views, forms, urls, admin, and templates based off the contents of models.py.

It's a bit like Rails scaffolding, but less magical. For each view it creates, for example, it will include stubbed out versions of almost all the methods and attributes you can override, in the order that they get called. The most "magical" part are the admin files that get generated, as they make use of a mixin I wrote that makes (hopefully) intelligent choices for list_display, list_filter, search_fields and automatically links to the related objects for each ForeignKey/OneToOneField. All the default choices are easily overridable.

[https://github.com/krisfields/django- baker](https://github.com/krisfields/django-baker)

It's not a big project but it's my first open source contribution so I'm proud of it nonetheless.

</comment><comment><USER5> Auto-Sort Bookmarks (Firefox add-on): [https://github.com/antoyo/auto-sort- bookmarks](https://github.com/antoyo/auto-sort-bookmarks) It provides a way to sort all bookmarks and automatically sort bookmarks. By the way, I planned to rewrite it in OCaml. I started the binding of the add-on SDK (here it is: [https://github.com/antoyo/oc-addon-sdk](https://github.com/antoyo/oc-addon- sdk)).

Vim Licenses (vim plugin): [https://github.com/antoyo/vim- licenses](https://github.com/antoyo/vim-licenses) Vim Plugin that provides commands to add licenses at the top of the buffer (very useful when working on open-source projects).

</comment><comment><USER6> I've spent some good time on: [https://github.com/appnexus/sicksync](https://github.com/appnexus/sicksync)

It's a one-way syncer utility in Node, and backed by a CLI. I Was tired of Ruby file watchers running rsync and waiting the seconds it took for file synchronization. So I wrote this which uses WebSockets to persist a connection and send deltas much quicker. Ideal for small, iterative changes (front-end).

Is it secure? No. Does it work for everything? Probably not. But it get's me waaay more productive than I was.

</comment><comment><USER7> [http://introtopython.org](http://introtopython.org)

[http://github.com/ehmatthes/intro_programming](http://github.com/ehmatthes/intro_programming)

It got some stars when I first introduced it about a year ago, but I'm mentioning it because I've just picked up development on the project again. It's a site to help people teach and learn Python. I wanted to make an easy way for experienced Python devs to contribute to a site that helps people learn Python.

Key features:

\- If you can use IPython Notebook, you can contribute to the project. Every page is an IPython Notebook that gets converted to html. To edit a page, check out the project and edit the notebook.

\- If you want to add a tutorial - for example, a tutorial about how to use PyGame, or how to use a specific data visualization tool, or any specific Python library - just make a new notebook, write your tutorial using IPython Notebook, and run intro_programming/scripts/build_html_pages.sh.

I just pushed a branch that updates the infrastructure to IPython 3.0. I'm a day or two away from updating the first project on the site, which shows how to plot recent earthquakes on a world map - that project has been well received for the last year. ([http://introtopython.org/visualization_earthquakes.html](http://introtopython.org/visualization_earthquakes.html))

If you're interested in helping out, get in touch or open an issue.

</comment><comment><USER8> It's not code, but if you're designing a website or app, I created some free simple device templates (phone, tablet, web browser) to help you sketch your ideas on paper.

They're CC licenced and you can create your own print templates:

[http://www.interfacesketch.com/](http://www.interfacesketch.com/)

<comment><AUTHOR> What a clever idea. Thanks!

</comment></comment><comment><USER9> My most recent is "React Resolver":

> [https://github.com/ericclemmons/react- > resolver](https://github.com/ericclemmons/react-resolver)

When React came out, I was disappointed that server-side rendering was pretty much impossible unless you knew _all_ of the data requirements for the entire render tree & loaded them up front.

This project has just underwent a rewrite for React v0.13 that I'm pretty proud of, since it's ES6 and packaged as ES5 via Babel.

It's been fantastic in my personal & work projects, and has made it possible to rebuild a major application that was in PHP entirely in Node w/ progressive enhancement.

</comment><comment><USER10> Django SQL Explorer

[https://github.com/epantry/django-sql- explorer](https://github.com/epantry/django-sql-explorer)

Engineers or analysts write SQL queries, and share them with anyone in the business who needs the data to make decisions. Through over a year of heavy, daily real-world use, I've added dozens of little usability features that make it (for me at least) really pleasant to use. It's still a pretty under-the- radar Django app, but I literally can't imagine life without at, at any business I've ever worked at.

Explorer can also expose select queries as read-only pages to specific users and we use this feature to keep investors and partners up to date on key metrics and financials which saves a lot of time and ad-hoc reporting. Just go to a URL and BAM! Real time data, downloadable as CSV.

I've also documented the version and license of every dependency to make it as easy as possible for businesses to go ahead and use it. And finally, it's extensively tested via automation, and our own internal deployment which is always running off the tip of master. We dogfood every commit quite heavily.

<comment><USER11> This looks awesome! Good work.

I'm going to try it out with my next Django project.

</comment></comment><comment><USER12> My "Patterns of Resemblance Arithmetical Library (PORAL)" is, in a formal sense, one of the most sophisticated pieces of software ever written: the ordinals it can perform arithmetic upon are so large, they require nontrivial fragments of set theory just to prove they're really ordinals. Some of the algorithms implemented in this library were recently printed in "Archive for Mathematical Logic", a hardcore logic journal.

Github: [https://github.com/semitrivial/poral](https://github.com/semitrivial/poral)

</comment><comment><USER13> I have three that I'd love to give more exposure to:

Hawkeye - [https://github.com/ipartola/hawkeye](https://github.com/ipartola/hawkeye). This is a webcam streaming server for the Raspberry Pi + cheap webcams. I wanted a simple, extensible webcam monitoring system for the nursery, so I built this. You can use a cheap USB webcam that supports MJPEG video, and Hawkeye has a built-in HTTP/HTTPS server for streaming the video to desktop or mobile browsers. The included "client" is just a basic HTML page that lets you view multiple streams. The project is written in what I consider fairly readable C. The whole thing can be easily built into a Debian package so maintenance is pretty simple, and init scripts just work.

groper - [https://github.com/ipartola/groper](https://github.com/ipartola/groper). groper is a configuration library that Python's stdlib is really missing. Python comes with argparse for command line arguments, and the config parser module for parsing config files. It is your job to make the two work together. groper takes all that pain away from you. You simply define what stuff is configurable and what names it should use, and it will take care of order of precedence, etc. Works with Python 2 & 3, and will even generate sample configs for you based on your defaults. A former employer of mine uses it extensively, and so do a few other projects.

LogHog - [https://github.com/activefrequency/loghogd](https://github.com/activefrequency/loghogd). My current employer, Active Frequency, LLC ([https://www.activefrequency.com/](https://www.activefrequency.com/)) sponsored my work on this. LogHog is a logging facility similar to syslog, but not compatible with it. Instead it supports a few advanced features (encryption, HMAC, built-in file rotation and compression) and basically Just Works. If you have ever tried to set up syslog logging with Python and got frustrated, give this a go. Active Frequency uses this for some of our projects, and it works really well for the most part (except that TLS, which works but configuration still has some sharp corners).

</comment><comment><USER14> Gumbo HTML parser:

[https://github.com/google/gumbo-parser](https://github.com/google/gumbo- parser)

It's one of the most conformant (if not _the_ most conformant - 0.10.0 passes all html5lib-trunk tests) standalone HTML parsing libraries out there. It has third-party bindings in nearly a dozen different languages. The API is simple, the code is robust and well-tested, and being written in C, it's often a fair bit faster than alternatives.

<comment><USER15> Looks interesting. Does it parse html in chunks? (I am actually looking for html5 parsing library that does it in chunks in C).

<comment><USER14> No, it reads in a whole string at once and then parses it as a single document. It's actually pretty hard to parse HTML in chunks, because the spec allows for text that comes later in the document to alter the parse tree of nodes produced earlier (see, for example, foster-parenting or the adoption agency algorithm). You could take a look at Hubbub as a callback-based HTML5 parser, but the way that works is to take a callback interface where you need to implement 18 or so different functions.

[http://www.netsurf-browser.org/projects/hubbub/](http://www.netsurf- browser.org/projects/hubbub/)

</comment></comment></comment><comment><USER16> [https://github.com/qq99/muvee](https://github.com/qq99/muvee) \- μv, a mix of concepts like Plex, Netflix, Popcorn Time for your LAN, with Hue light support. I'm working on this one regularly and use it frequently at home

[https://echoplex.us/](https://echoplex.us/) \- anonymous chat, code, draw, WebRTC calls, with PGP support. Much less maintained nowadays

</comment><comment><USER17> [https://github.com/LeadDyno/intercooler- js](https://github.com/LeadDyno/intercooler-js) \- Giving you 95% of the functionality of a client-side MVC framework at 5% of the complexity.

Main site at [http://intercoolerjs.org](http://intercoolerjs.org)

I'm particularly proud of how well history-aware AJAX is working out: you just add an ic-push-url="true" attribute to your element, and, blam, AJAX is integrated with your apps history. See:

[http://intercoolerjs.org/examples/history.html](http://intercoolerjs.org/examples/history.html)

<comment><AUTHOR> ... that's a lot of work. Thanks!

</comment></comment><comment><USER18> * Deeplearning4j - distributed DL for the JVM [https://github.com/deeplearning4j/deeplearning4j](https://github.com/deeplearning4j/deeplearning4j)

* ND4J - Scientific computing for the JVM [https://github.com/deeplearning4j/nd4j](https://github.com/deeplearning4j/nd4j)

* Vectorization lib for Machine Learning Tools [https://github.com/deeplearning4j/Canova](https://github.com/deeplearning4j/Canova)

</comment><comment><USER19> [http://zealdocs.org/](http://zealdocs.org/) \- 2 years old dev documentation browser. Maybe not exactly overlooked with 2400 GitHub stars, but never hit HN frontpage, and 0.1.1 was recently released. :D

<comment><USER20> I really love Zeal, but I wish the documentation files weren't being hosted from Dash's servers. If Zeal were available on OSX I'd use it in an instant.

<comment><USER19> Thanks! You can compile it for OSX yourself with some effort, but it's not going to be supported any time soon due to agreement with Dash's author, and is ugly being cross-platform as opposed to native like Dash.

</comment></comment></comment><comment><USER21> [https://github.com/endeav0r/hsvm](https://github.com/endeav0r/hsvm) \- 16-bit virtual machine with a bunch of reversing and exploitation challenges.

[https://github.com/endeav0r/rdis](https://github.com/endeav0r/rdis) \- Visual reverse-engineering tool for Linux with custom graph layout stuff.

<comment><AUTHOR> That documentation is so awesome.

You may think about doing a version with [https://github.com/kristopolous/BOOTSTRA.386](https://github.com/kristopolous/BOOTSTRA.386) ...

</comment></comment><comment><USER22> I don't know why, but a perceptual hasher I wrote for PHP is apparently moderately popular (at least for me): [https://github.com/kennethrapp/phasher](https://github.com/kennethrapp/phasher)

Chances are I won't be updating it anytime soon though, because I have so many other projects, so feel free to fork it and/or drop a pr, which i'll get around to merging eventually.

I'm personally kind of proud of another project ([https://github.com/kennethrapp/embedbug](https://github.com/kennethrapp/embedbug)) which I meant originally to be a self-hosted replacement for site profile services like embed.ly, but which has kind of grown into a general purpose xpath based web crawler. I've been using it in various toy forum and news aggregator projects and it seems to work pretty well, although of course it's only one of countless crawlers out there.

</comment><comment><USER23> I wouldn't call it overlooked and it's probably not the typical open source project, but I'm quite proud of this, so here is it:

[https://acoustid.org/](https://acoustid.org/) [https://bitbucket.org/acoustid](https://bitbucket.org/acoustid)

There has been a few attempts at open source audio fingerprinting service before and after AcoustID, but none of them survived for long. It's been 5 years since I started working on this. I'm particularly proud of the project, because I have done it the way I think software should be done and it worked wonderfully. I spend a lot of time researching, then ran some experiments, set myself some goals of what is practical to do and what exact use cases I want to support, designed and implemented it and then I was able to run it without any scaling problems for years.

<comment><USER24> Perhaps more people would find it if you moved it to Github. It doesn't take much time...

<comment><USER23> It was originally on GitHub and I moved it to Bitbucket after GitHub decided they do not want to host release files.

</comment></comment></comment><comment><USER25> [https://github.com/web2project/web2project](https://github.com/web2project/web2project)

I've been the lead for Web2project for the years since we forked from dotproject. In the simplest terms, we're a project management system but unlike something like Basecamp, we handle dependencies, logging time on tasks, accounting for projects costs and a ton of other things.

At present, we have a small community, but we have a few thousand installs ranging tiny two-person shops who have a ton of things going to at least one US Air Force Base.

The biggest challenge since our fork was dealing with the old code and continuing to support older versions without leaving people without a path forward. I put a ton of time into making sure the upgrade/update process works smoothly and no data is lost.

</comment><comment><USER26> An underappreciated project of mine is [langcodes], a Python package for looking up, comparing, and doing the right thing with IANA language codes. It's not a full-blown toolkit for localization, it just does this one thing well.

A project that finally got some appreciation after a couple of years is [python-ftfy], which Fixes Text For You. It repairs mojibake, and generally takes in bad Unicode and outputs good Unicode.

[langcodes]: [https://github.com/LuminosoInsight/langcodes](https://github.com/LuminosoInsight/langcodes)

[python-ftfy]: [https://github.com/LuminosoInsight/python- ftfy](https://github.com/LuminosoInsight/python-ftfy)

</comment><comment><USER27> Not mine, but I've always thought how this is not mainstream...

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

[http://www.duplicati.com/](http://www.duplicati.com/)

Duplicati is a backup client (with GUI) that securely stores encrypted, incremental, compressed backups on cloud storage services and remote file servers. It works with Amazon S3, Windows Live SkyDrive, Google Drive, Rackspace Cloud Files or WebDAV, SSH, FTP (and many more). Built-in AES-256 encryption and backups can be signed using GNU Privacy Guard.

PS: This should be a monthly thread like "who's hiring"!

<comment><USER28> The original project that Duplicati was forked from, Duplicity, is very well known.

Other than GUI and Windows (VSS) support, I couldn't easily find how Duplicati diffentiated itself... might be nice to have a "Duplicati vs Duplicity" page?

</comment></comment><comment><USER29> I have quite a lot of open source projects, mostly just little utilities or interesting experiments. [https://github.com/martindevans?tab=repositories](https://github.com/martindevans?tab=repositories)

The one I'm most proud of is probably MumbleSharp ([https://github.com/martindevans/MumbleSharp](https://github.com/martindevans/MumbleSharp)) which is a complete implementation of the mumble protocol in C#. It's actually getting fairly close to complete, it can handle all functions except sending voice.

</comment><comment><USER30> [https://github.com/MachinePublishers/jBrowserDriver](https://github.com/MachinePublishers/jBrowserDriver) is a Selenium WebDriver that runs headless, is pure Java, and runs fine on a standard JVM. And most people use these web drivers because they need to parse AJAX sites, yet most web drivers have terrible support for it. Mine does a pretty good job of knowing when a page is loaded, including its asynchronous requests, whether from the page load or subsequent clicks/actions.

There are some missing features and bugs still but it's working pretty well.

</comment><comment><USER31> Snebu ( [http://www.snebu.com](http://www.snebu.com) and [https://github.com/derekp7/snebu](https://github.com/derekp7/snebu) ) is a Linux backup system that works kind of like rsync snapshot backups (i.e., similar to rsnapshot). Except it stores backup sets meta data in an sqlite database, and the files are stored as lzo compressed objects. Other than the standard features such as backup retention schedules, it has a number of small features that I haven't seen in a lot of similar backup utilities:

* Path rewriting (grafting) -- this lets you mount an LVM snapshot somewhere, and the backed up copy can be stored referencing the original path (i.e., if you backup a snapshot of /srv/mydbfiles mounted on /mnt/snapshots/mydbfiles, you can tell it to store it on the backup server as if it was backed up from /srv/mydbfiles). This also works the other way for restoring files.

* Safe expiring of old backups -- Let say you haven't backed up a particular host for a number of months (i.e., it has been decommissioned). When you tell the system to expire all backup older than 6 months, it will by default keep the 3 most recent backups [this number is tunable on the command line].

* Multiple user / granular permission support [ in the development branch, should make it in the next release ] -- You can give a given user ID the ability to backup but not restore, or backup and restore but not purge old backups, etc. That way if a host is compromised, you can ensure that an attacker can't delete backups from that compromised host.

* If used in client/server mode, you can back up a client from the server without installing anything other than an SSH key (it just calls GNU find/tar on the client).

Things missing that are currently being coded up:

* Client side encryption

* Multiple backend support (to support tape or cloud replication)

* Local shadow copy -- lets you back up a laptop to a network server, but also do incremental snapshots to a local USB device when not on the network, and sync that to the network copy periodically.

</comment><comment><USER32> sysdig([http://www.sysdig.org/](http://www.sysdig.org/))

winpcap([http://www.winpcap.org/](http://www.winpcap.org/))

</comment><comment><USER33> ido-ubiquitous for Emacs: [https://github.com/DarwinAwardWinner/ido- ubiquitous](https://github.com/DarwinAwardWinner/ido-ubiquitous)

A lot of people probably use this Emacs package without knowing it, since several "starter kit" Emacs config templates use it by default. It aims to completely replace emacs completion with ido[1] completion.

[1] [http://emacswiki.org/emacs/InteractivelyDoThings](http://emacswiki.org/emacs/InteractivelyDoThings)

</comment><comment><USER34> \- jsChan [[https://github.com/graftjs/jschan](https://github.com/graftjs/jschan)]. Our javascript implementation of Docker's libchan library. It implements the same kind of semantics that Go channels have, but over the network, and using node streams. Since it is based on the capabilities of SPDY, it allows you to embed additional channels in messages. So i could request a page, but give you a return channel to write the document to. instead of waiting for the response.

\- Graft [[https://github.com/graftjs/graft](https://github.com/graftjs/graft)]. Our attempt to determine what microservices taken all the way to the browser would look like. It's a higher level library built on top of jschan. The idea is to be able to use node streams interchangeably on both sides of the pipe, with the communication managed by libchan ... and work invisibly over SPDY or websockets or whatever.

Unfortunately, SPDY was replaced by http2, which meant that libchan went under construction for a bit while the library support was figured out. At the same time, io.js happened. And now there's a very fastly evolving streams spec that is feeding on the whatwg effort to standardise a stream spec for the browser and node.

I am going to take up the mantle again, but there needs to be some settling of the ecosystem first. =\

</comment><comment><USER35> doctest.js: [http://doctestjs.org/](http://doctestjs.org/) | [https://github.com/ianb/doctestjs](https://github.com/ianb/doctestjs)

Testing system for Javascript, explicit and example-based, with nice support for async testing, and I think it treats test failures particularly nicely. I think it's a way better model than BDD. But no one has ever really cared about doctest.js, even to complain...

</comment><comment><USER36> [https://github.com/cfwheels/cfwheels](https://github.com/cfwheels/cfwheels) \- Rails ported to CFML

was on this for a while. learned alot from the awesome team.

[https://github.com/rip747/cfml-liquid](https://github.com/rip747/cfml-liquid) \- CFML Port of the Liquid Templating language

always wanted liquid available for CFML so I put my time where my mouth was and did it myself. learned a ton and had an awesome time doing it.

</comment><comment><USER37> [https://github.com/pjungwir/db_leftovers](https://github.com/pjungwir/db_leftovers) \- Rails without the data loss. ;-)

[https://github.com/pjungwir/aggs_for_arrays](https://github.com/pjungwir/aggs_for_arrays) \- C functions to compute stats on PostgreSQL arrays.

</comment><comment><USER38> I recently made the code for my newsreader side project public: [https://github.com/charlieegan3/serializer](https://github.com/charlieegan3/serializer) (hosted at [http://www.serializer.io](http://www.serializer.io))

I don't know about pride but I'm pretty happy with it.

</comment><comment><USER39> RobotsAnywhere.

[http://robots- everywhere.com/re_wiki/index.php?n=Main.Softwa...](http://robots- everywhere.com/re_wiki/index.php?n=Main.SoftwareRobotsAnywhere) Released early 2010, full Android robotics stack.

(It is "open source", but I want people to email me for the source because... well, it's interesting to chat).

</comment><comment><USER40> Dust.js ([http://www.dustjs.com/](http://www.dustjs.com/))

Dust is flexible asynchronous templating for both the browser and server.

The project languished for awhile, which I think led to it falling by the wayside popularity-wise. I picked up development last year, and the last nine months or so have seen rapid improvement of the language and documentation.

I feel like Dust would fit many use cases way better than people's current templating solutions. Because it's asynchronous, you can put Promises and Streams right into your template variables, and Dust will handle them properly.

So for example, you can pass ReQL cursors straight into Dust, and it'll stream them into the template, so you get progressive rendering in the browser without buffering the whole result set in memory.

        r.table("messages").orderBy({index: "date"}).run(conn, function(err, cursor) {
          dust.render("inbox", { messages: cursor }).pipe(res);
        });

</comment><comment><USER41> JarMan, for working with Java archives (JAR files). You can check the manifest, see if the JARs listed in the manifest's classpath exist, browse the methods, interfaces, etc. of a class file in the JAR, etc. I've found it handy.

[https://github.com/argonium/jarman](https://github.com/argonium/jarman)

</comment><comment><USER42> At the moment Anvil is my favourite child:

\- [https://github.com/zserge/anvil](https://github.com/zserge/anvil) \- a new reactive UI library for android. It totally changed the way I develop android apps now.

Also there is some tiny ones, but found useful over the years:

\- [https://bitbucket.org/zserge/jsmn/wiki/Home](https://bitbucket.org/zserge/jsmn/wiki/Home) \- JSMN, a very fast and lightweight JSON parser for embedded systems

\- [https://bitbucket.org/zserge/mucks](https://bitbucket.org/zserge/mucks) \- A wrapper for Tmux/Screen/DVTM to keep persistent terminal sessions. Usefule when you use terminal as an IDE

\- [https://bitbucket.org/zserge/gambiarra](https://bitbucket.org/zserge/gambiarra) \- minimalist Lua unit-testing library

</comment><comment><USER43> [http://utter.io/](http://utter.io/)

Mostly operational framework for implementing lightweight federation with OpenStack and Bitcoin. Worked on it for a year before starting to work again as a technology evangelist. Still noodling on it when I have time.

</comment><comment><USER44> Not mine (but I am using it in production and it fits the brief down to a tee).

The world's best open source content management system [https://github.com/SpontaneousCMS/spontaneous](https://github.com/SpontaneousCMS/spontaneous)

</comment><comment><USER45> Leaps, another Google Docs clone except written in Golang. It comes with a web UI for hosting your own pair programming environments.

[http://jeffail.github.io/leaps/](http://jeffail.github.io/leaps/)

The above link has a three step guide for pair programming your local files over LAN (including installation). The service is quite flexible and also allows you to share hosted documents through MySQL and postgreSQL and do things like user authentication etc.

I have a pair programming website set up as a proof of concept that uses leaps with postgreSQL here: [https://megrim.uk/](https://megrim.uk/), it's hosted across three ARM micro computers under my sofa so go easy on it.

</comment><comment><AUTHOR> Javascript database - [https://github.com/kristopolous/db.js](https://github.com/kristopolous/db.js)

Javascript event system - [https://github.com/kristopolous/EvDa](https://github.com/kristopolous/EvDa)

* Self-contained

* Piecemeal

* Vertically sophisticated - simple things remain simple; hard things remain possible

* Focus on pleasant, consistent, ease, and flexibility

My end-users are programmers and my UX is the API and documentation.

I care about facilitating both novice and experienced programmers equal enjoyment and proportional productivity with the most minimum ramp-up necessary.

If I have to think about how to do it in the library or look up how to invoke things, I consider that an impetus for re-design.

</comment><comment><USER46> JSON Archetypes: [https://github.com/servant-app/json- archetypes](https://github.com/servant-app/json-archetypes)

Community-Driven Standards For Popular Types Of Data in JSON.

Think Products, Blog Posts, Events, Contacts, etc.

</comment><comment><USER39> NAVCOM AI, full autopilot for various class of vehicles... in 2007.

[http://robots-everywhere.com/portfolio/navcom_ai/](http://robots- everywhere.com/portfolio/navcom_ai/)

</comment><comment><USER47> [https://github.com/longshoreman/longshoreman](https://github.com/longshoreman/longshoreman)

Longshoreman is a simple solution for deploying Docker containers to a server cluster.

</comment><comment><USER48> [https://github.com/dieselpoint/norm](https://github.com/dieselpoint/norm)

Norm is a lightweight layer over JDBC. Access a database in one line of code.

</comment><comment><USER49> [http://sourceforge.net/projects/oovcde/](http://sourceforge.net/projects/oovcde/) \- creates C++ analysis diagrams

<comment><AUTHOR> Out of curiosity, is sf.net your preference for FOSS hosting in 2015?

</comment></comment><comment><USER50> Hammerspoon - crazy powerful desktop automation for OS X. [https://github.com/Hammerspoon/hammerspoon](https://github.com/Hammerspoon/hammerspoon)

We get a few hundred downloads of each release, but I like to think that the market for people who want to program their desktop, has to be a bit bigger than that :)

(Our website sucks, which probably doesn't help, but we don't currently have any contributors who are good at making pretty web sites)

</comment><comment><USER51> »A Beginner's Guide to Finding User Needs« read: [http://jdittrich.github.io/userNeedResearchBook/](http://jdittrich.github.io/userNeedResearchBook/) source: [https://github.com/jdittrich/userNeedResearchBook](https://github.com/jdittrich/userNeedResearchBook)

Is a free/libre guide teaching how to find out what your users' needs are.

</comment><comment><USER52> mountebank - the first open source tool to provide multi-protocol over the wire test doubles.

[http://www.mbtest.org/](http://www.mbtest.org/) [https://github.com/bbyars/mountebank](https://github.com/bbyars/mountebank)

There are some excellent HTTP/S stubbing libraries out there but no open source ones that let you also stub other protocols. mountebank was first built to support testing Java serialization over a mule-based TCP layer, supports HTTP/S, SMTP, and I'm working on first-class SOAP support. The only tools that provide this capability today are commercial (e.g. CA Lisa) and not nearly as friendly to CI/CD practices.

By the way, thanks for this thread. Independently of my own self-promotion, it's a great idea. Great open source developers are rarely good marketers, which means the best tools often rot in obscurity, and users of the tools rarely recognize that they can help by the simplest of actions. Find the ones you like on this page, star them, fork them, link to them. Help the open source community shine.

</comment><comment><USER53> AppFS ( [http://appfs.rkeene.org/](http://appfs.rkeene.org/) )

It's a "universal package format". It's similar to lazyfs (from 0install) with a bit more structure for packages. It's digitally signed from end-to-end. It uses FUSE. It supports writing, SUID files, and advanced configuration which can be updated at runtime without unmounting.

</comment><comment><USER54> Droopescan, a plugin-based scanner that aids security researchers in identifying issues with several CMSs, mainly Drupal & Silverstripe.

[https://github.com/droope/droopescan](https://github.com/droope/droopescan)

I've been working on it for heaps! Sponsored in part by the company I work for, I reckon it's pretty decent ^^

</comment><comment><USER55> Hacker News Android app: [https://github.com/hidroh/materialistic](https://github.com/hidroh/materialistic)

API testing with Cucumber: [https://github.com/hidroh/cucumber- api](https://github.com/hidroh/cucumber-api)

</comment><comment><USER56> jsLPSolver. [https://github.com/JWally/jsLPSolver](https://github.com/JWally/jsLPSolver)

Easy to use, kind of quick linear programming / mixed integer linear programming solver in javaScript that takes models as easy to understand javaScript objects instead of tableaus.

</comment><comment><USER57> I created shortcode engine for PHP, already battle-tested: [https://github.com/thunderer/Shortcode](https://github.com/thunderer/Shortcode) . I'm proud of it because it's well engineered and it is not copied from WordPress nor it relies on WP.

</comment><comment><USER58> [http://playtomic.org/](http://playtomic.org/) / [https://github.com/playtomic](https://github.com/playtomic) is a bunch of services for game developers, self-hosted and very cross-platform.

</comment><comment><USER59> SeaweedFS Distributed File System

[https://github.com/chrislusf/seaweedfs](https://github.com/chrislusf/seaweedfs)

Seaweed-FS is a simple and highly scalable distributed file system. There are two objectives: to store billions of files! to serve the files fast!

</comment><comment><USER60> libeot: Convert EOT (Microsoft proprietary embedded fonts) to TTF. [https://github.com/umanwizard/libeot](https://github.com/umanwizard/libeot)

As far as I can tell, the only free software capable of doing this.

</comment><comment><USER61> json-sempai: Use JSON files as if they're python modules! [https://github.com/kragniz/json-sempai](https://github.com/kragniz/json- sempai)

It's entirely dumb and not very useful.

</comment><comment><USER62> keystonejs.com a Node CMS kinda like wordpress meets django

<comment><AUTHOR> put the [http://](http://) in front of it so hn makes it clickable.

<comment><USER63> like [http://www.keystonejs.com/](http://www.keystonejs.com/) :)

</comment></comment></comment><comment><USER64> > _Please list the projects you are most proud of along with their project > URLs._

This is what the "Show HN:" submission convention is for.

</comment><comment><USER65> worked on a small petproject to enable annotations in javascript ([https://github.com/warmuuh/yaap](https://github.com/warmuuh/yaap)) just for fun ;) (its not that practical, but in combination with wire.js, its quite fun to work like with Spring)

</comment><comment><USER66> Ket ([http://sourceforge.net/projects/ket/](http://sourceforge.net/projects/ket/))

For most trivial algebra, it's quicker to use paper and pencil than a full algebra system. Ket is a faster alternative with the benefit of clipboards, save/load and export to LaTeX and HTML.

Most algebra consists of recombining existing expressions. These can be added in plain text and substituted into one another by clicking and dragging one equation into another. You can then reorganize the resulting equation using click-and-drag algebra by dragging terms to different parts of the equation, e.g. y=m _x+c y-c=m_ x (y-c)/m=x x=(y-c)/m.

Most real-world algebra problems require translation from real-world information into a coherent mathematical framework. For simple cases, the standard approach is the back-of-the-envelope calculation. This shows only enough working to keep the idea organized in your mind as you solve it. This part of a maths problem is more akin to writing the first draft of an essay. That is, you list relevant known equations and solution fragments which you organize into a coherent narrative.

For this you need an algebra-centred text editor. Most of the time spend doing algebra on computers or on paper is writing and rewriting respectively. To avoid this, Ket is a modal editor (built around Vim-like commands) in which keyboard letters correspond to simple editing commands. That is, the editor focuses on transforming existing expressions and only incidentally on adding new ones. In addition to redrafting working, with each command, the user performs an algebraic step.

A text editor represents a line of text as a list of characters. Ket represents an equation as a tree of functions, constants and variables. And instead of a cursor editing around a particular character, editing takes place around a tree branch. So editing commands edit a function, variable or value at a time in plain text while keeping the larger whole in conventional mathematical notation. And because each command is a single key press, each editing step is as quick as touch typing. Furthermore, while some commands perform algebraic transformations, others simply edit the data structure. This is analogous to algebra on paper where symbols are cancelled by scoring them out.

A text editor represents an essay as a list of lines of characters. Ket represents a document as a list of equations where each is represented as a tree of functions, constants and variables. Instead of a cursor editing around a particular character, editing takes place around a tree branch. So editing commands edit a function, variable or value at a time in plain text while keeping the larger whole in conventional mathematical notation. And because each command is a single key press, each editing step is as quick as touch typing. Furthermore, while some commands perform algebraic transformations, others simply edit the data structure.</comment>


Show HN: I made Breaktap. A daily newsletter for the mobile startup community. - <AUTHOR> http://www.breaktap.com

<comment><AUTHOR> You can have a look at the latest issue here: [http://us6.campaign- archive1.com/?u=9f8345c9a9462d19984b8ca5...](http://us6.campaign- archive1.com/?u=9f8345c9a9462d19984b8ca53&id=ff4d46c6f5&e=3f492344df)

I've been publishing for a little over a week and have gotten some quality feedback so far but would love to hear from HN readers, particularly in terms of the content curated: am I covering the most pertinent areas? Too many articles? Too little? Is it something you'd be interested in subscribing to? Any feedback to this end would be awesome.</comment>


Variable pricing spreads to Amazon, Lala, Rhapsody, Wal-Mart - <AUTHOR> http://arstechnica.com/media/news/2009/04/variable-music-pricing-comes-to-amazon-lala-rhapsody-too.ars <comment><USER2> Gee, what a surprise. Develop alternatives to Apple, whack Apple into submission then "reward" the alternatives by making them join Apple with price increases. I think they just don't understand their market and the times... Charging more for pretty much anything digital (or computer-related) is a hard, hard sell.</comment>


VMWare ousts founder - <AUTHOR> http://www.bloomberg.com/apps/news?pid=20601087&sid=ahpYslwsz.vs&refer=home

<comment><USER2> She was just featured in the most recent Economist:

[http://www.economist.com/people/displaystory.cfm?story_id=11...](http://www.economist.com/people/displaystory.cfm?story_id=11662168)

</comment><comment><USER3> Its a sad day when the founder is ousted. I wonder why Vmware is in trouble. I can't imagine it is because of Greene.

I think virtual machine technology has great potential.

<comment><USER4> "Trouble" in the crazy stock market sense. They are not reaching "growth targets", which means she isn't pushing hard enough for growth. In reality she's probably a great boss, but just not cut out for running a public company owned by another company.

I'd feel bad for her, but I'm sure she has plenty of money. She apparently loves windsurfing, so they should just move back to Hawaii and have fun. Her picture looks like she's in her 50s, so she should just retire early and have lots of fun in the sun.

<comment><USER5> projections for 2008 was +50% growth. vmware didn't manage that, but it's not a reason to oust the ceo.

this is a highly political move

<comment><USER5> another article showing that vmware might have been too successful for emc's ceo <http://www.theregister.co.uk/2008/07/08/tucci_costs_vmware/>

</comment></comment></comment></comment><comment><USER6> Wow. The interesting part of this story is that VMWare was founded by a woman. Fascinating.

<comment><USER7> Best to call her the "co-founder." She's the non-technical head. The technical co-founder is her husband, Mendel Rosenblum, who created the first robust implementation of x86 virtualization.

Quite impressive that these two have been together so long without the business partnership or marriage falling apart.

<comment><USER8> I'm pretty sure people who know her from her UCB days (she was peripherally involved with Stonebraker's research) would say it's a mistake to call Diane "non-technical".

</comment></comment></comment><comment><USER9> Wow. This going to come back to slap EMC in the face, just like what happened back with Moshe Yanai. It looks like the EMC management can't retain it's most valuable employees.

<comment><USER10> What happened with Moshe Yanai? I can't find much on Google.

<comment><USER11> Nov. 2001: "Moshe Yanai, VP of engineering at EMC and the inventor of its Symmetrix flagship storage array, has received a cut of Symmetrix sales for over a decade. And they maintain that the arrangement has thwarted EMC's ability to create new hardware for a tougher market. ... EMC denies rumors that Yanai is set to leave the company." <http://www.byteandswitch.com/document.asp?doc_id=9644>

Dec. 2001: "the chief engineer would no longer oversee the company's hardware division and, instead, would become an adviser to CEO Joseph Tucci. ... Yanai was pushed aside and really sidelined." [http://www.bizjournals.com/boston/stories/2001/12/24/newscol...](http://www.bizjournals.com/boston/stories/2001/12/24/newscolumn3.html)

2002: "XIV is led by Moshe Yanai, one of the key architects of data storage systems and instrumental in the development of EMC's Symmetrix and DMX product lines throughout the 1990s." <http://www.xivstorage.com/company/company_background.asp>

2008: XIV bought by IBM to compete against EMC.</comment></comment></comment>


The State of the World Isn't Nearly as Bad as You Think - <AUTHOR> https://edge.org/response-detail/26669 <comment><USER2> But the improved quality of life and so on has been built up in an unsustainable manner. We have been using or otherwise destroying our non- renewable resources (arable land, fresh water sources, and so on) at an accelerating pace.

Its actually typical for a society or civilisation to be at the height of its power before it collapses; the easter islanders had their greatest population and were constructing the biggest stone heads just before their collapse.</comment>


IE11 gains the most market share, and Chrome finally passes Firefox - <AUTHOR> http://thenextweb.com/insider/2014/04/01/ie11-gains-market-share-chrome-finally-passes-firefox/ <comment><USER2> a lot of April prank going around...

though _this_ won't "work" on HN, Microsoft gaining on WEB market, give _us_ a break!</comment>


RFPs Will Kill Us All - <AUTHOR> http://bigbangtechnology.com/post/rfps_will_kill_us_all

<comment><USER3> 3/4 through this article I started wondering whether this was some kind of Swift-ian satire about the graphic design "spec work" argument. I don't think it is.

Here's the deal: it's called supply and demand. If clients have 10 quality firms to choose from, and they pay their firms enough, then building an excellent RFP is simply going to be the cost of doing business with them.

Sometimes, some firms are so good, and provide output that is so hard to match with any substitutable firm, that they get to set the terms for the client/vendor relationship. Those firms know who they are, because they have waitlists, and are already turning down clients.

If you want to boycott RFPs, by all means, get your lunch eaten by the companies who are willing to throw those two extra non-billable days at the task of making themselves extra easy to work with. But I don't think you're going to manage to demonize the RFP process the way designers have the spec- work process, because RFPs are simply the way consulting works.

<comment><USER4> > because RFPs are simply the way consulting works.

Not all the time. I never respond to public RFPs, and neither does the OP. Apparently in our (separate) niches, you can get by just fine.

Agree with your point about supply and demand, but good hackers are (nearly) always in demand, and so can nearly always find work. It's the strange outsourced companies that spend all their time searching for work that end up responding to RFPs, and that's dangerous even to clients.

Look at it this way: if you have a pool of proposals sitting on your desk, 90% of which are from firms that are simply incapable of doing the job[1], and you are a business/nontechnical chap, it's going to be difficult to find the 10% who are capable, let alone competent.

Meanwhile, technical guys who are good hackers but don't understand this see lots of firms sending out and responding to RFPs and think this is how it works, so I guess we have to do it too.

[1] [http://www.elance.com/php/search/main/eolsearch.php?matchTyp...](http://www.elance.com/php/search/main/eolsearch.php?matchType=profile#page=1&matchKeywords=iphone%20developer&sortBy=&sortOrder=1&bizFilter=false&catFilter=10183&indFilter=false&premierFilter=false&feedbackFilter=0&reviewsFilter=0&minrateFilter=lt20&locFilter=&regionFilter=&zipFilter=&zipRadiusFilter=50&skillFilter=-100&groupFilter=)

<comment><USER3> Knowing what I know about the bill rates for the kind of work we do versus the kind of work you likely do, I'm going to humbly suggest that we're in more demand than you are (not a value judgement, just an observation about scarcity).

We absolutely do respond to RFPs, when they're for projects we want to work on or clients we really want a relationship with. And we always spend serious otherwise-billable time on proposals, even though that's the same speculative work that this article argues against.

It's important to us to be easy to work with, because we want good projects. We don't want to confine ourselves to whatever lands in the margins of "unusually liberal clients"; those clients don't necessarily have the best projects.

I read the other post referenced on this thread, and so I'll add that being able to smoke out the bogus RFPs you shouldn't waste time responding to (because they indicate inept purchasers, or, for instance, because they probably mean the client is in the tank for another vendor) is just one of those things you need to be able to do to succeed as a consultant.

<comment><USER5> Any pointers on how to identify clients already in tank with another vendor? Being overly specific in the RFP and demanding the exact features a vendor has is a clear giveaway but I am wondering if there are any other signs.

I am new to this RFP business.

<comment><USER3> We get on the phone before we respond to expensive RFPs, and there are questions you can ask (incumbent vendors, past experience with vendors, is there a formal requirement for the RFP, or do they genuinely want real proposals, etc).

On "real" RFPs, especially if you have a good shot, you'll find the purchaser you talk to is accomodating; they'll set aside time for calls to answer questions, and they'll do a good job with your Q&A submission (as a general rule, real RFPs have Q&A phases, though note that you never know whether your Q's are going to other vendors too).

There is an old negotiating trick a bizdev guy taught me once, which is, if you want to figure out whether a deal is real or whether the other side is just wanking, figure out a reason to schedule a meeting on a Saturday. If the deal is big and the other side is serious, they'll do it. Similar idea here, although less aggressive.

If your firm's way of handling the RFP process is to simply pick up the forms off some website, mail them in, and hope, then yes, I can see how the RFP process would upset you.

<comment><USER5> That's great advice. Thank you!

</comment></comment></comment></comment></comment></comment><comment><USER6> I work for a publicly funded institution, in our jurisdiction we have to go through the RFP process. It is either an RFP (where we are allowed to do an evaluation of who "best" met the requirements - using a pre-defined scoring criteria) or a straight tender where we have to pick the lowest bid that meets the requirements.

I sympathize that it is very difficult to produce a proper response to an RFP, however as one who evaluates those responses let me tell you it is quickly evident which vendors spend the time to do so. It is also painful on the client side to prepare the criteria on which to fairly evaluate the responses.

It is an imperfect process and definitely more of an art than a science but the good news is that a well-defined RFP will often signal a client who understands their requirements.

</comment><comment><USER7> Most consultancy firms that don't respond to RFPs eventually die. Of those firms that survive, they could be viewed as a collective of successful freelancers. There typically is not enough revenue to grow the company beyond the founding consultants because the project budgets that they deal with are typically $15K to $50K. You can definitely get away with not responding to RFPs if you're only ever dealing with budgets of tens of thousands of dollars. Also, an RFP is a way for customers to weed out the "I just quit my day job at an agency and started my own consulting company" firms. These customers want to deal with bigger firms because they expect these companies to be around for a while and provide support years down the road. A bigger company can afford to devote a few employees for a couple of weeks to address an RFP properly.

<comment><USER3> I _thought_ we put a lot of effort into RFPs, but wow, 2 employees 2 weeks is crazy. For us, it's more like 1-2 days.

<comment><USER7> Depends on the project. A lot of website RFPs can be done in a crunch session of 1 to 2 days. I've had to bid on systems that interacted with assembly lines and ones that involved dealing with the government and getting security clearances. These latter two took 2 calendar weeks although the people involved in putting together the RFP were definitely not working full time on it until the last minute. All in all you might have 1-2 days of actual work, 1-2 days spent Q&A attending meetings with the client and other potential vendors, etc. The time can add up.

I have seen one ridiculous "RFP" that a government agency up here put out recently in which they wanted potential vendors to essentially do 6-8 months worth of work and if they landed the project, they'd end up with a long term multi-year contract. We're talking tens of millions of dollars here, but still, that one struck me as quite the lottery and I'm pretty sure the only companies that responded to it were the big names consultancy firms.

EDIT: here's the results of that RFP...whaddaya know look which firms won the bid: [http://www.newswire.ca/en/releases/archive/October2009/21/c8...](http://www.newswire.ca/en/releases/archive/October2009/21/c8969.html)

<comment><USER8> It might be willful ignorance on my part, but I really want to believe that eHealth is the (unfortunate) exception, and not how IT usually works - <USER2> when we're talking about government contracts.

<comment><USER7> I've done some work for a Federal government agency a few years back and a provincial government within the past year. eHealth was exceptional not because of the cost but because nothing got done.

Here's where posting anonymously is beneficial (but alas since it's anonymous, take my account with a grain of salt). My opinion is that a select few large IT companies in Canada have a virtual monopoly on all government work. In fact, the only reason that I was involved in these projects was because certain teams from these companies screwed up so badly that some bureaucrats formed a skunk works side project to move things along. There was an unspoken understanding that the government wouldn't sue and shake the boat, but that they'd screwed up badly and needed to let another party try to resolve the situation.

Pretty much the only way you're going to get access to government contracts is via sub-contracting for these firms. To bring this post back on topic, the reason that this happens is because in a bid to try to account for government spending, the government issues these RFPs that are so lengthy and cumbersome to accomplish that only the big companies can actually pull them off. But it's a premature optimization and means that the government spends more money than it needs to. It's not unheard of for a simple web application to have a budget of CDN$1M. This would be something that your typical YCombinator team could pull off in 3 months and US$17K.

Some of the more successful government projects that I've heard of are ones where you have a bureaucrat that hires acquaintances without an active bidding process, because they can vouch for their expertise. Stuff gets done quickly and correctly the first time because there's little red tape to work around. Unfortunately, eHealth involved friends hiring friends and stuff just not getting done. I always thought that the criticism of eHealth folks hiring people they knew was less of a concern than the fact they simply didn't get stuff done. I mean think about it, in the private sector do you get people to actively bid on every little position and project or do you have your go-to guys?

Anyways, my opinion is otherwise largely positive with government work here in Canada. They seem to spend more money than I think they would if they let smaller more agile companies into the fold more often. But stuff seems to get done and when it doesn't (e.g., eHealth) you hear about it. Most of the government people I've worked alongside care very much about their job and doing it well. It wasn't unheard of for them to reply to my off-hours questions on their Blackberries on a weekend. So all is not lost. If I'm a little bitter, it has to do with what I perceive to be a rigged RFP process that favours these big vendors.

<comment><AUTHOR> This is a really well thought-out response. Even though people would probably like to describe eHealth as an exception, I think that situation really exemplifies the problems I was trying to expose in the RFP process. It's just another reason it's a bad system.

<comment><USER3> No, it exemplifies what's wrong in the GSA-style procurement system, where the process is deliberately complicated and biased towards a small number of institutionally-accepted contract holders. It has nothing at all to do with the bare concept of an RFP, and does not reflect the nature of RFPs outside of FedGov.

</comment></comment></comment></comment></comment></comment></comment><comment><USER9> The article is well thought out and presents a good viewpoint. I think it's one-sided and, um, short-sighted.

I see the RFP process from the viewpoint of a buyer and a provider. From the buyer's standpoint, when we start a project we simply don't know what firms are capable of doing what we want done. The RFP gives us a level playing field to compare costs, capabilities, and experience.

Without an RFP, particularly for complex projects, you can spend months scoping out capbilities, refining your needs (both of which you should be doing AFTER you form a relationship.)

Which takes longer for a firm? Researching an RFP and presenting a document for a potential client's review or spending eight months going back and forth trying to figure out what to build. Of course, the latter. The difference is that providers get paid for those eight months (a plus for them) while buyers get nowhere.

</comment><comment><USER10> Our approach is to respond to RFPs with a fixed-rate proposal development fee.

Anyone that's good enough to be in demand should do the same. Clients that expect you to do work for free will probably turn out to be difficult people to work with in the long term.

<comment><USER3> Do people tend to actually pay you to develop proposals? Or is that just your way of turning down RFPs?

I make this same observation every time the spec-work argument comes up (if you haven't picked up on it, I'm also not against spec-work):

When we were just getting started, lawyers from WSGR and another firm spent literally hours on the phone with us, for zero money and no promise of ever being compensated, presumably because the fact that they're willing to be that cool to work with costs them very little and makes them incredibly attractive in the long run.

I want to be like them.

<comment><USER10> Good point. So far about half have paid.

I guess the main reason this works for us is that we prefer smaller projects. We don't aspire to being a huge consulting company / agency taking on bigger and bigger projects. We like working on small projects that grow into bigger things.

<comment><USER3> Just be aware that you're not only restricting the size of the projects you take on, but also the selection of clients you have to work with. Some very excellent projects will require competitive proposals for you to get in the door.

</comment></comment></comment></comment><comment><USER11> The normal way to solve this in government and big dumb companies (which issue RFPs) is to have one domain-specific expert firm awarded an RFP management contract, recusing itself from the actual implementation contract, which then specifies what will be in the RFP. Judging the proposals is a combination of the client and process-management contractor, and in some, the management contract manages the ongoing relationship with the contractor as well.

It's inefficient for best case (you have 2 contracts instead of one), but solves a lot of worst-case problems (bribery or incompetence leading to a rigged bidding process, companies awarding themselves contracts, or buying a perfect but wrong thing).

I'm not sure of the background of the author, but RFPs are standard in a lot of domains.

</comment><comment><USER12> For the most part, I view the RFP as a way to encourage wrong and ill-fitting service providers or third party consultants to engage with your company or business. Simply put, an RFP is just a tick-a-box approach to seeking skills and services externally. The tick-a-box approach and mentality by it's nature sets up a very black and white context. This is the problem. Business for the most part is not purely objective.

A better approach I think, would to be more proactive and approach only those service providers or companies that are somewhat aligned with your business or company values and vision.

Another solution (for bigger companies) would be to fund smaller independent teams to consult as an acting external supplier.

</comment><comment><USER13> Nice article, Max. Carl from nGen Works has an interesting post up of late on the same topic:

[http://www.ngenworks.com/blog/detail/from_the_archives_chapt...](http://www.ngenworks.com/blog/detail/from_the_archives_chapter_1_answering_rfps)

</comment><comment><USER14> Mike Bosworth's two books Solution Selling and CustomerCentric Selling talk a bit about RFP/RFQ's.

The authors note that most RF[PQ]'s are prewired and biased towards a preferred vendor. The client gives out the RF[PQ] so the client can say it was properly competed for so it can pass the approval process in upper management. If you are not that preferred vendor who was there from day one, you will most likely not win.

The author cites one anecdote of a big company that has a separate department that only handles RF[PQ]s. One day they decided to take some metrics over a time period. Out of that time period, they submitted 153 bids to unsolicited RF[PQ]s ... only won 3.

<comment><USER3> Some RFPs are definitely rigged. Spotting them is part of being a good consultant. See upthread for a deeper discussion on this.

"Most" RFPs are not rigged.

A company that submits 153 RFP responses and wins only 3 has a problem, and it isn't with the concept of RFPs. Perhaps their pricing is wildly out of whack. For awhile, there were things we did wrong with our proposals that cost us several RFPs. We figured them out, resolved them, and systematically improved our win rate.

There is no way that 1.9% (or even 5%) of RFPs are bogus.

</comment></comment><comment><USER15> In case anyone's wondering, RFP (probably) stands for Request for Proposal

<http://en.wikipedia.org/wiki/Request_for_proposal>

<comment><USER3> FWIW: An RFP is just a company's formal process for documenting an upcoming project and soliciting proposals from multiple vendors for it. There are as many RFP processes as there are companies running RFPs.

</comment></comment><comment><USER16> Hmm, this perspective seems to ignore growing services like InnoCentive and Aardvark to connect people with knowledge to buyers. I'm not sure about the pricing equilibriums in play, and I'm not sure about the relevance to RFPs. Am I relating two frameworks that shouldn't be?

</comment><comment><USER17> hm. well, personally, I find 'relationships' in business usually raise costs. How to get around this? I don't know.

You could simply only buy commodities. If this is possible, it is clearly the best answer. However consulting isn't a commodity, and neither is design work. it seems that making it a commodity is a 'hard problem' - RFPs are one attempt to treat consulting as a commodity, and they are obviously imperfect.</comment>


JSNice: Statistical renaming, type inference, and deobfuscation - <AUTHOR> http://www.jsnice.org/ <comment><USER2> I'd like to know more about how it picks variable names. Running it on non- obfuscated code is amusing. It occasionally comes up with better names for my variables than the ones I had picked.

<comment><USER3> It has read lots of code before reading yours: [http://www.srl.inf.ethz.ch/jsnice.php](http://www.srl.inf.ethz.ch/jsnice.php)

<comment><USER4> Arguably code with better names than the OP's code ;)

</comment></comment></comment><comment><USER5> I tried to de-obfuscate some HTML5 games that I made and the result was bad, marginally better than some naive JS beautifiers.

Yes, we all know that it's pointless to obfuscate client side code, but this serves as a simple deterrent. I've had games copied/pasted on some Chinese website and this seems to avoid that.

I used this [0] to obfuscate, which is free and open-source. You can also try it online here [1] if you don't feel like installing the Node.js package just for playing with it.

disclosure: I built the web interface [1] to the obfuscator, which is also open source.

[0]: [https://github.com/javascript-obfuscator/javascript- obfuscat...](https://github.com/javascript-obfuscator/javascript-obfuscator) [1]: [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com/)

<comment><USER6> I always see ads from JScrambler, does this really work?

<comment><USER5> I used JScrambler before and I really liked. If you don't mind the monthly fee, I'd say go for it.

They do nice stuff, like hiding some of your strings, other literals and random predicates inside an encrypted string. This is decrypted and eval'd at runtime using the text of the decrypt function as a parameter i.e, you can't beautify it otherwise it stop working. The random predicates are merged within your code for instance: it appends a `&& somePredicateThatReturnsTrue(someOtherRandomValue)` to ifs conditions. It makes it really hard to figure out what is happening.

<comment><USER7> Just as a general thought, not specific to this product:

 _This is decrypted and eval 'd at runtime_

Most(all?) string-based obfuscators can be bypassed by simply replacing eval with a logging eval implementation.

      var oldEval = eval; eval = function(str){console.log(str);oldEval(str)};

A similar patch to the Function constructor can bypass the other easy dynamic code generation code path.

If at some point, a string needs to be evaluated as code, then it's possible to intercept that code and output it.

<comment><USER8> So, all you need is to break a longer eval into multiple smaller ones, shuffle them and thus make it a chore to connect the evals back.

<comment><USER9> tried it, does not work I'm afraid...

</comment></comment></comment></comment></comment></comment><comment><USER10> I'm a big fan of JSNice - it's easily the best JS beautifier I've used. It's twice saved my bacon, really helping to make sense of some horrible, buggy third-party code.

</comment><comment><USER11> It would be useful to have this for other languages. I'd love to have it for some of the VB.net and C# I have seen.

</comment><comment><USER12> It would be cool if they made an API that an editor could interact with.

</comment><comment><USER13> I really like this. Is it using the flowtype notation?

<comment><USER14> These are closure type annotations - [https://github.com/google/closure- compiler/wiki/Annotating-J...](https://github.com/google/closure- compiler/wiki/Annotating-JavaScript-for-the-Closure-Compiler)

<comment><USER15> They are probably using closure in the background, using the new type inference with the compiler, to collect the meta information.

<comment><USER16> Yes, the paper JS Nice is based on calls out that they use the Closure Compiler as a backend: [http://www.srl.inf.ethz.ch/papers/jsnice15.pdf](http://www.srl.inf.ethz.ch/papers/jsnice15.pdf)

</comment></comment></comment></comment><comment><USER17> Doesnt seem to work with ES6 and imports ? :(

<comment><USER18> It doesn't work with much of ES6 at all</comment></comment>


Goodbye, Motherboard. Hello, Silicon-Interconnect Fabric - <AUTHOR> https://spectrum.ieee.org/computing/hardware/goodbye-motherboard-hello-siliconinterconnect-fabric <comment><AUTHOR> It's been fun to see Dr. Subu present this concept and prototypes at several conferences, and the level of integration possible is absolutely insane. I think the industry is definitely moving toward chiplets, such as the latest AMD release.

I definitely think we will see more chiplets and more standardization on interfaces between chiplets. The focus will be on how to minimize energy per bit transferred (a big topic in Subu's talks) and how to minimize the die area used for inter-chiplet communication. In monolithic silicon, you don't have to think about die area, since your parallel wires between sections might just need a register or two along the way. With chiplets, you typically can't run wires at that density yet, so you still have some serialization/deserialization hardware. But, since it's not crossing multiple high inductance solder balls and PCB traces, you can get away with less. Hopefully also you can get away without area-intensive resynchronization, PLLS, etc.

I think it will definitely be awhile before this kind of integration is used outside of niche cases though. The costs are just insane. You have to pre-test all manufactured chiplets before integration, and that test engineering is nothing to sneeze at. If you don't then you have all kinds of commercials issues about who is liable for the $500k prototype one bad chip broke.

On the bright side, I see the chiplet approach benefitting other integration technologies. For example, wafer level and panel level embedded packaging technologies can be used for 1-2um interconnects now. You won't get a wafer sized system out of it with any kind of yield, but it's probably the direction mobile chips and wearables will go.

Anyway, disorganized info-dump over.

<comment><USER2> I agree this looks promising, though I'm not an expert in this field.

But the title is a bit, well, overpromising or broad. I don't think we'll replace traditional motherboards anytime soon (except maybe in smartphones?). Rather, it will be an incremental progress.

\- first, SoC's will be replaced with chiplets

\- then we'll start seeing more and more stuff being integrated on this wafer.

\- say, instead of a server motherboard with multiple sockets, have all the CPU chiplets on the same wafer and enjoy much better bandwidth than you get with a PCB

\- integrate DRAM on the wafer. This will be painful as we're used to being able to simply add DIMM's, but the upside is massively higher bandwidth.

The motherboard pcb per se will live for a long time still, if nothing else then as the place to mount all the external connectors (network, display, pcie, usb, power, whatnot).

<comment><USER3> > integrate DRAM on the wafer. This will be painful as we're used to being > able to simply add DIMM's, but the upside is massively higher bandwidth.

One way I imagine this working out is that, instead of just replacing the plastic motherboard with a silicon motherboard, you eventually do away with a single monolithic motherboard entirely. Instead, you have "compute blocks" (comprised of chiplets bonded to a silicon chip, or conventional chips on a conventional circuitboard) that connect with each other via copper or fiber optic point-to-point communication cables, and you can just wire them together arbitrarily to build a complete computer. Like, you might have a couple blocks that house CPUs, one or two that have memory controllers and DRAM, and maybe one with a PCI bus so you can connect peripherals, and you can connect them all in a ring bus. You could house these blocks in a case and call it a server, or connect a lot more blocks and call it a cluster.

The main advantage of such a setup is that you don't have a single component (the motherboard) that determines how much memory, how many processors, or what sort of peripherals you can have.

<comment><USER4> I've been playing a lot of TIS-100 lately, so this architecture sounds like a nightmare to develop on.

<comment><USER5> You know, I bet the TIS-100 wouldn't even be all that tricky given a) way more cells and b) a compiler to abstract a bunch of stuff.

</comment></comment></comment></comment></comment><comment><USER6> Yeah... I'm not entirely convinced about this future.

* PCBs are cheaper to manufacturer than silicon wafers.

* PCBs can be arbitrarily created and adjusted with little overhead cost (time and money).

* PCBs can be re-worked if a small hardware fault(s) is found.

* PCBs can carry large amount of power.

* PCBs can help absorb heat away from some components.

* PCBs have a small amount of flexibility, allowing them to absorb shock much easier.

* PCBs can be cut in such a way as to allow for mounting holes or be in relatively arbitrary shapes.

* PCBs can be designed to protect some components from static damage.

What I can see on the other hand is some packages end up being dropped into the PCB and soldered at the sides. Sometimes this is done with large through- hole capacitors, where the legs are bent and the capacitor sits in the middle of the PCB (inside a cut hole). Other than ball packages, you could could probably drop the majority into the PCB itself.

The other obvious option for manufacturers will be to put more tech on a single die, but then other problems are also raised. For example, some parts are binned based on their tested results.

<comment><USER7> _What I can see on the other hand is some packages end up being dropped into the PCB and soldered at the sides._

That's been done for at least 30 years:

[https://www.keesvandersanden.nl/calculators/hp32sii_repair.p...](https://www.keesvandersanden.nl/calculators/hp32sii_repair.php)

<comment><USER6> That's amazing and I'm glad that it's possible, even by the standards of older technology. I certainly think dropping packages into the PCB is the lowest hanging fruit for reducing depth.

</comment></comment></comment><comment><USER8> "Power turned out to be a major constraint. At a chip's standard 1-volt supply, the wafer's narrow wiring would consume a full 2 kilowatts. Instead, we chose to up the supply voltage to 12 V, reducing the amount of current needed and therefore the power consumed. That solution required spreading voltage regulators and signal-conditioning capacitors all around the wafer, taking up space that might have gone to more GPU modules."

Uh, this seems like a pretty serious downside.

<comment><USER9> Also: shifting PCB prototype costs in the direction of silicon is going to be a tough sell for many applications.

> Another drawback of SoCs is their high one-time design and manufacturing > costs, such as the US $2 million or more for the photolithography masks

> ... 6 paragraphs later ...

> Patterning wafer-scale Si-IF may require innovations in "maskless" > lithography.

</comment></comment><comment><USER10> "Silicon-interconnect fabric, or Si-IF, offers an added bonus. It's an excellent path toward the dissolution of the f(relatively) big, complicated, and difficult-to-manufacture systems-on-chips that currently run everything from smartphones to supercomputers. In place of SoCs, system designers could use a conglomeration of smaller, simpler-to-design, and easier-to-manufacture chiplets tightly interconnected on an Si-IF."

Reading this reminded me of a remark from Bunnie Huang's teardown of a dirt cheap 'gongkai' cellphone ([https://www.bunniestudios.com/blog/?p=4297](https://www.bunniestudios.com/blog/?p=4297)): "To our surprise, this $3 chip didn't contain a single IC, but rather, it's a set of at least 4 chips, possibly 5, integrated into a single multi-chip module (MCM) containing hundreds of wire bonds. I remember back when the Pentium Pro's dual-die package came out. That sparked arguments over yielded costs of MCMs versus using a single bigger die [...] I also remember at the time, Krste Asanović, then a professor at the MIT AI Lab now at Berkeley, told me that the future wouldn't be system on a chip, but rather "system mostly on a chip". The root of his claim is that the economics of adding in mask layers to merge DRAM, FLASH, Analog, RF, and Digital into a single process wasn't favorable, and instead it would be cheaper and easier to bond multiple die together into a single package. It's a race between the yield and cost impact (both per-unit and NRE) of adding more process steps in the semiconductor fab, vs. the yield impact (and relative reworkability and lower NRE cost) of assembling modules. Single-chip SoCs was the zeitgeist at the time (and still kind of is), so it's interesting to see a significant datapoint validating Krste's insight."

I wonder if there's any advantages to si-if from an ewaste (aka reverse logistics, cradle-to-cradle) perspective

</comment><comment><USER11> Another drawback the article doesn't mention is tight component coupling removes the ability to treat the components as separate pieces. This can make repair or upgrades extremely difficult. This might be desirable for companies against the right to repair; if it's illegal to use software to prevent repair, making it sufficiently difficult by hardware design is a possibility.

<comment><USER12> Is anybody actually repairing a faulty motherboard? Let's one of the chips or some resistor is broken.

<comment><USER13> Yes, quite often in fact. On older motherboards, often the only problem is something benign like a blown capacitor, which is a few cents at the hardware store and a few minutes labor to desolder the old and attach the new. It's a really common part to wear out due to heat stress, and it manifests as funky logic problems, since the caps are mostly there to clean up the line noise. I've saved a few flatscreen monitors this way, that were flickering and unusable; I'll take a $5 handful of parts over a new $179 monitor any day of the week.

<comment><USER14> I have only a rudimentary understanding of electronics and what the various components do, so this may be a dumb question, but how on earth do you diagnose an issue like this? If my monitor dies or my printer stops working and I open it up, I'm completely bewildered at what steps you'd take to figure out that some random resistor or capacitor out of (what seems like) thousands of components is the one causing the issue. Do you just go through and test each one with a multimeter until you find it?

<comment><USER15> If a consumer electronic device suddenly refuses to power on, it's a failed electrolytic capacitor most the time (in my experience). Finding them requires effectively no knowledge of circuits. Sometimes one is visibly deformed/exploded, but I usually just replace them all.

If that doesn't work, yea you pretty much start testing things with a multimeter starting from the power source. But if it isn't a capacitor failure, it's probably ESD or power-surge related damage and not worth trying to fix.

<comment><USER16> I attempted to repair a coffee machine that had a short that left a black burn on the PCB. Replaced the parts around it and it still wouldn't turn on. Likely the power surge destroyed a lot of things.

<comment><USER17> Those sorts of power faults can burn out traces on the circuit board too (you can bypass the break sometimes), and often there are fuses that would n need changing (in my very limited experience).

Louis Rossman on YouTube has a lot of stuff on circuit repair that I find good, [https://m.youtube.com/watch?v=_at9Jy3dfeY](https://m.youtube.com/watch?v=_at9Jy3dfeY).

</comment></comment></comment></comment></comment></comment></comment><comment><USER18> This step is inevitable in my opinion. This is especially true for mixed signal (that is some digital and some analog components) systems. It's early fore-bearer (multi-chip modules or MCM) was instrumental in IBM getting its later mainframes to hit the density and thermal constraints.

Like the authors, when I saw AMD's chiplet pictures for the Zen2 chips I felt that we would see this expanded. Intel has also done some interesting optical chip to chip interconnects that would facilitate assembling these newer multichip modules into chassis that route signals to and from the outside world.

The next (and perhaps last) element to fall into place is a way to efficiently cool these systems. One of the problems that large data centers face is not that they want "smaller" boxes but that they need to pull enough heat out of a rack of servers in order for them to reliably function.

<comment><USER2> For data centers, while air cooling might be running out of steam, there's plenty of leeway in water cooling. So I don't think that's an insurmountable problem.

<comment><USER18> Having been inside Google's data centers I agree with you :-). I did a top level, high efficiency data center design for a multi-tenant hosting with Google scale economics as an exercise once, talked with some potential partners who were very enthusiastic. It would cost roughly double what the existing warehouse type data centers cost to build, but it would repay its costs faster than they did (given colocation cost structures at the time). It also leveraged some of the open compute designs to achieve better density.

</comment></comment></comment><comment><USER19> For reference, there are companies that have developed this to a commercially viable level. First that comes to mind is ZGlue, a company that has the design tools, interconnect fabric, and chiplet ecosystem required to deliver these kinds of devices.

[https://www.zglue.com/](https://www.zglue.com/)

<comment><USER8> This is really impressive work.

</comment></comment><comment><USER20> The downside is that independent entities are not anymore able to design hardware projects, there are only a few companies that can design and make such integrated circuits. Cpu's are not only made for computers but for all sorts of appliances. Time will tell if these big companies will sell chiplets and the tech to assemble them onto silicon to 3rd paties. PCB tech is fairly democratic in that sense.

<comment><USER2> I think it's more fruitful to (initially at least) see this as an alternative to single chip SoC's rather than an alternative to PCB's.

</comment></comment><comment><USER21> I kinda like this idea, but I think it only makes sense where the end product sold to the intended consumer is wholly integrated. So, this might make sense for a smartphone. Or perhaps custom systems in Google- or Amazon- scale datacenters, with a number of different custom types tuned to exactly the work each is intended to do, and packed as densely as the intersection between thermodynamics and economics will allow.

But, I don't think we can escape the need for packages and PCBs entirely. At some point, you're going to need to interface with something that either A) you don't or can't control, or B) something at appropriate scale for interfacing with the humans whom the fancy system is ultimately supposed to serve. In either case, here come standard connections that are much bigger than the chiplet dies or the interconnect fabric between them, and thus, the need for PCBs to connect the Systems-on-a-wafer to the outside world.

As such, I think it will be a while before I can pick components out on Mouser's website, and have all those component chiplets fused to an interconnect wafer and delivered to my home or employer's shipping dock (though that would be damned awesome).

<comment><USER22> > As such, I think it will be a while before I can pick components out on > Mouser's website, and have all those component chiplets fused to an > interconnect wafer and delivered to my home or employer's shipping dock > (though that would be damned awesome).

I agree. People have been talking about that future since at least the 1990s (back then SOC didn't mean a somewhat standard chip with a lot of peripherals, but literally a custom die with your own hardware on it). "Hardware/software co-design" was part of the jargon of the day. I'm not holding my breath.

But I do imagine seeing a lot of consumer products go this way. Not a $3 IoT light switch/malware vector, but anything that gets rid of connectors is a win on both the BOM and reliability standpoint, but anything in the $50-$500 price range with volume over a million units is probably worth it.

</comment></comment><comment><USER23> Color me skeptical, but I remember being 12 seeing this on The Screen Savers on TechTV in 2003

</comment><comment><USER24> I like the idea of faster and smaller devices but dislike the idea of expensive production methods that are only realizable with heavy capital investment and large volumes of products.

Like I can realize a PCB prototype in my apartment (or rather, my parking lot without telling my landlord), or rent a CNC machine at a makerspace/public library to do it. If I need the thing fabbed with a nice solder mask and silk screen, I can have it made for < $20 domestically with under two weeks lead time. Component sourcing is even easier.

But where do I go to have the chiplets I need for the circuit? Organize the logistics to ship them to the clean-room where they can be packaged on this fabric? How many widgets do I need to ship for this to be viable, or for the contract fab to not laugh at me? How do I prototype? How long is the lead time?

It just seems like there's a _lot_ in the way of this being viable for run of the mill projects.

<comment><USER2> Increasing capital costs and consequent dependence on huge volumes have been a defining feature of the semiconductor industry since the invention of the integrated circuit.

AFAICT this technology will have no impact on the low end hobbyist end of the market, but rather (if all works out) enables those $zillion behemoths to produce ever faster systems since they won't be as bottlenecked by off-chip bandwidth as they are with today's PCB's.

</comment></comment><comment><USER25> You can order custom pcb from China for a couple of dollars. How likely is that this technology will be affordable at small quantities?

<comment><USER2> Seems one of the main advantages is higher density of conductors and connectors compared to a PCB. Aligning those dielets with micrometer precision would seem to require equipment out of reach for the hobbyist. And then bonding them, while they don't use solder but rather temperature and pressure, again with such small connectors I guess the line between bonding and destroying the thing is very very fine. Again requiring specialized and presumably expensive equipment.

</comment></comment><comment><USER26> Does anyone know how this compares with AMD's Infinity Fabric? How is it similar or different from it?

<comment><USER27> Infinity fabric is a software thing (a way to distribute information over a buss similar to pci-e) where as this is a physical piece of hardware that electrically passes the signals between 2 chips.

I see no reason why infinity fabric could not be routed through a silicon interconnect, but it would be wasteful. The whole point of silicon interconnects that the hardware protocols like pci-e are no longer necessary and can use much lower power/cheaper ways to transfer data.

</comment></comment><comment><USER28> It seems like promising technology but the cost of making these chiplets must outweigh their benefits.

</comment><comment><USER29> I think it should be called Silicon Fabricated Interconnect so we can just call it Si-Fi...

</comment><comment><USER30> Cyberpunk 2077, here we come!

</comment><comment><USER31> Gloodbye customizability and modularity, from a user standpoint.

I guess Apple will hire them pretty soon.

</comment><comment><USER32> Will this increase the number of bit flips from cosmic rays?

<comment><USER33> All the cool kids these days are _wearing_ nodeJS , not just writing it!

</comment></comment><comment><USER34> It sounds like hardware side of computer science is rediscovering the UNIX philosophy - each unit does one thing, well, with standardized interfaces.

</comment><comment><USER35> >pack dozens of servers' worth of computing capability onto a dinner-plate- size wafer of silicon.

Congratulations on the insurance money from your building burning to the ground.</comment>


Show HN: Easy music listening website, with radio and playlist support. - <AUTHOR> http://tunezap.com

<comment><AUTHOR> We start this project for fun one month ago and we would like to share it to get some feedbacks.

The concept is to search for an artist or a song, and get the most relevant result. If you want more results, simply press enter again! Then we also add the possibility to start a radio related to the current artist or related to a genre ifwe couldn't find any relations for the artist. Once you have your playlist, you can save it and share it easily with the URL, no login required...

See if you like it, and give us any feedback

</comment><comment><USER2> seems pretty cool, one nice feature could be the login (with facebook maybe?), and the possibility to save favorite songs (grooveshark style)

<comment><AUTHOR> Thanks :D. Yes the login feature is one of our main priority. At the beginning, we didn't want to force the login to save and use it. But Yes, the login would be a really nice improvement, even if we keep the current features without login. ;)</comment></comment>


Castle Game Engine 6.4 released – physics, iOS services, shader pipeline upgrade - <AUTHOR> https://castle-engine.sourceforge.io/wp/2018/01/21/castle-game-engine-6-4-release-physics-ios-services-shader-pipeline-upgrade-big-api-improvements-vectors-transform-and-more/ <comment><USER2> it is written in pascal ... interesting

<comment><USER3> ... and hosted on sourceforge, of all places!</comment></comment>


Create a Google Talk bot with Node.js: Part One - <AUTHOR> http://simonholywell.com/post/2013/02/create-a-node-js-google-talk-bot-pt1.html

<comment><USER2> It would be really great if Google supported persistant char rooms like IRC. That would make these kinds of bots really usefully.

<comment><USER3> xmpp supports chatrooms! see <https://gist.github.com/powdahound/940969> for an example similar to the parent link

</comment></comment><comment><USER4> While 'const' is cute, it's not a standard feature:

"The current implementation of const is a Mozilla-specific extension and is not part of ECMAScript 5."

[https://developer.mozilla.org/en- US/docs/JavaScript/Referenc...](https://developer.mozilla.org/en- US/docs/JavaScript/Reference/Statements/const)

</comment><comment><USER5> I have a side project that provides hosted bots: <http://getinstabot.com>. I don't think there's much interest, though.</comment>