Nylas N1 – extensible open-source mail client - <AUTHOR> https://www.nylas.com/N1 <comment><USER2> Beware: from what I understood, this isn't a self-sufficient MUA in traditional sense, it's a thin client that offloads the interaction with the actual mail server to a remote system. That said, the credentials to access the mailbox are entrusted to a third party.

> See the README for full instructions on setting up the sync engine, API, and > N1 on your local machine.

Sadly, there is no instructions in the linked document yet.

I wonder, can the sync engine and whatever else be bundled with a client, so it'd be a self-sufficient standalone piece of software?

<comment><USER3> Here's what you need to install to run the entire stack locally: [https://github.com/nylas/sync-engine](https://github.com/nylas/sync-engine)

Sorry-- launch day craziness :) More docs to follow soon!

<comment><USER4> Why do I need to run a whole stack for a mail client? It's a mail client! Why is everything JS web services :(

<comment><USER2> At least half of the blame should be not on them. IMAP doesn't know a thing about what happened to email in last 10 years (few minor exceptions apply).

They're merely implementing their own means to access email in convenient and modern way. Say, IMAP has no labels[1] or contacts[2] (and many other things) - there are proprietary extensions, MS Exchange being the most famous one, but they're... proprietary. And given that proprietary implementations differ, it makes sense to create an unifying wrapper.

And JS apps and web services are just an approach that's trendy today. Personally, I don't like it either, but can't blame for going with the flow. Especially since it's a business (and going against the flow has costs, both in development and adoption), not a private project where one can do things in a way that just feels right, ignoring anything else.

I believe it would absolutely make sense to bundle the "sync engine" within the mail client, though, to make it standalone. But I understand it's done this way just because there was only the engine (as a service, not a library) at the beginning.

____

[1] [https://nylas.com/docs/#labels](https://nylas.com/docs/#labels)

[2] [https://nylas.com/docs/#contacts](https://nylas.com/docs/#contacts)

<comment><USER5> IMAP actually does have labels. They are called flags. Servers tend to not implement them well at all (sometimes allowing only a handful to exist, and almost never keeping an index for that metadata, meaning that searches by flag are either slow or often not even allowed :/), but that is not the fault of IMAP.

<comment><USER6> Apparently, most sane open source IMAP servers support PERMANENTFLAGS \ * which as I understand it means user-defined flags?:

[http://serverfault.com/questions/115769/which-imap-flags- are...](http://serverfault.com/questions/115769/which-imap-flags-are-reliably- supported-across-most-mail-servers)

I'm not entirely sure what's "happened with email in 10 years"? Search-defined virtual folders?

<comment><USER5> And, FWIW, search defined virtual folder is a client concept and would be trivially implemented over IMAP's incredibly powerful (and I believe I remember being even extensible) search commands, if only IMAP servers tended to provide the right kinds of index to make such queries fast. (I know this, as I was working on a highly scalable and very efficient IMAP server a few years ago that I had to force myself to stop working on as it was too much of a distraction from the things in life that are actually capable of putting food on the table.)

Mark Crispin was actually pretty-damned prescient when it came to IMAP: he believed that client operations should be offloaded to a server that would have much more disk space and CPU than the client, which is exactly the model everyone reaches for today, and thereby designed a thin client protocol that had asynchronous updates baked into its core. A few years ago, he passed away: here is what I wrote at the time about his mission for IMAP and history on the project.

[https://news.ycombinator.com/item?id=4826113](https://news.ycombinator.com/item?id=4826113)

Really, the only thing in IMAP to actively dislike is how the thin client view requires the server to have a "dense" (here I mean the mathematics term, not from the technical spec) numbering of messages the client is modeling in its view (this is the reason opening a large mailbox via Zimbra takes forever, and why many IMAP servers have dumb global locks), but I have come up with some techniques that should allow me to handle that with minimal overhead. Otherwise, with some of the modern extensions in place (QRESYNC, for example), IMAP is pretty damned awesome.

</comment></comment></comment></comment></comment></comment></comment><comment><USER7> I've used the Nylas API for 9 months for my side project iOS email client. It works very well and the team is super responsive. Documentation is clear and complete. It makes it super easy to build any email client.

Eventually though, I decided to stop using it because I'm not confortable with having all my messages stored by "one more" entity in the cloud. Back to good old IMAP with all the pain it brings.

I'm often wondering if such an API could work in a full end to end encrypted mode, i.e. messages would be encrypted as they arrive before they are stored on the server, and only the client would have the key to decrypt them.

<comment><USER8> Engineer from Nylas here: End-to-end encryption is definitely on the roadmap. In the meantime the Sync Engine service that we're currently hosting for the sake of convenience is fully open source. You can run everything yourself on your own machines and still have the modern RESTful API that Nylas exposes. No more IMAP!!

There's documentation about how to get that setup with N1 here: [https://github.com/nylas/N1/blob/master/CONTRIBUTING.md](https://github.com/nylas/N1/blob/master/CONTRIBUTING.md)

There's much more on the Sync Engine page here: [https://github.com/nylas/sync-engine](https://github.com/nylas/sync-engine)

<comment><USER9> > No more IMAP!!

Why is that a big deal? I've worked with IMAP, and it's not that bad.

<comment><USER10> > I've worked with IMAP, and it's not that bad.

I don't believe you.

Every email account provider is different in horrible, horrible ways.

</comment></comment></comment></comment><comment><USER3> Hi HN-- Michael from Nylas here. We're super excited about this launch, and happy to answer questions about N1, including plugin architecture, design, features, etc.

A few Nylanauts will likely hang out in this thread today. Would love to hear what folks think! :)

<comment><USER11> How "natively" does this deal with GMail? My experience with most non-google mail clients is that the GMail support is almost always broken or ugly in some way. Does it archive correctly? Label correct? Does it make use of GMail's IMAP extensions for doing the right things? If not, how does it work? What level of integration into the GMail workflow is there? I have for a long time desired a good desktop client for GMail, but all of them rely on an unacceptably bad mapping between IMAP and GMail idioms that I still have not found an acceptable one. How does N1 differ?

<comment><USER3> Yep, it does all the right things. All the "heavy lifting" here is done by the Nylas sync engine which works natively with Gmail labels, actions, search, etc. and those same semantics are exposed in N1.

We've spent almost 2 years building the sync technology, so it's very stable and flexible. You can check out the IMAP code here: [https://github.com/nylas/sync-engine](https://github.com/nylas/sync-engine)

<comment><USER12> What about the aspects of Gmail that less obviously map onto things a client should do?

Can it use Gmail's classification of e-mails as "important", "not important", "updates", or "promotional"?

<comment><USER13> I don't think GMail exposes the "primary/social/forums/promotional" classification (which they call categories). However, there's a workaround: in the GMail web interface, type "category:promotions" (for example) in the top search bar, and an option will appear to create a filter that automatically applies a label to all emails matching this condition. (in this case we can make a "promotions" label.)

Then your label will appear in your desktop client. Kind of a hack but I did this for thunderbird and it works.

As for making a plugin that handles this automatically - I'm not sure it's even possible, but I'd love to be proven wrong!

On second thought, the initial setup doesn't really need a plugin so much as the way categories are _displayed_. Especially cool would be to have them as tabs like in the web interface: once you get used to them, you find them sorely missing in desktop clients. I always find it weird to have my personal, social, and "promotions" emails brutally mixed together.

</comment></comment></comment></comment></comment><comment><USER14> I don't quite understand how the business model of the Nylas platform that this client depends on works.

Since it provides up to 10 accounts for free, it looks like that end-users (for whom 10 accounts are more then enough) are not supposed to be the paying customers, but rather other companies that want to integrate with Gmail, etc.

But... does this mean that these companies are supposed to encourage the user to connect their e-mail accounts to the company's Nylas platform account, thus giving Nylas all the user's e-mails and weakening e-mail privacy even more?

Or is the business model something else...?

<comment><USER15> We're not paying for it, so we can only assume that we (or more likely, all of our emails) are actually the product here.

<comment><USER16> Or it could become an e-mail version of the google play store.

</comment></comment></comment><comment><USER17> Did anyone else get an email from Nylas that they never signed up for? I don't recall ever signing up for newsletters, so I'm curious as to how I heard about this in my inbox instead of on HN. Kind of annoying.

<comment><USER3> We used to be called Inbox (www.inboxapp.com) but we changed the name last year (after Google shipped a product with the same name). You may have signed up then! Lots and lots of folks from HN certainly did. :)

<comment><USER18> I got the email this morning and was very confused as well, this makes sense. Maybe in the next email should write "Nylas (formerly inboxapp.com)", otherwise I'd imagine your unsubscribe rate is going to be very high.

<comment><USER17> Yep, I already unsubscribed.

</comment></comment></comment></comment><comment><USER19> Google has all my data, and that allows them to build incredible features for me, like Google Now and Inbox's automatic parsing of travel and event emails.

I'd rather have all my data myself so I could pick great features from anyone who makes them. Nylas sounds like a part of the puzzle to make that happen. I wish you guys the best of luck.

<comment><USER2> If you want to have your data yourself, self-hosted mail system is a way to go.

In terms of privacy, the experience is good. I must warn, though, it's quite unpleasant in terms of dancing pigs and bunnies[1]. You won't get anything fancy. The age of protocol development had passed long ago and mail protocols (IMAP) aren't evolving anymore. Almost all the modern stuff is proprietary to services and their APIs and clients.

This limitation doesn't apply to mail filtering and automated parsing, though. Mail filters and processing for self-hosted email is way more powerful one can normally get with third-party services.

[1] [https://en.wikipedia.org/wiki/Dancing_pigs](https://en.wikipedia.org/wiki/Dancing_pigs)

<comment><USER20> What do you mean by mail filters and processing? Is there anything fun I can get, may you point a few links for further reading?

It happens that I'm right in the middle of configuring my own server. I've got only postfix and dovecot for now, nothing fancy yet.

<comment><USER2> Dovecot has great support for Sieve, which is a neat and fairly powerful scripting language for mail filtering: [http://wiki2.dovecot.org/Pigeonhole/Sieve](http://wiki2.dovecot.org/Pigeonhole/Sieve)

If this is not powerful enough, you can make sieve plugin invoke external program and pass it MIME-encoded email message for further processing. This way your server can, for example, add events to your calendar software or do the accounting based on receipt emails (and I forward my SMS to my IMAP server too)

Before Sieve I've used tools like procmail ([http://tldp.org/LDP/LG/issue14/procmail.html](http://tldp.org/LDP/LG/issue14/procmail.html)), although I'm currently only using Dovecot/Sieve setup for my own mail. Some servers I've configured, for example a DIY SMS gateway at the company I've worked for, use just postfix+procmail (+ custom bash and Python scripts).

As for the spam filtering, I've had a good experience with rspamd ([https://rspamd.com/](https://rspamd.com/)), which is light on resources, integrates with Postfix quite nicely, usable out-of-box and is scriptable with Lua.

Hope those few pointers would help.

<comment><USER20> Sorry it took a while to reply.

Thanks a lot for recommending Sieve, I really mean this. There isn't even a single mention of it on the myriad of the half-baked 'how to setup isp-mail for personal use' blogspam I keep stumbling into when googling issues.

It looks like a great tool. Now I can probably have 'n' junk mailboxes with varying personal filters (always wanted this).

</comment></comment></comment></comment></comment><comment><USER21> First, we had SquirrelMail and its ilk.

Then, Roundcube became the standard.

Their dominance is being eroded by Mailpile, RainLoop, and Nylas.

Around the edges, we have Peps[1], Mailr[2] & Kite[3] which may all someday take off.

Zimbra and the well known groupware vendors (OnlyOffice, Horde, Citadel, Kolab) are competing in more-or-less the same space.

Probably dozens of other projects that are on the same level that I have never even heard of. I would love some sort of comparison, even a biased one written by the respective teams. Anyone have useful links?

[1] [https://github.com/MLstate/PEPS](https://github.com/MLstate/PEPS) [2] [http://pusto.org/en/mailr/](http://pusto.org/en/mailr/) [3] [http://khamidou.github.io/kite/](http://khamidou.github.io/kite/)

<comment><USER3> Karim, who built Kite a few years ago, is actually now an engineer at Nylas :)

[https://nylas.com/about](https://nylas.com/about)

</comment></comment><comment><USER22> Is it too much to request a modern mail client that supports threads in the UI?

I find it hard to follow conversations without some form of visual indicator of who replied to what within a thread.

<comment><USER3> Yeah, it's a tough design decision (assuming you mean nested threads HN- style).

We may add something like that soon. I agree that it's superior in some situations. But most folks are familiar with Gmail, so we opted for linear threading for the first release.

Would love to see a plugin (or several) that explore new thread UIs! Here are a few you can look at to get started: [https://nylas.com/n1/examples](https://nylas.com/n1/examples)

</comment></comment><comment><USER23> I'm super excited about this. I'd love to see a serious collection of apps/extensions for the platform. I love the ecosystem around gmail, but I despise using their web-ui. I'd love to have the flexibility baked into a modern app. I've tried every email app and none of them cut it. They start off promising, but quickly degrade into feature-bloat (Airmail) or development is discontinued (Sparrow, Mailbox?).

</comment><comment><USER24> Is JMAP [1] support on the roadmap? Once email providers (namely Fastmail, who wrote the spec) start supporting it, of course.

[1] [http://jmap.io/](http://jmap.io/)

<comment><USER25> We'll consider JMAP support if it reaches widespread adoption. For now, it wouldn't add much value, and we have a lot to build!

</comment></comment><comment><USER26> Plugins via JS ... another sad day for GNU Guile. ;-)

</comment><comment><USER11> Source: [https://github.com/nylas/n1](https://github.com/nylas/n1)

</comment><comment><USER27> Damn. Was hoping I could just build it myself, but the bootstrap script is broken.

\---> Cleaning apm via `apm clean`

dyld: lazy symbol binding failed: Symbol not found: _node_module_register Referenced from: /Users/karl/tmp/N1/apm/node_modules/atom-package- manager/node_modules/keytar/build/Release/keytar.node Expected in: dynamic lookup

dyld: Symbol not found: _node_module_register Referenced from: /Users/karl/tmp/N1/apm/node_modules/atom-package- manager/node_modules/keytar/build/Release/keytar.node Expected in: dynamic lookup

/Users/karl/tmp/N1/apm/node_modules/atom-package-manager/bin/apm: line 28: 27072 Trace/BPT trap: 5 "$binDir/$nodeBin" \--harmony_collections "$binDir/../lib/cli.js" "$@"

<comment><USER28> Hey kstenerud,

Thanks for checking out N1! I work on the client. Unfortunately `keytar` is a bit of a nasty module. Try using `nvm` to run script/bootstrap with Node 10.x. I think this might be the issue you're seeing: [https://github.com/atom/apm/issues/195](https://github.com/atom/apm/issues/195).

If you run into anything else, feel free to ping us on the Nylas Community slack channel ([http://slack-invite.nylas.com/](http://slack- invite.nylas.com/))

</comment></comment><comment><USER29> Terrific job, congrats to all the team! Curious to know why you choose MySQL and not PostgreSQL.

<comment><USER3> Honestly, the main reason is that I previously worked at Dropbox and knew we could reliably throw ~petabytes at MySQL. Or at the very least, when we started scaling I could call my friends from Dropbox and Facebook to help out. :)

Most of our complexity is in the sync later, so we spend more time tuning our Python sync server. For example, we wrote a custom statistical profiler: [https://nylas.com/blog/performance](https://nylas.com/blog/performance)

<comment><USER30> How hard would it be to create a backend for PostgreSQL?

I'm currently in doubt to move to either Mailpile or your platform on my personal server. However, PostgreSQL would be a big plus for your platform, since I don't have any experience with MySQL in recent years, and I rather do not run it on my VPS just for mail.

<comment><USER25> We saw some folks start working on PostgreSQL support here: [https://github.com/nylas/sync-engine/pull/132](https://github.com/nylas/sync- engine/pull/132)

It's not something we're likely to support officially in the near future since we don't run PostgreSQL and don't have the ability to test it well with production loads, but it'd be neat to see a working community fork.

</comment></comment></comment></comment><comment><USER31> Finally! Always wanted something like this! It looks beautiful! Sorry if this sounds to flimsy but how an app looks is probably a huge factor for me to consider using it. This always pushes me away from open source because they aren't designed (visually) as properly as their proprietory counterparts. Love this project!

<comment><USER3> Totally agree-- thanks for checking it out! :)

</comment></comment><comment><USER32> Mutt FTW :D

<comment><USER25> I used mutt until I started this company, so I couldn't agree more. :) Reading HTML emails piped to w3m gets kind of old after a while though!

<comment><USER33> It gets about as old as mutt, one might even say ;)

</comment></comment></comment><comment><USER3> Hey folks-- sorry about the invite system. I know we sent out download links, but it turns out way more folks have signed up than we originally planned.

Relatedly, if any experienced devops/sre folks are looking for a new job, please ping me. ;) firstname.lastname@example.com

</comment><comment><USER34> I thought this looked nice until I saw that it's not an email client at all, it's an interface to a backend service. Sure, you can get the backend and run it yourself but who wants to do that. Pity, it looked nice.

</comment><comment><USER35> Now this is big bold news! Kudos guys! I'm extremely excited!

</comment><comment><USER36> Congrats, this is great! What's the Nylas story for mobile?

<comment><USER3> stay tuned ;)

</comment></comment><comment><USER37> I love this and want to try it, but I find it strange that they emailed me to tell me about it being available, when I can't actually use it without an invite code.

<comment><USER3> It was available when we sent out the newsletter. Turns out we got a bigger response than we were expecting!

Hopefully invites will go out over the next few days. Thanks for your patience.

</comment></comment><comment><USER38> The only feature I really care about these days is automatically grouping "important" and "non-important" emails (and notifying on important).

<comment><USER3> We expose Gmail's Important and non-Important via labels in the UI. And you can write your own plugin to sort mail based on any heuristics you want!

</comment></comment><comment><USER39> Interested...hesitant though with the idea of giving up more access to my private files. Signed up, looks like I hit a waitlist.

</comment><comment><USER40> Tried the documentation for setting up the sync-engine, I must say its bit confusing. Can we install on say, on a AWS VM ?

<comment><USER25> You can, but remember the sync engine doesn't provide any authentication layer by default, since people use it in so many different ways. You'll want to run it proxied behind some sort of authentication service. (With AWS, you can do this with different subnets via VPC.)

</comment></comment><comment><USER41> Congratulations and thanks, had been looking for one for eons now. Looks promising!

</comment><comment><USER42> Hi, do you plan on putting together a pkgbuild for arch linux based systems?

<comment><USER25> I don't expect that we'll have time to put this together officially very soon. If you'd like to help though, the best way would be to figure out how to get N1 building on arch from the open source repo!

<comment><USER43> Here's a PKGBUILD that works for me: [https://gist.github.com/tylermenezes/c1934bf72e4db8816690](https://gist.github.com/tylermenezes/c1934bf72e4db8816690)

I can't fully test it yet since I don't have an invite. It starts up, though.

</comment></comment></comment><comment><USER44> This looks like a fantastic roundcube or rainloop competitor. Thank you!

</comment><comment><USER45> Any hope for an RPM or Yum repo for us Fedora users?

<comment><USER25> Yep, the only reason we didn't have one for launch is a lack of time. :) You want to help? First step is making sure `script/grunt mkrpm` works from [https://github.com/nylas/N1](https://github.com/nylas/N1)!

</comment></comment><comment><USER46> this is INCREDIBLY cool - have been waiting for this for a long time. Way to go team! nicely done!

</comment><comment><USER47> Kind of reminds me of Geary.

</comment><comment><USER48> I'd pay for this....

</comment><comment><USER49> I've been using Mailbox by Dropbox for a while and it's still very rough, not even beta quality by Google standards.

Most frustrating is that search doesn't work at all.

I have multiple accounts, but if I didn't I would still prefer the gmail web interface to any thick client app I've used (so far).</comment>


Who Signs Up to Fight? Makeup of U.S. Recruits Shows Glaring Disparity - <AUTHOR> https://www.nytimes.com/2020/01/10/us/military-enlistment.html <comment><USER2> As usual, the HN crowd is comfortably outside the impact zone of military recruiting and despite being submitted multiple times, the basic responsibilities of citizenship command no discussion.</comment>


MeiliSearch: Zero-config alternative to Elasticsearch, made in Rust - <AUTHOR> https://github.com/meilisearch/MeiliSearch <comment><USER2> I'm impressed.

I have a database with 15k documents, each with around 70 pages of text, HTML formatted.

I'm using ElasticSearch currently, with the Searchkick gem.

30 min playing with MeiliSearch. So far:

\- Blazing fast to index, like 10x more performant than using ElasticSearch / Searchkick;

\- Blazing fast to search, at least 3x faster in all my random tests so far;

\- Literally zero config;

\- Uses 140MB of RAM currently, while in my experience ElasticSearch would crash with anything less than 1GB, and needs at least 1.5GB to be usable in production.

<comment><USER2> Since this got upvoted and I see the devs are replying to questions, here are some! I'm also going to point how ElasticSearch works for comparison.

\- The docs state that `Only a single filter is supported in a query`. This is kind of a dealbreaker for my use case, since I need at least a `user_id` and a `status` filter. ElasticSearch can work with multiple filters. Also, don't understand why you call it `filters` instead of `filter` then. Are multiple filters in the roadmap?

\- My search UI has a sort by `<select>`, where you can choose, for instance, `last updated asc` or `last updated desc`, amongst others. In my understanding, that would be cumbersome with MeiliSearch, since it would require (1) a settings change to alter the ranking rules order beforehand [0], which would not even work in production due to race conditions or (2) maintain multiple indexes each with a pre-defined ranking rule order and switch between them depending on the UI criteria?

\- As an extension of the last question, I see that a lot of what you call "search settings" are considered by ElasticSearch query parameters. For instance, I can easily query ES for the title or description fields just by setting that as a parameter. In MeiliSearch that would require a change in the index settings beforehand, right?

PS: The docs, specially in the Ruby SDK, could use some work in the filters section. It took me a while to understand I should pass a string, like index.search("query", filters: "user_id:3"). I was trying a hash like `filters: { user_id: 3 }`.

[0] [https://docs.meilisearch.com/references/ranking_rules.html#u...](https://docs.meilisearch.com/references/ranking_rules.html#update- ranking-rules)

<comment><AUTHOR> Hi, many answers to these questions. But first, I'll put you on the link to the public roadmap. A lot of the stuff we're working on is in there. If you need/love a feature, please add a heart emoji on it. [https://github.com/orgs/meilisearch/projects/2](https://github.com/orgs/meilisearch/projects/2)

\- Currently, we only support single filters. The multiple filters option is coming soon. [https://github.com/meilisearch/MeiliSearch/issues/425](https://github.com/meilisearch/MeiliSearch/issues/425)

\- Custom ranking rules on the fly is something imaginable on our solution. We didn't do it yet because it complexifies the search query parameters. We are waiting for feedback like yours to implement this kind of feature.

\- To return only the field you need, it's already possible during the search [https://docs.meilisearch.com/guides/advanced_guides/search_p...](https://docs.meilisearch.com/guides/advanced_guides/search_parameters.html#attributes- to-retrieve). To restrict attributes to search in during the query. We had this feature on a previous version. But like the last answer, no one used it, and it complexifies the search query.

</comment></comment></comment><comment><USER3> I know the project doesn't claim it, but the title somewhat implies this: I honestly don't understand people claiming ElasticSearch is hard to operate, especially not at small scales. If anything, ElasticSearch for me has been one of the easiest pieces of infrastructure to operate, for me pretty much "zero- config". Let me elaborate: You can run ElasticSearch via Docker command-line, if you want a cluster you just supply IPs of the other nodes. Then you start indexing documents with simple HTTP calls. You can add or remove nodes at any time and don't have to do anything but to start another ElasticSearch instance. If you run out of space or performance just start another node. Everything needed for management, indexing, search is available through HTTP APIs, no tools needed.

Clustered ElasticSearch has been rock-solid for me and I've used it in anger many times. The level of maintenance needed is close to zero, both initially and long-term. Compare that with the abysmal experience of setting up a sharded MongoDB cluster for example...

Please enlighten me how ElasticSearch is "a lot of work to operate" (heard that one multiple times), and what you're comparing it to.

<comment><USER4> I've been bitten by elasticsearch twice in my career, and I've seen others bitten by it as well. Once you put it in production, you can't just run it from docker on your workstation. You have to set up a cluster with enough capacity for whatever load you're going to throw at it, gracefully handle failures, updates, scaling up as load increases, etc.

There are so many switches and dials to tune, and unless you really learn it in depth, you won't know which ones you need. It's difficult to even determine what hardware requirements you have. And it's a hard sell to tell your business guys "I think elasticsearch will work better if we give it more... CPU? Memory? Disk speed? I'm not really sure." and can't provide any concrete metrics to back that up.

Another place where footguns abound is upgrading from one version to another, _especially_ if you've got plugins installed. There are tricks that you have to learn the hard way.

At this point, I think long and hard before reaching for a solution like elasticsearch. If I've got a DBA whose entire job it is to master the tech and wield it expertly, that's one thing. But if I'm part of an early stage startup, I just can't justify the lost time and potential for catastrophe.

<comment><USER5> > Once you put it in production, you can't just run it from docker on your > workstation.

But that's true for any data store. This isn't any different. Nor is an RDBMS. They all need HA/replication. And that is rarely trivial.

Honestly, I think this is why managed/hosted solutions (AWS RDS for example) are so popular - they remove a large part of the complexity for you.

<comment><USER6> Not all data stores. You can go quite far with an out of the box Redis instance or even PostgreSQL. No fiddling needed unless you are in triple digit QPS ranges.

</comment></comment></comment></comment><comment><USER7> I wanted to mention Sonic [1] as another lightweight document indexing alternative written in rust, when I found MeiliSearch to provide a thoughtful comparison page [2]

[1] [https://github.com/valeriansaliou/sonic](https://github.com/valeriansaliou/sonic)

[2] [https://docs.meilisearch.com/resources/comparison_to_alterna...](https://docs.meilisearch.com/resources/comparison_to_alternatives.html#comparisons)

</comment><comment><USER8> Mostly "made in Rust", but from the github readme[0] "MeiliSearch uses LMDB as the internal key-value store. The key-value store allows us to handle updates and queries with small memory and CPU overheads."; so a lot of the credit goes to LMDB, and safety implied by "made in Rust" is not, in fact, guaranteed.

Not that I'm complaining - I love LMDB, and it's been rock solid and bug free in my experience (thanks, Howard!) - but it's low level C, not rust, and if you expect the certainty that Rust provides w.r.t to security, race conditions and leaks, be aware that you are not completely getting it.

But other than that: Thanks! This looks like a great project!

[0] [https://github.com/meilisearch/MeiliSearch#how-it- works](https://github.com/meilisearch/MeiliSearch#how-it-works)

<comment><USER9> True, but there are significant components in pure Rust, such as `fst` (full disclaimer, I wrote it). Which is written in purely safe Rust.

> and safety implied by "made in Rust" is not, in fact, guaranteed

Just about every Rust program depends on some C code, usually at least in the form of a libc. So you could lodge this criticism against almost every Rust project.

> and if you expect the certainty that Rust provides w.r.t to security, race > conditions and leaks

Rust's safety story covers neither race conditions nor leaks.

<comment><USER10> > Rust's safety story covers neither race conditions nor leaks.

It covers a type of race condition, namely unsynchronized concurrent access to memory.

<comment><USER9> Data races and race conditions are orthogonal, according to some: [https://blog.regehr.org/archives/490](https://blog.regehr.org/archives/490)

I think you've disagreed with this in the past, and I don't know how to resolve that. But certainly, I think we can agree that saying that Rust's safety story prevents race conditions is, at minimum, very imprecise.

<comment><USER10> Oops, I wasn't trying to reopen an argument. I didn't recall us having discussed it before (still don't, but I forget things easily).

And yeah, I'd agree with your last sentence.

<comment><USER9> Ah yeah, it could have been someone else... Not sure. It was a while ago. Anyway, I don't personally have a strong opinion here on definitions here. (I'm not qualified to.)

</comment></comment></comment></comment></comment></comment><comment><USER11> The goal of ElasticSearch, I always thought, was that it scales horizontally and can handle the loss of multiple nodes without availability- or data-loss. It's interesting to build a single-server replacement, and this can likely work for many use-cases, but it's definitely a different approach from ElasticSearch itself.

<comment><USER12> Replication for MeiliSearch is on its way :) The main differentiator is that MeiliSearch algorithms are made for end-user search not for complex queries. MeiliSearch focus on site search or app search, not analytics on hyper large datasets

<comment><USER13> what is the size of the largest dataset that you have indexed with MeiliSearch?

<comment><USER12> We are currently working with this dataset: [https://data.discogs.com/?prefix=data/2020/](https://data.discogs.com/?prefix=data/2020/)

It's a dataset of 107M songs, 7.6 Gb of compressed files which represents 250 Gb of disk usage by MeiliSearch. We are indexing the release, song and artists names.

We also work with a dataset of 2M cities that we can index in less than 2 minutes when the db uses 3 shards.

</comment></comment></comment></comment><comment><USER14> The real power of Elasticsearch for me is the ability to filter logs by:

1\. exact match this nested JSON field (with support for lists of values)

2\. negative match this nested JSON field (with support for lists of values)

coupled with the ability to filter by "timeframe", then pump it through to visualizations (tables/graphs) in Kibana

MeiliSearch would be cool if it spoke the API Kibana expects from Elasticsearch

<comment><USER15> If only one could set up Elasticsearch and Kibana using infrastructure-as-code (IaC). I spent several days trying and still haven't succeeded. Elasticsearch config is full of foot-guns.

There are tons of easy setup examples but they lack access control and encryption. All of my servers must write logs. When one of them gets cracked, the attacker must not be able to read all the other servers' logs and steal all the PII. An attacker can use an ARP attack to MITM server connections to Elasticsearch. Without encryption, that attack yields all the PII.

I hope Meilisearch can someday help fill this gap in the free DevOps toolset.

</comment></comment><comment><USER16> ok I just looked through things a bit but the phrase 0 config worries me - first off I could conceivably run ElasticSearch with 0 configuration but then it needs to make decisions as to what types things are, and how things should be analyzed, and sometimes those decisions are not what I want.

Often ElasticSearch makes a mistake in typing because the programmer has made a mistake in data format, if you fixed that mistake your data would now not fit the format that ElasticSearch has chosen for it (actually don't know if this is still a problem because it has been years since I have ran without all my fields being mapped first) but actually don't see how it couldn't be a problem.

so theoretically if you didn't want to go through the trouble of defining a wrapping you could just reindex all your data fixed in such a way that ElasticSearch will choose a better type for individual fields but why would you do this?

And I mean what does MelliSearch do? I wonder - because looking through this code here [https://github.com/meilisearch/MeiliSearch/blob/master/meili...](https://github.com/meilisearch/MeiliSearch/blob/master/meilisearch- schema/src/fields_map.rs) (and not being a rust guy my understanding of it is probably off) but it seems like maybe it is no configuration because it expects you to follow its semantics. Which to be fair lots of things do, at the base level, everything has a title, description, date.

But if I have a domain with different or probably more advanced semantics what happens?

Search Engines are generally configurable because you want to add other fields and rank hits in those fields higher than other things, or maybe do a specific search that only targets those fields - like say Brands based search.

on preview: lots of other people with similar views it seems, I got maybe a bit ranty just because the title sets me off when it just is so wrong it even seems like lying.

</comment><comment><USER17> Awesome, glad to see all the competition in the search space now. There are other projects like Sonic, Tantivy, Toshi and more that have more functionality if you need alternatives.

Here's a public list of search projects (in rust, c, go): [https://gist.github.com/manigandham/58320ddb24fed654b57b4ba2...](https://gist.github.com/manigandham/58320ddb24fed654b57b4ba22aceae25)

<comment><USER18> Are there any that fit the log searching use case, apart from loki which doesn't do full text searching?

<comment><USER19> I think vector[0] does what you are asking for.

[0] [https://github.com/timberio/vector](https://github.com/timberio/vector)

<comment><USER17> Vector is a log/event forwarding system. It moves data between sources and sinks with optional transforms. It doesn't store or search it.

</comment></comment></comment></comment><comment><USER20> Hardly an "alternative to Elastic search" if only because the later is scalable beyond a single machine.

This overhyped description coupled with on-by-default analytics suggests to me MeiliSearch should be dismissed regardless of potential usefulness or technical merit.

<comment><USER21> The analytics seem pretty benign.

"We send events to our Amplitude instance to be aware of the number of people who use MeiliSearch. We only send the platform on which the server runs once by day. No other information is sent. If you do not want us to send events, you can disable these analytics by using the MEILI_NO_ANALYTICS env variable."

<comment><USER20> The practice itself is malignant, either explicitly ask upon first run or require a MEILI_YES_ANALYTICS env variable to enable it.

<comment><USER22> That would require configuration. This is zero-config.

<comment><USER23> It'd still be zero-config to provide it's primary function. I don't think anyone would say anything against MeiliSearch or not consider it zero-config had they decided to enable analytics off an env var rather than having analytics be sent by default.

<comment><AUTHOR> I would like to clarify that by analytics we are only talking about 1 ping per day that sends a hash that allows us to uniquely identify a user. The privacy of the users is kept. It just serves us to know if our work is being used.

<comment><USER20> > I would like to clarify that by analytics we are only talking about 1 ping > per day that sends a hash that allows us to uniquely identify a user.

This is already pretty invasive - it discloses activity, number of machines deployed, IP address which identifies location and often organizations and individuals (and which is considered protected personal data per the GDPR afaik).

> The privacy of the users is kept.

No it isn't, see above - even as the authors you don't get to decide what data does or doesn't infringe upon the users privacy.

> It just serves us to know if our work is being used.

This is irrelevant, if you want to condition the use of your work on being let known where and how it is being used then license it accordingly and abide by the applicable laws.

</comment></comment></comment></comment></comment></comment></comment><comment><USER24> Nice. This looks promising. Very clean API. I like the focus on a narrow use case.

Do you have any information on security topics like using TLS, client authentication, etc?

<comment><USER25> Currently we think this kind of security can be enabled by a simple nginx setup, allowing autorefesh of certificates easily (e.g. certbot). But in the future we will probably handle that in the engine itself.

<comment><USER26> I was thinking it might be nice to be able to have an HMACed token with an expiry as an option - so e.g. my main http-serving thing could provide one of those to allow the frontend to read for a bit but kick the user off after half an hour or whatever if the token isn't refreshed.

I've no issue with offloading SSL to a different process though, I tend to prefer doing that anyway a lot of the time.

<comment><USER25> I understand what you mean but is it for a specific usage of a search engine? I was thinking that this kind of time-restricted tokens could also be managed by the nginx instance, our engine doesn't support that for the time being.

<comment><USER26> I _can_ make the nginx instance do that.

Was just thinking for "simplest possible deployment" it would be nice to be able to have clients hit the meili instance basically directly to take maximum advantage of the speed.

Note that I'm not saying "this should be priority 1" or anything, I'm already thinking about how to configure nginx to handle the hmac crap if I try meili out :)

</comment></comment></comment></comment></comment><comment><USER27> MeiliSearch appears to be more of an alternative to Lucene than it is to Elasticsearch. Lucene is the search engine that runs on a single instance; ES is the horizontally-scalable distribution and aggregation layer atop the instances. Absent a similar aggregation layer, MeiliSearch isn't "elastic" as the comparison implies.

<comment><USER12> Actually Lucene is the library for search that Elastic uses under the hood. Lucene does not provide any HTTP API, which Elastic does. Before using Lucene, you have to build the interface around it.

In this way MeiliSearch is comparable to ES, especially for site search and app search working out of the box as standard with its http api.

MeiliSearch does not offer distribution yet, but it is something the team is working on :)

<comment><USER27> My concern is that by comparing it to Elasticsearch, you implicitly minimize the amount of engineering effort required to go from single-node to a distributed system. It is a non-trivial exercise that you will undoubtedly realize once you get into the dirty details.

</comment></comment></comment><comment><USER28> Looks pretty good. The single filter approach is restrictive though.

We're currently leaning towards Manticore Search[1], which is a fork of Sphinx Search[2].

[1] [https://manticoresearch.com](https://manticoresearch.com) [2] [http://sphinxsearch.com](http://sphinxsearch.com)

<comment><AUTHOR> We are working on multi filters and faceting. [https://github.com/meilisearch/MeiliSearch/issues/424](https://github.com/meilisearch/MeiliSearch/issues/424) [https://github.com/meilisearch/MeiliSearch/issues/425](https://github.com/meilisearch/MeiliSearch/issues/425)

</comment></comment><comment><USER29> While this might be an alternative for that one specific use case (search bar), it does not feel like a viable alternative to ES. I am sure it is great at that specific case, and don't want to knock them on that. But, I have never used ES for a simple search like they are. when I use ES, I want to store billions of records redundantly and search them by text, time, and/or location. And then create visualizations with the results.

When I first read the title I thought it might be a Rust based Lucene engine or something, and thought that would be pretty cool. Though no idea how that would work. On its own, this is a pretty nifty little tool, however I think the framing as an ES alternative is what feels wrong to me, and apparently others in the comments as well.

<comment><USER30> [https://github.com/tantivy-search/tantivy](https://github.com/tantivy- search/tantivy) is a Rust based Lucene-alike.

</comment></comment><comment><USER31> Wow to see this popup is strange as I was just implementing this yesterday.

It is blindingly fast and easy to setup.

</comment><comment><USER15> > MeiliSearch can serve multiple indexes, with different kinds of documents, > therefore, it is required to create the index before sending documents to > it.

[https://github.com/meilisearch/MeiliSearch#create-an- index-a...](https://github.com/meilisearch/MeiliSearch#create-an-index-and- upload-some-documents)

Indexes are config. This is not really zero-config if you require API calls before it can receive data.

Also, there's nothing about TLS or access control. These will be required for any production deployment. At the minimum, let us specify a TLS key.pem and cert.pem file and create write-only and read-only access tokens.

</comment><comment><USER32> If you are looking for alternatives, check out Typesense as well:

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

</comment><comment><USER33> How does it compare to Sonic [https://github.com/valeriansaliou/sonic](https://github.com/valeriansaliou/sonic)

</comment><comment><USER34> Are the documents stored on disk or only in memory?

<comment><USER12> We are using LMDB as the key/value store, so the documents are memory-mapped (usually on disk, and in memory when needed)

</comment></comment><comment><USER35> Does anyone know if this supports bulk indexing? My team has a lot of data in S3 in parquet format. (We could change the format to something else if that helps).

It would be really nice to be able to point tools like MeilliSearch or ElasticSearch to a data location and have it index all the data without me writing code to send individual records to the API.

<comment><USER25> This is not something that MeiliSearch supports currently but I am working on making the engine be able to index other formats than JSON, I saw great performance improvements when indexing simple CSVs.

We will probably make MeiliSearch accept different indexable formats (i.e. CSV, JSON, JSON-lines) in a future version.

</comment></comment><comment><USER36> looks really easy to use. will use this instead of resorting to Postgres full text search for my next app(s)

</comment><comment><USER37> Looks promising! Are there any docs coming on a production ready setup? Reading below it looks like you're working on high availability, but even in the single machine scenario, do you have recommendations for persistence, fault tolerance etc?

<comment><USER25> I would say that you must add your own nginx (or else) in front of our HTTP only engine, in term of fault tolerance we are working on high availability.

</comment></comment><comment><USER34> We use Algolia and use the public API keys with search filters encoded so they can only search their data (I.e. account_id:123)

Is there anything similar here? Otherwise all the queries need to go through our servers first to ensure the filter is present.

<comment><USER25> The current API key system is a simple and temporary solution.

We will work on a more feature-full API key system including the one you are talking about. This is on our roadmap IIRC.

</comment></comment><comment><USER38> Sounds more like a potential alternative to Sphinx than Elastic Search.

sphinxsearch.com/

</comment><comment><USER39> Pretty heavy user of ES here, and one cannot compare the two products.

<comment><USER40> What is the rationale for not comparing the two?

<comment><USER41> Only one filter. Very fast limited search. Not great for anything remotely complex like searching with two conditions.

</comment></comment></comment><comment><USER42> Is there already a browser library that can talk to MeiliSearch?

<comment><USER25> Yes, there is, you can find all clients on this documentation page: [https://docs.meilisearch.com/resources/sdks.html](https://docs.meilisearch.com/resources/sdks.html)

Note that we are reworking the js library and there will probably be React integration too!

</comment></comment><comment><USER43> I've never used elasticsearch and only had a brief toy project with Algolia. The demo on the github repo looks awesome.

Can this run on top of my postgres database?

<comment><USER25> To make MeiliSearch expose the documents that are stored in your PostgreSQL (or any other database) you must extract them and store them in our engine using the HTTP API we provide to you. [https://docs.meilisearch.com/references/documents.html#add-o...](https://docs.meilisearch.com/references/documents.html#add- or-replace-documents)

For that you will need to also define the different attributes your document is composed of.

We thought about providing a simple tool to extract the documents from an SQL table into the MeiliSearch directly.

</comment></comment><comment><USER44> Does any tool in this category (This, Elastic, or whatever else) support something like permissions on a per document level?

<comment><USER45> Hey B! Funny seeing you here. I'm now running product at [http://sajari.com](http://sajari.com)

You will find that most tools provide document level permissions to some degree by storing user/group IDs on the document and adding filters to the query. However, it generally requires custom implementation work to integrate it into your systems and prevent spoofing of the filters.

Hope you're doing well!

</comment></comment><comment><USER46> Thanks for including performance metrics right up front!</comment>


Peter Thiel aims to purchase Gawker's archives - <AUTHOR> https://www.washingtonpost.com/news/posteverything/wp/2017/12/12/if-you-miss-gawker-dont-let-peter-thiel-buy-its-archives/?utm_term=.dc77956cc23a <comment><AUTHOR> Is this a case where a quick scrape and an IPFS version might make the whole thing moot? I presume that isn't legal - but is it viable and will it prevent the loss of the material?

Not that I have a strong moral view either way. Just interested.

<comment><USER2> To be fair, if you find yourself taking a strong moral stance opposing Thiel, you're probably in the right.</comment></comment>


Benchling (YC S12) – The Digital Laboratory Notebook for Life Sciences - <AUTHOR> http://a16z.com/2015/04/15/benchling/

<comment><USER2> Benchling's awesome - definitely a well-designed (and much needed!) tool for biologists. They've done a great job with adding new features, from CRISPR design to gel analysis, and their latest electronic lab notebook update is a compelling step towards becoming the central hub for designing, storing and sharing experiments and data.

</comment><comment><USER3> I know nothing about life sciences, but from talking to friends it seems like this is one of those no brainer ideas.

I'm curious to know what some of the adoption/market challenges are - is it hard to get scientists/students to actually use something like this? Why hasn't anyone built this yet? Are there certain technical challenges that haven't yet been addressed?

Congrats to a great team!

<comment><AUTHOR> It is tough - it's a big behavior change to go from paper to electronic records. It's less difficult when scientists are using wikis or Evernote though.

It's been built before. Many times. Mostly for chemists though. However, it's never been done in a way that's integrated with the actual tools scientists use to design experiments and analyze data, so you end up with a bunch of data silos. If you ask a scientist whether they can search all of the work and associated context/data that has ever been done in their lab from one location, the answer is almost always no. We are trying to fix that.

It's really technically challenging - life sciences is so broad so you end up with lots of surface area in your product. The "apps" we provide for manipulating the primitives in biology (e.g. DNA) are huge products just by themselves.

</comment></comment><comment><AUTHOR> Founder here. We are hiring if you want to help us fix life science! No biology background necessary, only an interest.

<comment><USER4> Are there any ways to get involved as a medical student/physician scientist in the making?

</comment></comment><comment><USER5> I have spoken to a few of their customers and the benchling team has built a beautiful and uniquely useful product for life-scientists. Congrats on the progress and success!</comment>


Interview with Donald Knuth - <AUTHOR> http://www.informit.com/articles/article.aspx?p=1193856&rll=1

<comment><USER2> I found this part fascinating.

"Yet to me, literate programming is certainly the most important thing that came out of the TeX project. Not only has it enabled me to write and maintain programs faster and more reliably than ever before, and been one of my greatest sources of joy since the 1980s—it has actually been indispensable at times. Some of my major programs, such as the MMIX meta-simulator, could not have been written with any other methodology that I've ever heard of. The complexity was simply too daunting for my limited brain to handle; without literate programming, the whole enterprise would have flopped miserably.

If people do discover nice ways to use the newfangled multithreaded machines, I would expect the discovery to come from people who routinely use literate programming. Literate programming is what you need to rise above the ordinary level of achievement. But I don't believe in forcing ideas on anybody. If literate programming isn't your style, please forget it and do what you like. If nobody likes it but me, let it die."

I am a little skeptical of literate programming (especially how it would would work on multi person teams, a circumstance Knuth doesn't face) but when someone of the stature of Knuth is so emphatic, common sense dictates a closer look.

The LCC compiler (Fraser and Hanson) seems to have been developed using literate programming and it is a beautiful piece of code.

I was wondering -- has anyone on news.yc attempted literate programming?

<comment><USER3> Why are you skeptical of literate programming with multi-person teams? It seems to me that the value of literate programming would increase exponentially in relation to the number of people reading the code.

<comment><USER2> "Why are you skeptical of literate programming with multi-person teams? "

I guess it is because I am not convinced about many people working on a piece of _prose_ (vs code). As I understand literate programming, the "text" evolves parallelly with the code.

Having said that, I'd be interested in knowing if anyone managed a successful lp project with more than one person (or a couple of persons).

<comment><USER4> I've done some literate Haskell programming on stuff of my own. I never used it while working with other people, though. I understand that darcs (<http://darcs.net>) uses a fair amount of literate programming, perhaps you'd like to check it out.

</comment></comment></comment></comment><comment><USER5> 'With the caveat that there's no reason anybody should care about the opinions of a computer scientist/mathematician like me regarding software development, let me just say that almost everything I've ever heard associated with the term "extreme programming" sounds like exactly the wrong way to go...with one exception. The exception is the idea of working in teams and reading each other's code. That idea is crucial, and it might even mask out all the terrible aspects of extreme programming that alarm me.'

</comment><comment><USER6> Knuth is the Warren Buffett of computers: phenomenally successful because he's a master of fundamentals, with an uncommon share of common sense. Also, a great writer (of books _and_ software).

<comment><USER7> He also has an uncommon humility considering his achievements that really commands attention when he speaks or writes. You just don't ever get the "hidden agenda" vibe from Donald. Its very refreshing.

</comment></comment><comment><USER8> Wow: "During the past 50 years, I've written well over a thousand programs, many of which have substantial size. I can't think of even five of those programs that would have been enhanced noticeably by parallelism or multithreading."

<comment><USER9> That is a pretty amazing point - I am betting most people will ignore that.

Whilst current CPU trends are to "wider" architectures - how much of that is lack of innovation in the CPU design area rather then some major actual shift - ie will we see new CPU innovation in the near future where explicit parallelism is less of an issue?

Having said that, parallel friendly functional languages like erlang and haskell have so many other advantages, maybe its worth shifting in that direction anyway.

</comment></comment><comment><USER10> "Yet I think that a few programs, such as Adobe Photoshop, will always be superior to competitors like the Gimp—for some reason, I really don't know why!"

See, that's what a name like The Gimp does. Even smart people will believe your product is inferior - backed-up by no real argument what so ever ;)

<comment><USER11> Although maybe he's wrong about Photoshop vs Gimp, I still think he is correct in saying that some programs just can't be done in an open source manner. A better example might be something like Second Life - there is no way that could have evolved the way most open source software evolves now.

Some things just require immense dedication and concentration from a large amount of people from the very start - and in an open source project, you can't get that until you have a sizable project already done.

<comment><USER12> I don't know what part or aspect of SL you think couldn't have been done Open Source, but there was this company called Nevrax who developed and launched this MMO called Ryzom. It was not a commercial success, but it got done, and it was open sourced all along, which AFAIK did't hurt them much.

Edit: <http://www.fsf.org/news/free-ryzom> (where it also says Linden Labs has GPLed the client code for Second Life, back in 2007.)

</comment></comment></comment><comment><USER13> " ... that might well be because I'm a very strange person"

I completely agree he does sound like a very strange person, some of his opinions are not what you would expect from a person in stature, to the degree that made me doubt the integrity of this interview

If people didnt know he was Don Knuth he would have been easily acused of being a troll

He also sound like a very opinionated and passionate person

<comment><USER3> Which of his opinions are not what you would expect from a person of his stature?

<comment><USER13> [http://tech.slashdot.org/article.pl?no_d2=1&sid=08/04/26...](http://tech.slashdot.org/article.pl?no_d2=1&sid=08/04/26/1627248)

</comment></comment></comment><comment><USER14> 'I have special [...] Emacs keyboard shortcuts that make bookwriting a little bit like playing an organ.'

</comment><comment><USER15> _I do grant that web browsing probably will get better with multicores. I've been talking about my technical work, however, not recreation._

What??? Web browsing is only for recreation? Perhaps, he meant that it is recreation _for him_...

</comment><comment><USER16> From the article: "I also must confess to a strong bias against the fashion for reusable code. ... you'll never convince me that reusable code isn't mostly a menace."

???

<comment><USER17> Knuth is solving different problems than Joe Average programmer.

I don't think anyone will argue against reusing existing databases, web frameworks, etc. when you are writing a web app. But if you are, say, writing a new typesetting system... who cares about reusability? You just need to make it work. The components aren't typically used elsewhere in that case, so your priority should be writing a good typesetting system, not writing reusable parts.

I think that's what he's saying, anyway...</comment></comment>


Show HN: Hacklily – sheet music editor - <AUTHOR> https://www.hacklily.org <comment><USER2> Very cool! I run LilyBin ([http://lilybin.com](http://lilybin.com)), which I've unfortunately let languish. I compile using AWS Lambda and stay within the free tier. Did you consider using Lambda?

<comment><AUTHOR> Very cool work -- I'm a fan.

I considered Lambda and similar, but keeping LilyPond running as a server allows for lower latency, which is important given how long it takes for LilyPond to start up.

I don't think I'd be able to have the kind of live reloading I implemented here with Lambda.

<comment><USER2> The reason I switched to Lambda was to handle bursts. Occasionally some teacher would have a classroom open LilyBin, and my one server couldn't compile 30 scores at once. Lambda made it easy to handle.

Hacklily is great! Obviously doing fine with the HN burst! I may just point people to yours at some point.

<comment><USER3> This sounds like a really interesting problem. What kind of transformation is taking place during compilation, datatype wise, like are you rendering audio serverside?

I wonder for a classroom setting, if many people compile similar scores, if there's any opportunity to say "the first half of all these scores are the same, compile it once and concatenate it with the unique pieces"...caching composition...I'm sure I'll play with it someday.

<comment><AUTHOR> For Hacklily, it turns out that the audio is rendered clientside via [https://github.com/hacklily/hackmidi](https://github.com/hacklily/hackmidi)

Caching sheet music rendering is a hard problem. For example, a note later in the score can affect the spacing of notes before it.

</comment></comment></comment></comment></comment><comment><USER4> Funnily enough, I spend the weekend making almost the exact opposite of this:

[https://github.com/Miserlou/chords2midi](https://github.com/Miserlou/chords2midi)

<comment><USER5> Neat! Want to play with this. Does it also do voice leading?

<comment><USER4> No, it's pretty crude so far, but that's a great idea!

How would you want that implemented?

<comment><USER6> Short of a genuinely complicated ML system which having been fed a bunch of (say) Jazz Pianists midi data for chord patterns etc, I think you could probably do it with some kind of weighted (let's say by the user) Markov chain/state machine with some kind of graph for which chord voicing should be used relative to those around it: e.g. "This Dm7 has a F in it, the next chord is a Cmaj7#11 so move the F up a semitone[Within the same octave]"

The above system should be able to come up with coherent movement of voicings (and fingers...) although I can't imagien that it would sound very human.

</comment></comment></comment></comment><comment><USER7> This is so cool. Hadn't heard of LilyPond before this. I browsed mutopiaproject.org for some .ly files and imported them. Works great. Thanks for sharing!

<comment><USER8> Mutopiaproject and LilyPond are great. I used Mutopiaproject a lot when I was a teenager who enjoyed playing piano. It and imslp changed how I explored music, and helped me develop my interests. I always preferred the LilyPond scores from Mutopiaproject when they were avaialable, because they were usually higher quality. I actually decided to give back to the community by typesetting some scores myself.

<comment><AUTHOR> That's awesome! Do you have any suggestions on how Hacklily could help you typeset & share music?

<comment><USER8> The thing that led me to stop contributing was ultimately seeing the progress that was being made toward automated music transcription. I saw this technology as something that would make the process a whole lot faster once it was good enough, and so it wasn't a wise time investment to keep writing out those intricate files by hand, but it also wasn't yet the right time for me to start using that transcription software, either.

At the time, the software that caught my attention was mainly the kind that helps users turn a scan of sheet music into something that could be transformed (with a text editor and some scripts) into a LilyPond source file with far less work than actually typing out all of the LilyPond input yourself.

I can envision software that does this, but it seems like a big project with very uncertain adoption outcomes.

Edit: I think software like this probably already exists, essentially, and definitely if you consider running one of the LilyPond command line conversion tools an acceptable step. The system's main differentiators would be being web-based (which isn't that uncommon anymore for music engraving software), and targeting LilyPond as the best-supported output.

</comment></comment></comment></comment><comment><USER9> At first, I thought: 'Kinda cool Latex inspired markdown editor for notes, but the play button is missing.'

Then I saw the play in the top bar :D

Pure awesomeness!

</comment><comment><USER10> This is quite cool! I do feel like the "code view" interface isn't the best default, the "Insert Notes" interface should be more than just a tool hidden in a menu, because that's more than likely the primary way people would prefer to write music. I would keep the code view to more of a "view source" option.

<comment><AUTHOR> Thanks! That's useful feedback. Hacklily's audience so far is primarily users who are already Lilypond users, but I'd love to make it more broadly useful.

<comment> jay-anderson Agreed. As a lilypond user, hiding some of the extra stuff would be confusing to me. I don't think it would be simple to create a mode for more easy note- only editing.

</comment></comment></comment><comment><USER11> Is this an online editor for lilypond? What are you using to render?

<comment><AUTHOR> Yes! It uses lilypond in docker.

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

<comment><USER12> Very cool. I dug up an unfinished Lilypond arrangement that I'd been working on in 2008 and pasted it in and everything worked perfectly the first time.

I think if this had existed back then, the much-faster feedback loop would have helped me finish it. :)

<comment><AUTHOR> That's super motivating, thanks for taking the time to comment!

<comment><USER13> It would be really neat if I can export to a MIDI. Do you reckon that's easy to do for you? Lilypond in the back is storing this data in abc format right?

Separately, a question, which you guys might know how to solve:

How can I convert a PDF music sheet to a MIDI? I.e., does there exist a music- sheet to digital-music converter? The pdf in question I want to convert is not a scanned copy, it's been digitally produced by some other program (I don't know which program)

<comment><AUTHOR> Someone requested MIDI and other exports at [https://github.com/hacklily/hacklily/issues/2](https://github.com/hacklily/hacklily/issues/2) and I'll try to tackle soon. Hacklily already makes MIDI available (for playback), so it's a matter of actually exposing that.

There are solutions for converting sheet music images to MusicXML/Finale/etc., but I haven't had good results with any of them.

</comment></comment></comment></comment></comment></comment><comment><USER14> I've been describing it as a code editor for sheet music, but I guess it's just as much a sheet music editor for coders?

</comment><comment><USER15> Very cool! If you're a guitar player, you might like: [http://public.vexflow.com/vextab/](http://public.vexflow.com/vextab/)

<comment><AUTHOR> As someone who has tried making a sheet music renderer, VexFlow is extremely impressive.

<comment><USER16> Yeah, I got as far as rendering the tab and the notes - but then trying to tie the "tied" notes together... that'll drive you crazy.

</comment></comment></comment><comment><USER17> Pretty sweet, I'll just have to learn that LilyPond to make use of it. Is there any good resources out there? It would be nice to include some tutorials or example songs but well that's a minor issue.

To me learning through programming is very natural so I'm excited to try my hands on composing using this language. Didn't ever occur to me that the notation would be that simple. With same effort and time you put into learning say C++ could you become a proficient composer with this?

<comment><AUTHOR> I think the LilyPond documentation ([http://lilypond.org/doc/v2.18/Documentation/learning/index](http://lilypond.org/doc/v2.18/Documentation/learning/index)) is a pretty good way of learning LilyPond. It's linked to from "menu > LilyPond manual" within Hacklily. Maybe I should be more aggressive about highlighting that...

Making community features is a natural next step which might help with finding examples.

LilyPond has a bit of a steep learning curve, but you can absolutely use it professionally. [http://www.mutopiaproject.org/](http://www.mutopiaproject.org/) shows what LilyPond can do. Personally, I find that I can be more productive with LilyPond than with Finale, and that the results look better.

<comment><USER18> I've been using Musescore for a lot of the stuff I used to use Lilypond for, but one of the things I absolutely love about Lilypond is that its easy to write scripts that emit lilypond format, it's killer for repetitive stuff like examples, flash cards, etc.

I was never any good with Finale or Sibelius, so I feel like I'm unqualified to say whether Musescore is worth learning, but have been curious what an actual skilled Finale user thinks about it?

</comment></comment></comment><comment><USER19> I sometimes try to use Denemo but the UI is a bit complicated so that writing LilyPond yourself maybe is easier? But I like that Hacklily hat some other input methods as tools. I would like to click on a virtual piano. [http://www.denemo.org/](http://www.denemo.org/)

<comment><AUTHOR> [https://github.com/hacklily/makelily/issues/2](https://github.com/hacklily/makelily/issues/2)

</comment></comment><comment><USER20> Could really use a more complex example. Anything I could paste in?

<comment><AUTHOR> Here's an arbitrary example from mutopiaproject.org: [https://www.hacklily.org/?edit=jnetterf/sheet- music/BWV857BW...](https://www.hacklily.org/?edit=jnetterf/sheet- music/BWV857BWV857_Praeludium12BWV857_Praeludium12.ly)

</comment></comment><comment><USER21> This looks beautiful! Here's a related tool my friends made: [http://partifi.org](http://partifi.org)

</comment><comment><USER22> [https://en.wikipedia.org/wiki/ABC_notation](https://en.wikipedia.org/wiki/ABC_notation)

</comment><comment><USER23> [https://github.com/adjunct-professor/sheet- music/blob/master...](https://github.com/adjunct-professor/sheet- music/blob/master/adjunct-professor-cd.ly)

[https://github.com/adjunct-professor/sheet- music/blob/master...](https://github.com/adjunct-professor/sheet- music/blob/master/adjunct-professor-cd.pdf)</comment>


Like Tweeting, but You Can't Use the Letter E - <AUTHOR> https://motherboard.vice.com/en_us/article/its-like-tweeting-but-you-cant-use-the-letter-e <comment><USER2> Translation of posting without using 'E':

It's Similar to That Bird Social App, But Without a Fifth Symbol

Mastodon has an app with particular quirks and many humans find it joyful.

Mastodon boffins did it again.

A particular boffin going by initials M.R. works as a digital craftsman at a corporation with initials I.A. (that has http archival capability), did craft a social app oulipo.social with an odd quirk: said app disallows applying of fifth anglo-saxon linguistic symbol or "any variant of it".

Said individual found motivation via book "A Void" by author G.P. This lipogrammatic book did apply all anglo-saxon linguistic symbols but that particular symbol. It follows a Francophonic philosophy of Oulipo, a constraint form of writing that is a combination of both math and book study.

Banning of this symbol is Oulipo's most famous limitation: "It limits writing without making it too hard," M.R. said. "You can still sound natural and say what you want to say, though you may think on it a bit in a way that you wouldn't without constraints." Such limitation can push you to think hard and apply imagination about words, M.R. said.

M.R. had no anticipation that oulipo.social would attain popularity — as it got its start as a trial of skills application of Ruby on Rails and to attain a sharp mind in OS capability — but said app did gain many additional accounts (singular digit with two nought digits) within about six days of starting.

"It's a joy to watch folks do things I wouldn't think of—#drilipo, and applying oulipo constraints to famous writing and songs—and just chat about day to day stuff," M.R. said. "It's also gratifying that folks will look at oulipo.social and go on to think up constraints or gimmicks for additional variant Mastodons."

M.R. did post back to my communication within an hour, with almost 300 words and without said taboo symbol. I suck at thinking by using my imagination to avoid said symbol and quit not long post-starting as my mind is frail.

<comment><USER3> Pray tell, fifth Symbol of what? Did you try to put words to say "fifth symbol of an Anglo-variant of latin-script".

<comment><USER4> 'Pray tell' has an 'e'.

<comment><USER3> Dang, you are right.

</comment></comment></comment></comment><comment><USER5> > Reeve replied to my email in less than an hour, with nearly 300 words and no > appearance of the banned character. I attempted to write this article > without using the letter "e" and gave up after five minutes of weak effort.

0x7265657665 did dispatch back as to my communication in duration not in surplus of an hour with almost 300 words and without a taboo glyph in sight. Although I did try to author this column without using said taboo glyph "0x65", against apathy and sloth I could not triumph and did submit for my stab at it, as short in duration as to boil liquid in a pot, was a dud.

<comment><USER6> In what encoding does "0x65" represent "e" ?

<comment><USER7> ASCII, UTF-8, ISO-8859-1 (Latin-1), Shift JIS, among others.

<comment><USER6> Am I tripping? I thought 65 was "A"?

<comment><USER8> Can't help you with your use of hallucinogenic substances, but I think you're mixing your decimal and hex. Decimal 65 is a capital "A". Hex 65 (0x65) gives you lowercase "e".

<comment><USER6> Ooooooooh duhhhhhh. I applied "automatically ignore prefix" filter for some reason. Dumb brain.

</comment></comment></comment></comment></comment></comment><comment><USER9> If we want something like Twitter, but in the form of an open source protocol, we need to name it and brand it well.

I remember when I first used Linux, I didn't "trust" it. There wasn't a singular OS called Linux and the GUI applications looked low quality because they didn't have good design or branding. To most people, the UI and branding _is_ the product, so when they see it poorly implemented, it simply feels like a bad product.

If you make open source feel expensive and luxurious, they will come.

<comment><USER10> > If you make open source feel expensive and luxurious, they will come

Hmmm...So: let's ask a bunch of objective, analytical, concrete techies to pivot themselves over to a subjective, abstract, feelings-based judgment process which requires a great sensitivity and sense of cultural refinement.

<comment><USER11> I'm not sure what this ad hominem comment was supposed to accomplish. Don't we already have people who appreciate subjective and cultural concerns involved?

<comment><USER12> > The cybre.space instance calls each post a "florp" instead of a "toot."

I'm not entirely convinced that we do, no.

</comment></comment></comment></comment><comment><USER13> Rather than rejecting e it should delete your account if you happen to enter one. And announce the fact in impact font on your followers' timelines.

<comment><USER14> That would be a great game. Try and trick others into using it while abstaining yourself.

</comment></comment><comment><USER15> This sounds like a fun gimmick, but it makes me more excited about the concept of Mastodon (GNU Social). I think this creates a really fun use case for federation. Hell I never thought of it before, but maybe now I'll want accounts on multiple servers now.

<comment><USER16> One of the constraints of GNU Social is that you shouldn't have two identical usernames on two separate instances. I did that and I don't know how to fix it.

email@example.com

email@example.com

Does Mastadon suffer the same problem?

<comment><USER17> Mastodon have the same problem.

> [https://social.tchncs.de/@voidnill](https://social.tchncs.de/@voidnill) > > [https://mastodon.cloud/@voidnill](https://mastodon.cloud/@voidnill)

are the same user (me) on two different instances.

<comment><USER18> What do you mean by "problem"? Email has the same "problem".

</comment></comment></comment></comment><comment><USER19> Also of interest: [https://en.wikipedia.org/wiki/Gadsby_(novel)](https://en.wikipedia.org/wiki/Gadsby_\(novel\))

<comment><USER20> Now I remember where I'd heard of that Gadsby book before.

It's referenced in one of the exercises in the Think Python book:

 _Write a function called has_no_e that returns True if the given word doesn't have the letter "e" in it._

[http://www.greenteapress.com/thinkpython/html/thinkpython010...](http://www.greenteapress.com/thinkpython/html/thinkpython010.html)

</comment></comment><comment><USER21> There's a musician named Andrew Huang who sometimes makes music based on song challenges from his fans. Years ago, I asked him to write a rap song in which none of the lyrics contain the letter "e." Like the person in the article, I had read "A Void" by Georges Perec, so that's where the idea came from.

And about a day later, he posted this song: [https://www.youtube.com/watch?v=Z8-WtH4ujps](https://www.youtube.com/watch?v=Z8-WtH4ujps)

<comment><USER22> Wow, that musician has amazing skills! Thank you for sharing this.

</comment></comment><comment><USER23> Oulipo.social now has a mirror image: dolphin.town, where you can _only_ use the letter E.

</comment><comment><USER24> I think I need help understanding why this is in any way relevant or interesting. I'm actually serious and open to listening. Obviously it got on the front page.

<comment><USER25> Personally I find interesting the general idea that adding constraints to a system leads to creative outlets, forcing the participants to break entablished thinking patterns. The fun stuff here is not the content, but the alternative paths the writer has to take to convey the message.

<comment><USER26> Wouldn't the asy workaround b to writ what you wantd to writ but drop th "3"?

Even without the e's you can probably infer meaning with a high probability of success.

<comment><USER27> Replacing 'e' with similar symbols like '3' is also not allowed. That's the point :)

<comment><USER28> It's not actually said that "3" should swap with it - it's a substitution for that symbol.

It's a proposal to post normally but to omit any symbols that don't fit by just not typing anything.

</comment></comment></comment></comment></comment><comment><USER29> How would you talk about an unfamiliar individual known by a noun you can't say?

<comment><USER30> It's limiting in a big way. Occasionally, you can say a string of words without that symbol that flows without worry, but an individual word trips you up and brings much difficulty, as any of its obvious synonyms all contain that symbol too.

<comment><USER31> That's... just a hacky workaround...

Imo such would warrant a distinct class of "non-format" strings, just for that noun class; that you might talk about it as-is without violation?

Or for purists... commonalization of a particular 'magic' shorthand, such as 'xqx', that is uncommon in that noun class thus can act as a _quick_ shorthand. Though such has additional 'logic' to say initially, it and similar shorthands form a basis for a community 'pidgin' within constraints.

Also, I am now full of irk. Continually colliding with taboo words containing (un)said symbol. Ugh. (WHY MUST SO MANY WORDS FINISH WITH TABOO GLYPH?!)

</comment></comment></comment><comment><USER32> So just lav out the "e"? The human brain would b prfctly capabl of undrstanding it.

<comment><USER33> From oulipo.social's FAQ ([https://oulipo.social/about/more](https://oulipo.social/about/more)):

* No problm I'll writ lik this.

No. Stop. Don't do this.

<comment><USER34> At the same page they describe themselves as:

'A Dcntralizd and Fdratd Social Ntwork'.

<comment><USER33> Fair point, but it's still a young program and no doubt a fix is coming soon.

</comment></comment></comment></comment><comment><USER35> This website is slugish as hell. Every time I scroll my cpu usage jumps to ~30% and I have ~2FPS, using the latest version of Firefox.

On Chrome the CPU still spikes, but it's no nearly as bad.

<comment><USER36> If you're willing to turn off JavaScript, you can have all the same content, but with silky smooth performance.

On the "downside", though, you miss out on the social media sharing buttons, and auto-loading of the next article when you get to the bottom of the page.

<comment><USER31> > you miss out on the social media sharing buttons

Oh, sad day... :)

</comment></comment></comment><comment><USER37> Silly Vice: it's "Perec", not "Pereca".

</comment><comment><USER38> It seems to me that Vice casually mentioning Mastodon suggests something about a level of achieved status as a communication platform.

</comment><comment><USER39> "A little glob becomes a globe instantly, if you just add silent e!" \- T o m L * h r * r

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

</comment><comment><USER40> Also of interest, "A Void": [https://en.m.wikipedia.org/wiki/A_Void](https://en.m.wikipedia.org/wiki/A_Void)

</comment><comment><USER41> Slightly related. Reddit user IHateLetterF never uses the letter F.

</comment><comment><USER42> Link to the actual "social sharing hub", which is a mod of Mastodon:

[https://oulipo.social/about](https://oulipo.social/about)

<comment><USER43> That's a login form.

Can you not look at posts on Mastodon without signing up for it? That sounds fatal for adoption.

<comment><USER44> You can see any users public timeline and posts at /@username, but the complete public timeline requires authentication (with this or any instance it's federated with).

</comment></comment></comment><comment><USER45> Twitter is like blogging, but you can't use more than 140 characters.

Clearly the more constraints we add, the better it is!

</comment><comment><USER46> Just use 3, 31337 nerds. Hey, people were writing like that in the '90!

</comment><comment><USER47> Twatting?</comment>


A Little Gear That Could Reshape the Jet Engine - <AUTHOR> http://www.bloomberg.com/news/articles/2015-10-15/pratt-s-purepower-gtf-jet-engine-innovation-took-almost-30-years <comment><USER2> There's a long negative history of high-speed gearing. Jet engines have one big rotating unit, and that basic simplicity is good for reliability. Turboprops have a gearbox, and fragile, high-maintenance gearboxes are a long- standing problem with turboprops. Adding a gearbox without reducing reliability is a major achievement.

<comment><USER3> High-speed gearing is indeed very difficult, but jet engines already typically have two separate, concentric rotating units (spools: [https://en.wikipedia.org/wiki/Turbofan#Basic_two_spool](https://en.wikipedia.org/wiki/Turbofan#Basic_two_spool)). Also, as the article mentions, turboprops (essentially jet engines connected to a propeller) already commonly use gearing. I guess you can think of it as a turboprop with a duct.

The reality is probably just that this is a solvable problem that just wasn't worth the work while there were easier efficiency gains to be had.

<comment><USER4> > High-speed gearing is indeed very difficult, but jet engines already > typically have two separate, concentric rotating units [...]

Yes, everyone knows that, but the spools are not connected by a set of gears as they are in the P&W's new engine.

> Also, as the article mentions, turboprops (essentially jet engines connected > to a propeller) already commonly use gearing. I guess you can think of it as > a turboprop with a duct.

The new engine is _ALSO_ unlike most installations of turboprop engines in that the fan is driven by the power spool, not a free turbine. The free turbine (in turboprops that have them), which powers the reduction gears for the propeller, runs at a much lower speed than the power turbine.

</comment></comment></comment><comment><USER5> I wonder if instead of gearing a single large fan, you could just remove the fan from the turbine altogether, add a much larger alternator, and power several large electric external fans from each turbine? That would give you more fan area than you can get with a geared turbofan, optimal fan speed for efficiency, redundancy in case one of the fans suffered damage, allow cross- routing of power between turbines if one turbine failed, and not require quite such large fans so they'd fit under the wings more easily.

<comment><USER6> This idea would unfortunately negate one of the top benefits of a high-bypass turbofan. Noise reduction.

<comment><USER5> Yes, but why is a high bypass turbofan quieter? If I understood correctly, it's because most of the thrust comes from the large slow moving fan, so you don't need to blast nearly so much air through the turbine as a turbojet to get the same thrust.

The whole purpose of decoupling the fans is to give you an even higher bypass ratio - two or three large electric fans driven from one turbine can have a larger swept area than a single large geared turbofan, so can run slower for the same thrust, and hence be quieter.

<comment><USER7> > Yes, but why is a high bypass turbofan quieter?

The noise comes from high speed air alongside slow moving air. A high bypass fan moves more air at slower speed to get the same push. The slower speed means less noise.

</comment></comment></comment></comment><comment><USER8> Love this: _"It's the antithesis of a Silicon Valley innovation," says Alan Epstein, a retired MIT professor who is the company's vice president for technology and the environment. "The Silicon Valley guys seem to have the attention span of 3-year-olds."_

<comment><USER9> I suppose the world is big enough for both. Sadly, media follows the kids more often than the adults.

<comment><USER10> Yeah, there are definitely people in Silicon Valley who are working on the same problems they were working on 20 years ago – it's just not very interesting to outsiders so you don't hear about it (until they have a breakthrough).

</comment></comment></comment><comment><USER11> Could some knowledgable aircraft people answer these questions for me?

1\. Can/are jet engines ever swapped out after a plane as been put into service? Or will these only ever be sold attached to new aircraft orders.

2\. Any idea on what the engine costs? And what percentage of the overall airline cost is engine? I didn't see any references to costs of this engine vs existing models.

<comment><USER7> Re-engining an airframe is a big deal. A lot of engineering has to go into it.

<comment><USER12> Why can't they just have a standard mount like an LCD panel?

<comment><USER13> I upvoted cause not dumb question. Yes they do to an extent. One of the major reasons the engines are mounted on pylons is exactly to make maintenance and replacement easy.

<comment><AUTHOR> Yeah, it's a fair question. Most are unused to weight optimization. It's why everything in a commercial jet down to the forks served with meals is purpose designed for aviation.

</comment></comment></comment></comment></comment><comment><USER14> It'd be interesting to know what exactly they are doing in the gearbox, apart from the flexible mount to absorb excess torque. New materials? Surface treatments? Special lubrication?

<comment><USER15> This article has much more detail:

[http://theflyingengineer.com/flightdeck/pw1100g-gtf/](http://theflyingengineer.com/flightdeck/pw1100g-gtf/)

The gearbox is described as the epicyclic type with the compressor driving the sun gear and the carrier of the five planet gears driving the fan. The article doesn't seem to identify any extra special sauce. It points out that geared turbofans have been used on an airliner in the past, and identifies some design trade-offs. "there may be a performance penalty, marked by slower cruise speeds for the same thrust setting, possibly slower max cruise speeds, slower green dot (best L/D speed), slightly shallower climbs, and possibly degraded single-engine performance. The single engine performance difference is expected to be the most prominent, with a possibly larger yaw, and a definitely reduced climb gradient, consequently lowering obstacle clearances."

My impression based on just reading that article is that, rather than a technological breakthrough enabling the geared approach, Pratt and Whitney have explored a rather neglected area of the design space, to arrive at a more efficient, lower noise engine with slightly worse performance in some other respects. And had to conquer numerous 'ordinary' engineering challenges to make it work.

<comment><USER14> Thanks, that article was indeed much better to understand what's going on. Still, as mentioned, high-speed gearing of the kind does offer some design challenges, but apparently its all secret sauce.

</comment></comment></comment><comment><USER16> So basically this seems to be a extra-high-bypass turbofan achieved by gearing down the fan. But delayed hugely because giant megacorps move very very slowly.

<comment><USER17> Because of safety. For a brand new concept engine, you don't want to have any doubts at all. That means lots of long term testing. Since it will be powering jetliners, it has to be as close to flawless as possible. And even then, they have to convince the airline companies to use it.

</comment></comment><comment><USER18> 30 years. I do wonder if that is true. Did they actually developed it under a time period of 30 years. or do they mean it more in a way that it is a continuation of previous models.

<comment><USER19> It's more of a 'The concept is 30 years old' thing. Some of the reasons driving the commercial development only became factors in the market more recently; things like fuel efficiency and airport noise restrictions. Also, one of the less discussed advantages (as a customer) for the geared turbo fan is the decrease in expected maintenance/repair costs on the life of the engine. That's big business for engine manufacturers and there will be less of it with this design.

</comment></comment><comment><USER20> > "At times, the extent of the operation had to be protected from bean- > counting Pratt executives"

Yep, that's how UTC operates. It's amazing they make any money at all.

</comment><comment><USER21> "The Silicon Valley guys seem to have the attention span of 3-year-olds."

<comment><USER22> It's a bit easier to be blasé about testing when your worst-case-scenario is that somebody misses a ride, vs when you kill ~150 people. The rapid cycle of innovation is a tradeoff that SV is able to make (and finds amazingly beneficial) because we're working with soft tools and have backups of our data. I'm certain that were human life so cheap, Pratt and Whitney would have a much shorter dev cycle, too.

<comment><USER23> Shorter project sprints came about to try to fix the problem of project failure. Failure to create a loop that feeds discoveries in to a project's knowledge, and to communicate knowledge between teams is exactly what makes projects come to catastrophic ends, and that's what the shorter cycle time attempts to correct.

The fact the product benefits from faster innovation is a function of more efficiently sharing knowledge and data, not spending less time on individual components.

Designing and testing an engine can be done in an agile style. There's nothing intrinsically "software only" about the methodology.

NB: I ran a startup that made software to manage requirements in big projects. I've spent lots of time thinking about different ways to manage things. Including how not to, but that was after we failed.

<comment><USER24> Yes it is intrinsically software-only. When a software test fails you fix the bug and run it again. When a jet engine test fails you just blew up a $10M prototype.

<comment><USER23> A software test is equivalent to a testing small part in an engine design. The cost of failure is low. The cost of a full production test in an engine design is clear, but it's the equivalent of a product handover and acceptance testing in software. The cost of failing _that_ test could well run to millions of dollars.

The only difference for a SaaS startup is that they're their own customer for product development (in the sense that they build and test in-house rather than someone else paying them to build a product). The cost of failure is still there, it's not measured.

</comment></comment></comment></comment></comment><comment><USER25> > what may be most remarkable about the engines is that they took almost 30 > years to develop. That's about 15 times as long as the gestation period of > an elephant

Who the hell is running their analogy department?!?

"Thirty years! That's a big number! We need some kind of comparison that will instantly give the reader perspective. Of course, in this, as in so many other things, the answer lies in _pachydermian pregnancy patterns_."

<comment><USER26> I thought the next example was even more inane. It goes on to say: "and unimaginably longer than it takes to pop out a smartphone app".

<comment><USER27> Smart phones haven't even existed long enough for anyone to spend 30 years making an app for them... And the laws of physics have much better backwards compatibility than each new fly-by-night smartphone OS</comment></comment></comment>


Adobe Warns Customers of Potential Legal Action for Using Older App Versions - <AUTHOR> https://forums.macrumors.com/threads/adobe-warns-customers-of-potential-legal-action-for-using-older-versions-of-creative-cloud-apps.2181197/ <comment><USER2> Don't negotiate with terrorists. Just cancel and refuse to do business with Adobe for the rest of your life.

</comment><comment><USER3> Did Adobe acquire a license for end-users to use dolby technologies or a license for Adobe to distribute dolby technologies? It seems weird that there would be a time limit on a license to _use_ features, whereas time limits on distribution is common.</comment>


Mind-Altering Cat Parasite Linked to Schizophrenia in Largest Study Yet - <AUTHOR> https://www.sciencealert.com/mind-altering-cat-parasite-linked-to-schizophrenia-in-largest-study-yet <comment><USER2> Relevant: [https://slatestarcodex.com/2014/12/17/the-toxoplasma-of- rage...](https://slatestarcodex.com/2014/12/17/the-toxoplasma-of-rage/)

<comment><USER3> That was a great read on it's own, thank you!

</comment></comment><comment><USER4> Startup bug discovered.</comment>