Nylas Mail is now free(blog.nylas.com) |
Nylas Mail is now free(blog.nylas.com) |
(I work at Nylas.)
Disclaimer: I am a Thunderbird developer.
It was to my understanding that development, outside of security fixes, was more or less halted. Although looking at commits this doesn't seem to be the case [1]. While I use and enjoy Thunderbird, I was also under the impression is was more or less frozen/dead in the water/EOL.
(I work at Nylas.)
The same happens for me with ProtonMail. I used the basic service but found that the convenience of a paid plan was enough for me to pay.
I was sort of put off by the look of Nylas though, in regards to the lack of a "native" feel. It was convenient, but I was forced into a paywall before I could really get acquainted as someone who isn't a power email user.
Does Nylas have anything that might convince me to use it? I guess Open Source is a pretty big one, but I'm talking featureset wise.
Maybe a way to submit feedback right from the app would be useful.
1 - any suggestions for an open source alternative that provides email snoozing on linux (that's a big part of my email processing)?
2 - any good guide on how to self host the Nylas server on my home server (I know they have the project on GitHub but the instructions are a bit too complicated for me, although that's perhaps my sysadmin skills are quite low)?
This took a huge amount of work behind the scenes. Stay tuned for the engineering blog post very soon!
"The Basic edition of Nylas Mail will remain free forever."
> We already sync several hundred terabytes of data for our users and are adding tens of thousands of new users each month. It’s costing us real dollars.
This is now changed with the new architecture in Nylas Mail.
For me, I would be super happy if the feature set of Thunderbird were frozen and future updates only fixed bugs and improved performance.
https://bugzilla.mozilla.org/show_bug.cgi?id=213945
This bug has been open for ~14 YEARS. Thunderbird not being actively developed is not exactly a recent development.
Reading through this thread I see tons of great MacOS mail clients, but very few Linux and essentially zero Windows. That's why I still use Thunderbird myself-- nothing better has ever come out.
(I work at Nylas.)
Whatever the reason may be, users were left without this extremely useful and desirable feature for fourteen YEARS. Thunderbird at its core today acts and performs essentially identically to 2003. I've been using it myself since well before that. Development on the mail client hasn't meaningfully progressed since, well, _ever_.
From a broad marketing perspective, you should have waited until the Windows client was available. When you finally release it in a week or a month, will you get another frontpage Hackernews post? Probably not.
I haven't tried it, but the Linux version works fine with a basic account.
The support page states that "If you’re using N1 against our open source sync engine, you’ll still need to create a Nylas ID."
Given the privacy policy says that Nylas shares information with third parties and that they can "make a copy of the entire contents of the applicable email inbox, calendar, and contact book", it doesn't feel like a traditional email client to me.
https://support.nylas.com/hc/en-us/articles/220974588-How-is...
Nylas Pro currently syncs in the cloud to enable some of the pro features not currently offered in Nylas Mail Basic and to provide a much easier to use modern API wrapper around mail data. The cloud syncing infrastructure is open source and you can run it yourself and inspect the code.
All editions (both Basic and Pro) need a Nylas ID. This lets us manage subscriptions for those who want to upgrade. The code is open source on GitHub (nylas/N1). You can fork & run yourself without a Nylas ID. You just won't get any cloud-enabled features.
We never send mail, contact, or calendar data to 3rd parties. We do, however, use 3rd parties for basic usage and performance statistics and self-host as much reporting infrastructure (like Sentry) as possible.
(I build Nylas Mail)
There's a reason that e-commerce sites allow buyers to add items to a cart without sign up, and to "checkout as guest" instead of forcing users to sign up for a Staples (or whatever) login -- you get more conversions.
Even if you prefer the approach of trying to get the information up front, adding a "skip" option that allows users to use the app without cloud sync, etc., then allowing a user to "go pro" later on at least allows people to try the app without a commitment. It's not possible to convert someone who isn't a user because they got scared away by the registration requirement -- better imo, to have a non-registered user, than no user at all.
The only reason I could think of for not wanting to allow this is related to the third party data sharing -- perhaps you plan to sell (obfuscated) user data to data brokers. If that's not in the cards, and you do not plan to monetize your free tier (aside from up-selling to pro), I see no downside to allowing users to use the app without cloud sync in the free tier, with upgrades available within the app.
Updating the privacy policy to be explicit about what data is used for ("basic usage and performance statistics") would do a lot to allay the idea that this data is being sold to data brokers (and not simply to make the app better).
The next step would be to make features like "read receipts" that necessitate signing into a cloud optional. Being able to use the app without having to sign into a cloud platform would be a much more valuable feature for me than any feature such a cloud platform could enable.
Aside: as mentioned elsewhere in the thread, tracking pixel based read receipts in particular, is overwhelmingly only used in spam and newsletters and I personally consider it to be a liability rather than a feature.
(puts Stallman's hat on) This is not free as in freedom.
https://github.com/nylas/N1/blob/master/CONFIGURATION.md
https://github.com/nylas/sync-engine
Edit: Not sure what the latest update changes yet (much of the sync engine is local now?), but this thread looks like it has the latest info so far.
If you're on the Basic edition, your emails never touch our servers. This was a huge undertaking (it's not easy to port a sync-engine written in Python and designed to run on servers to run efficiently on desktop machines) and is the major reason why we can now offer a freemium service. We're going to put out a blog post soon with more engineering details soon!
Cloud now used for "much much much much less" [0] - just tracking and stuff. Sync-engine also (?) runs locally now, I'm not totally clear on how this works but there's apparently some currently closed source stuff to become open 'soon', so it should become clearer exactly what's going on.
There's also apparently some details to follow on their engineering blog [1].
[0] - https://github.com/nylas/N1/issues/3166 [1] - https://nylas.com/blog
Another case in point is slack app. On Linux, it is probably the worst app. :(
It's nice to see that Nylas has learned nothing at all and keeps violating their users' rights.
Maybe I should finally sue them.
(I work at Nylas.)
We are a very small team building this app. Hopefully you can focus on what's new/good and not what is left to do! :)
If you find bugs, please post them here: https://github.com/nylas/n1/issues/
Here's the original discussion: https://news.ycombinator.com/item?id=11553738
It seems to me that Nylas could make a lot more money by charging $1 a month, since there are likely many, many more people willing to pay $1 vs. $12. Probably more than the 12 to 1 ratio required to break even.
I like Nylas, and think it is a good email client, but their pricing suggests they haven't done the market research and competitor analysis required to price themselves strategically and to be successful.
Do you have any data on this? Would love to see it to help inform the research we already did when pricing the Pro edition of Nylas Mail.
Having said that, I can offer you this isolated anecdote (as worthless as that is): The last company I worked for used to use Nylas, before the pricing was set to $7 a month. When your company started charging for Nylas, we all stopped using it, both personally and professionally, and the general consensus during the transition away from your product was basically, "I'd continue to use it if it were around a buck." We understood the need for your company to make money, but $7 a month seemed too steep to us, so we went elsewhere.
I think it is great if you're able to succeed at $12 a month. I certainly won't begrudge your success. It just seems to me that at the $12-price-point, your competitors are offering much, much more. There are also free options, like Boxer, that work satisfactorily and are still free.
I'm not knocking your product. I liked it when I was using it, and I think you're trying to succeed in a difficult market, so kudos for making the attempt. I just don't personally value Nylas Mail at $7 (or $12) a month, and reading through this thread, it seems there are others who feel the same way; which I would think you'd want to consider as you fine-tune your business model.
Anyway, best of luck to you. I wish you all the success you deserve.
Don't get me wrong, it looks extremely good.
However, I visited the site and immediately clicked on the back button.
I've been using Google Inbox for a few months, and it radically changed how I handle my many mailboxes. It's not rare now that I actually achieve inbox zero.
I would love to see the same amount of innovation that was put into Google Inbox (I think they might have acquired it, though?) in another email client, as I'm always looking to try things out.
In Nylas, I see the same things that make dealing with email a pain: folders, the trash and spam being given the same importance as the inbox, etc.
It's set up to make it a job to keep your emails organized, while you shouldn't keep them organized, because it's just doesn't matter: just reply and mark as done, snooze until you can reply and mark as done, or discard/mark multiple emails at the same time and go on with your life.
Seems to work just fine with a "basic" account.
> Today’s release supports Gmail/G Suite, Office365 Exchange, Yahoo! Mail, iCloud, and FastMail. Full support for self-hosted Microsoft Exchange servers is coming soon.
I am a little curious why this is so limited. All of the above solutions support IMAP, so why is this so specific? I could understand if they're trying to support, say, Gmail-specific features of your inbox, but a provider like FastMail is pretty much entirely standards-compliant, AFAICT.
But I gather they're not using it with them:
> It’s now powered by a hybrid sync engine that connects directly to your mail provider (Gmail, Exchange, etc.)
The Gmail API, [0] for example, is presumably far preferable to using IMAP.
Here's how to do it: http://imgur.com/a/WBdXe
(I work at Nylas.)
Though there's some odd duplication for FastMail from the last update, I am going to file an issue if I can't find an existing one. :D
And thanks for working on open source software!
Essentially, we started as a free beta at the very beginning, launched with free trial last year, and now have switched to freemium (with a free trial on the Pro version still there).
Does that make sense?
(I work at Nylas.)
The Nylas client doesn't connect to you mail provider directly, instead the Nylas client connects to the Nylas Sync Engine. It used to be that using this API for this was a couple hundred a year, per account.
Both the client and the sync engine are open source, so you've always been able to host your own.
[1]- https://www.reddit.com/r/privacy/comments/5grsan/do_not_use_...
(I work at Nylas.)
Do you also run apps like Slack or Google Chrome? How does their memory usage compare?
Was this during initial sync (very resource intensive) or at a steady state?
(Thanks for the blog post btw!)
Also if I access my email largely from my phone, would I have any significant advantages?
That's the only feature I want Nylas Pro and it's not worth $12/mo.
(By the way, feel free to open a Github issue if you're encountering problems syncing your IMAP account: https://github.com/nylas/N1/issues/)
When no javascript is running the app consumes effectively no power.
Now that being said there's nothing to stop developers from running lots of expensive code or being non-performant with rendering. This is true in any environment. However; having access to the type of flame-charts and profiling tools that come with Chrome / Electron go a really long way to addressing some of these issues.
I work at Nylas and we've been heavily focused on reducing the amount of power the app consumes. We've still got a lot of work to do, but at the end of the day processing a ton of email quickly is a fairly expensive operation.
In the long run it's possible to offload very expensive work to natively compiled modules. A lot of Electron projects do this and can use Node's native bindings to connect to processes that really need to be fast in native code.
So if Nylas is parsing imap messages then both parsing and rendering difference between a native and eletron app will be big. Fortunately browsers workaround some of this problem by consuming json and stuff - formats browsers can natively parse.
Citation needed. Battery life with Safari on Mac or IE/Edge on Windows is easily twice that of Chrome/Chromium with the same tabs open.
Note: I'm not disputing that the Chrome team has put in significant effort, but rather that the results are anything above mediocre at best.
I guess I found a replacement for Thunderbird.
There was an amazing mail client for (of all things) FidoNet back in the 90s called GoldEd that was amazing. It had threaded message display, a great editor, pleasant colors, etc. It was tailored to that network, however. Would love to find something like this for console-based email that has the built-in editor and isn't Pine.
I obsessively measure wakeups/s in powertop for every application I use, and the above setup is very good.
If you want to try other things you can look into the mutt-kz fork (which replaces internal search commands with notmuch).
There is also a notmuch curses client, but I find mutt+notmuch superior.
Mu is a notmuch alternative worth considering. Their emacs client is excellent.
Finally, also if you use emacs, gnus is perhaps the most powerful email client ever. Steep learning curve, though. It's a bit different to everything else, as gnus has been built as a news reader. It treats mail as news, but this has some great advantages I think, as long as you can adapt your mindset. Also Org integration.
Gnus is the only thing that might make me switch away from mutt.
One day someone will build a good Electron app.
Every time I try to get someone to explain it to me I'm just met with a bunch of empty answers like "Yeah it just flows really well man". It seems like the JavaScript Everywhere fad came into being solely to fulfill the need of a lot of novices to feel smug and important against more reasonable people, who are just left with puzzled looks.
Visual Studio Code is very good in my opinion. It can be done.
Heck even my company-id has lots and lots of emails. Jenkins integrations notifications, travis, cron job failures and what not.
I naturally filter both my person and company accounts - so my Inbox is neat and tidy but I think we have reached a point where programmers/system devs/devops people will have to deal with tons of emails.
And yeah - I wish Nylas was better at dealing with this.
Never really compared their resource usage since I'm only in one Slack team 99% of the time and even the official app isn't that horrendous in that use case.
Which is somehow funny, since the whole supply chain is controlled by them (App, Browser, OS).
Have you considered an iOS or Android version client? Why?
Is the backend within Nylas Mail still in Python? Isn't this inefficient, performance wise?
The new sync engine is written in Javascript, which is faster than Python, but the main performance improvements came from changing the architecture.
Sorry, but that isn't a fair way of describing what occurred.
Nylas is a startup, trying to figure out a business model which works for them.
You're not yet forced to pay. If you had a Nylas ID back when Pro was announced you got a gratis year of subscription. Now, they released a gratis version once more, called Nylas Mail, which is also open source. The backend is also open source.
What this means is that they've adopted a freemium model, and you got approx half a year to still enjoy your Pro license.
I haven't done a feature comparison between Mozilla Thunderbird (which I know is not everyone's preference but was my previous cross platform e-mail client), Nylas Mail, and Nylas Pro. If anyone knows one, please share.
My main concern is the backend being hosted in US by a US corporation. I don't like my data being hosted by US corporations, on US soil, and I recommend non US-citizens/residents to care about this.
Well, uh.. that didn't quite go that way for me.
The Pro 'transition' was a miserable experience that made me stop using it altogether* - it literally popped up asking me if I wanted to subscribe to Pro, and if I said 'no' (thinking I'll just continue non-Pro) the whole app quit.
* Coincidentally I tried it out again (seemed to get a 14day trial even though I'd used it before) a few days ago. There's still lots I like; the Basic tier is exactly what I needed really - last year when it suddenly held my emails hostage (slight hyperbole of course, there were still copies on the server).
If you didn't, you had to pay.
Nylas Mail Basic was designed exactly with this in mind. It's a free client, syncs locally, and does not include a lot of the Pro features that power users save a lot of time with.
On the flip side, we've designed Nylas Pro (and its price point) for users who are coming from the productivity world of ToutApp or YesWare. The goal with Pro isn't to merely be another Thunderbird or Mac Mail. We're focused on building new powerful workflows for people who live all day in their mailbox, calendar, and address book.
(I build Nylas Mail)
Everyone uses email slightly differently. The plugins allow us to build Salesforce integration, tracking, templates, and mail merge for sales people, while offering an entirely different targeted set for other users.
We intentionally "don't move the cheese to far" from existing clients to ease transition. There are a lot of grand ideas for radically different email experiences that fall flat due to their deviation from the core experiences most people expect and need. We instead believe that a handful of targeted features to a targeted group gradually develop into a very different way to interact with email for a very specific use case.
(I'm an engineer at Nylas)
I'd rather lose Salesforce integration, tracking, templates etc. and get the basics right: going through the dozens of emails we get every day.
When we reply to emails we feel like we're being productive, but we're just taking time away from our actual job. If there's no easy way to easily differentiate between low priority and important emails—which Google Inbox does automatically by grouping them and letting you dismiss them all at once—you're not helping me.
Again, the product looks awesome, this is just my point of view I thought I'd share.
Inbox is homegrown, not an acquisition.
(work at Google)
It's what I use, and I've notices a good improvement over the web version (besides the fact that it's in the Dock, with unread count).
There's a helper that takes up about 300MB of memory, but it's stable at 300, never goes up.
(I work at Nylas)
Looking forward to it!
I think for this audience, this blog post raises more questions than it answers.
I'm a student, I can't justify $12pm (or $7pm) for an email client however good it is - but I'll gladly use the Basic version and continue contributing; pay a little back that way :)
https://www.dropbox.com/s/s37onyv41w91zi0/Screenshot%202017-...
I'm using a 2008 macbook as well and I don't have any huge problems with most apps. I do stay away from web-tech-based apps as much as I can though.
If I'm reading emails it means I'm not working or enjoying myself. And I'm not dev-ops, which means I'm not getting payed to keep the systems up and running at night.
I'm also practicing my own extreme version of "inbox zero". Whenever my Inbox reaches 100 emails, I select them all, mark as read, then archive. Information loses value as time passes and I figure that if there was anything important in there that hasn't caught my attention and that I did not answer, then one of my colleagues will surely buzz me about it. Worked fine thus far. And because I'm regularly removing noise, it means I have a higher chance of actually noticing important messages.
Writing this message reminded me that I've got 40+ unread emails in my Inbox. Marked as read, archived, now it's a solved problem.
Call me old-fashioned, but I still think words matter. IANAL so I don't know whether any laws are broken or not by such claims as "worlds greatest coffee", but there are truth in advertising laws on the books in the U.S. https://www.ftc.gov/tips-advice/business-center/guidance/adv... Even if there weren't, it erodes your integrity if you're not being truthful and the faces of the staff in the video clip are a nice balance between disbelief over Buddy's credulity and shame (particularly on the guy in the foreground). But I may be reading too much into this...
(Repeating here that I'm not claiming that Nylas' claim is false; I don't know if it is or isn't).
You could give the application away for free with a sub, while saying to Basic users they gotta pay for it.
The application Emby has the same model.
I think its fair. Me, I don't want more subs (and I'm not a business user so probably not your market). But I'm fine paying a (high) one time fee for an application.
My experience was I received a coupon via e-mail at june 15 2016. I upgraded the same day. But I also still use other e-mail clients to access my mail e.g. from my phone. So I would not be locked out of my e-mail if Nylas quit working that same day.
One of those apps was Lumosity, and I installed it. The first step was setting up an account. I promptly uninstalled the app, and to this day, I have no idea whether it is any good.
It felt odd to me that for a game with no multiplayer component would require me to sign up for an account, and I'm not interested in leaderboards or cloud based backup either. I have the same feeling about email clients, especially when Thunderbird exists and is mostly decent.
Giving up an email account for a free "app" (and not a service) continues to feel odd to me. It almost feels wrong to call it "free", especially since it is unclear to me how my email is used.
[1] - http://i.imgur.com/0eLhrAM.png
[2] - https://raw.githubusercontent.com/chergert/gnome-builder-web...
http://www.sabah.net.my/manuals/en/nscomm/images/messwin.gif
At $7/month, if this tool saves you 10 minutes a month, it's worth it.
I do really like Nylas, it's mostly a pleasure to use.
But I'm using it with Gmail which costs me like $2pm for 100GB storage; the core (with I think 20GB?) is free (at the point of use, blah-blah advertising).
Is Nylas, the thing through which I access my free/almost-free email really adding $12pm value? I'm not so sure.
For my reduced email needs, I mostly use K-9 Mail (Android) and self-hosted RainLoop (web). For work mail I use Outlook.
Which supported service is not already running in the USA and subject to NSLs? In what way is Nylas reducing your privacy?
A normal e-mail client doesn't suffer from this issue. Only if the user is hosting their e-mail traffic inside the US. You may think that's true for everyone, but that is your own bubble or tunnel vision. Say, you are working at the EP (European Parlement). You use Mozilla Thunderbird for your e-mail. Some of the e-mail you receive is internal from your party. The SMTP and IMAP server is hosted in your European country. Then, one day you switch from Mozilla Thunderbird to Nylas N1. Suddenly, your e-mail is not hosted in the EU anymore, and the US government can use a NSL to read your private data. You may not give a rat about this (and if you're from US I can fully understand), that's your discretion. Others do, and their viewpoint is not 'absurd'.
> Which supported service is not already running in the USA and subject to NSLs?
Any SMTP and IMAP server not hosted in the USA. You know, you don't have to use Gmail.
(Nylas Mail doesn't suffer from this problem. Only a few features still require Nylas servers.)
Quoting
>> You actually can add any IMAP server
Well, my own server?
And even if this was impossible, they could make their name in the body of the blog post a link to their website.
Such pixel are only used by newsletter or shaddy spam senders.
And of course, a lot of email clients only open such images on demand anyway.
http://blog.mailchimp.com/how-gmails-image-caching-affects-o...
Don't use medium for this purpose then, would be my answer. I also had an issue getting to the homepage. Obviously I managed to get there, but I almost didn't bother.
Good that Outlook and other mail apps blocks third party pictures by default.
Since Google's goal with this was clearly to defeat tracking, I would strongly expect the former, but I can't back this up.
But take a new daemon that talks a cross product of tls/ssl and three(?) protocols, is supposed to parse random emails, expose it to the Internet - and claim "no new security issues"?
Oh, how I whish that could possibly be true.
VS Code is not 'a very bad app'. If you know of a comparable app that uses fewer resources to a significant degree please let us all know and I'm sure we'll all switch.
Built in debugger is just one example that makes Vim not comparable to VS Code: https://code.visualstudio.com/Docs/editor/debugging
So I would assume you are hosed. The passwords need to be stored plaintext.
1. You never enter them into the client. It uses Oauth to authenticate.
2. By the comment here, it seems that they're using Google's Gmail API. https://news.ycombinator.com/item?id=13417904
Oauth makes sense that there's no password saved. A unique key is saved which is authenticated with Google. If this key leaks, you are hosed, too, but at least you can revoke that key.
I tried grep mypasswd ~/.nylas-mail/* and grep said Binary file shared.sqlite matches. This did not occur in ~/.nylas it makes sense and it is inevitable, a client like Thunderbird suffers from the same.
It can be circumvented by saving the password encrypted and decrypting it using a master password. That is akin to how LastPass and Mozilla save their cloud data.
Using containers etc would also lower the threat.
In a way its good the password is saved locally. The engine also runs locally. It moves the threat model to the client, away from Nylas servers. Kudos.
I can think of one email client with ~15 million users that does that.
K9, gui Android (think it blocks by default, or I turned off auto load when I installed ages ago).
https://support.google.com/mail/answer/145919?co=GENIE.Platf...
Its faster than Ruby, Python and PHP by a mile.
It now has async/await.
The amount of work that goes into making it good for front-end apps is amazing.
It has a fairly large ecosystem.
Dynamic / unityped nature lets you prototype quickly.
Tooling such as TypeScript lets you switch to static types when being dynamic just wont cut it any longer. Oh, and TypeScript has generics! (can't believe thats still a differentiator in 2017)
TypeScript can typecheck JSX templates.
It has PureScript for when you want even stronger type-checking and abstraction powers.
It doesn't have: multicore green threads (probably not going to happen) and large ints (coming soon).
Here, have a look at https://facebook.github.io/reason/ and https://facebook.github.io/reason/modules.html and see how many equivalent features it provides using just lexical closures and free-form objects (the TypeScript overlay can also approximate some features of algebraic datatypes via tagged unions and control flow analysis)
Really, the JS sucks meme is getting old, fast. Sure there are more powerful languages and higher quality ecosystems, but its quite far from being "the worst".
In particular, I didn't realize how much faster V8 is than the reference implementations of similar languages. That can be a real and significant usage consideration and makes me less hostile to things like desktop apps. I've been operating from the "JS is slow" pre-V8 perspective, and while I knew V8 was a massive speed-up from the web perspective, I didn't consider that it was actually now among the fastest dynamic languages for non-web uses. That's a great point that should probably get promoted more often.
I still dislike a great deal about the methods and culture in the community and wish that such optimization would be directed at what, in my mind, is a more worthy target, but I know of a concrete rationale now. Thanks!
All the fixable weirdness has been fixed. Even `this` has been mostly fixed by arrow functions. It still has implicit conversions, but hey, typescript and flow make that irrelevant because they'd check statically for those.
What else is so bad about JavaScript? I really don't get it.
The DOM... thats another story.
Keep in mind I don't agree with the above at all, but this is what a lot of people believe.
That's plainly wrong.
The list of praticals client-side language on the web is actually pretty vast: https://github.com/jashkenas/coffeescript/wiki/list-of-langu....
Of course you can't write a piece of, say, typescript, and just include it in your HTML and call it a day. You need to compile it first, and you need some tooling for that, but it's not different from using a C++ compiler for building a Qt application.
> Every time I try to get someone to explain it to me I'm just met with a bunch of empty answers like "Yeah it just flows really well man".
Well, actually it flows really well indeed :)
I wish exist a native renderer that could use a (saner, better) subset of html/css that fit the same use case, then let us use any better language for the logic.
Probably OpenGL toolkits are the idea, but it way to operate and looks are weird.
Qt perhaps is holding up the best, but I can see why people prefer Javascript's event model to Qt's.
Pointing out that old toolkits still exist doesn't necessarily help when people expect more from their toolkit now.
Of course it's not.
> There is no reason to use JavaScript just so you can get a "cross platform GUI".
The main reason (imho) is that "JavaScript" (as you call it, but you should say "the web platform") is more future proof than "old toolkits".
Qt would be the best candidate for a "cross platform GUI", but you are relying on the [Qt company/nokia/whatever] for its continuation.
When you choose html/js you choose a standard used by virtually every single person with a computer nowadays. There is far less chance that html/js will be killed someday, like Microsoft killed WPF or like IBM made SWT an abandonware, because nobody is in that position and this whole World Wide Web thing rely on it.
Not get me wrong, I don't like much JS/html apart as be hostage as everyone else to use it in the web, but is clear that as far to build the GUI is way more enjoyable than most GUI toolkit.
The application involved a few components that were going to be quite complex and I wanted many of the basic components to have slight customizations. This turned out to be quite a bit more difficult than I thought.
The numerous issues that I encountered in 3-4 weeks (part time) of native development for MacOS included
* Xcode support for swift is garbage. Highlighting, code completion, and general responsiveness are far lower than even web based editors. Also no refactoring.
* Lack of documentation in swift + cocoa + appkit
* Lack of documentation for swift 3. Many examples were from either iOS (not everything is equivalent) or from older versions of swift (a lot has changed in 2 years apparently). Even basics of naming have changed a good bit.
* There was a lot of magic going on in xcode with storyboards / interface builder. When something broke it was very difficult to figure out what went wrong in the storyboard. The generated code from the storyboards is useless to look through. The difference between code working or not could be me forgetting to option + click a part of interface builder to a certain line in my code, with little or no indication of whether it had been done correctly, or what needed to go where, particularly with certain appkit components.
* Dependancies are a heck a of a lot harder to manage. I don’t know why but I ended up using Cocoapods and it was a total mess.
* Many core UI components requiring me to extend them or recreate them for basic functionality that would be a single line of code/xml/css on other platforms. Components that are common in other desktop applications don’t seem to be included in AppKit (some are including in UIKit though)
I ended up scrapping the idea of doing it natively and decided on Electron + React + Typescript. It was a lot easier to aquire and intergrate dependencies, the development enviroment is a lot faster, there’s no magic connecting my UI together, and it’s actually easier to recreate customizable, native looking components with css + js than it seems to be in AppKit. On top of that I won’t have to build a seperate windows app. Realistically my app currently looks and performs better than any competing app (many of which are legacy java+swing apps) and is a lot faster to iterate on.
Until recently, and I know the "front-end devs" are going to have my head for this, but until recently, there was hardly any serious JavaScript coding going on even on the client-side. That means it wasn't something that a new developer would really stumble across and just start using to build full-fledged programs.
JavaScript's main use was extending web widgets to do things slightly more conveniently. All the heavy lifting would be behind the scenes and JavaScript would watch you type so it could autotab for you. So I don't think the explanation that there was a vast knowledgebase eager to break into the backend is plausible.
JavaScript was so disliked from horrifyingly frustrating exposure throughout the IE6 days that no one would go near the thing unless they were wrapped in the jQuery condom. John Resig was a hero of legendary bravery for biting the bullet and making JavaScript semi-usable.
Someone had to write a book called "JavaScript: The Good Parts" that openly acknowledged JavaScript's inherent inferiority but tried to cheer us up by saying "Hey, I know we're stuck with this because browser vendors will never be able to agree on something else, but there are some hidden cool things about it! Don't cry!"
Somehow in the last 5 years or so, JavaScript has gone from something that required a prophylactic device before anyone would approach it to something that real companies are writing production _DESKTOP_ applications in. What the heck happened?
(I think The Good Parts is probably the real turning point here, where it became OK to treat JavaScript as a non-joke, and that V8 accelerated it. But people took Crockford's feel-good apologia and ran way past the finish line with it.)
They will then naturally choose the convenient-for-them known quantity and dismiss concerns regarding usability, performance, etc.
I don't see a real trend toward building apps using web technologies, but there is a lot of noise, making the topic seem larger than it is.
PHP would like a word.
With JavaScript transpilers, this happens in reverse; there is an entirely separate secondary language loosely bolted on here, which compiles to JavaScript, which compiles to some IR, which compiles to machine code. From the developer point of view, the code they wrote in the top-level language executes as JavaScript, not native code, and must be debugged at that level.
I'm sure you're not actually naive enough to pretend this is the same as using a library like Qt. Language semantics are very different and can be difficult and bug-prone to cross-implement. Third-party libraries and modules have large, potentially interdependent module webs that have to be resolved and will often result in massive includes on such transpiled pages (talking 10M+). Bugs at runtime will have to be debugged as the transpiled language, not as the code you originally wrote.
If you use Qt, everything is written in the same language, built by the same compiler, and that language's typical pipeline, including dependency resolution, is unaltered. Bindings in non-reference languages link out to shared objects that do not use transpilation, but long-established and well-understood OS-level linking conventions. This is a greatly reduced complexity surface (== fewer bugs).
My experience with transpilers is that people avoid them whenever possible because they introduce very intricate and difficult-to-use bugs. Now that I think of it, the most well-known transpilers are specially-made to service a large project's needs, like the recently-announced Grumpy [0], which converts YouTube's Python codebase to Go.
Wrong, source maps solves that problem well enough. Granted, it's not as coherent as a single compiler, but yet, it works.
How can JS be more future-proof than old UI toolkits when JS libraries and frameworks are constantly changing? Sure, nobody will kill HTML and JS, but that's not the point. Nobody knows how UIs will be built with web technologies in two years!
Edit: based on your reply below, it looks like I have to spell it out. GUIs are built with UI frameworks, not just with programming languages and markup languages. JS frameworks are so short-lived that one can't be sure if their code will still work in one year.
That is the opposite of future-proof.
Yes, it is the point. Nothing more, nothing less.
> Nobody knows how UIs will be built with web technologies in two years!
You can't say that things like es6/react/typescript/clojurescript will be plain gone in two years, there's too much real momentum behind these things.
The crop of JavaScript derivatives are probably not going to disappear, but riddle me this: while there are many variations on JavaScript's syntax, why do other languages that are arguably JavaScript competitors, like Ruby and Python, not have the same wide selection of alternate syntaxes and sugar packets? Could it have something to do with the usability of the default dialect?
I personally think it's a bad sign when so many people feel they need to write a transpiler to add some syntactic and behavioral enhancements. The language should provide a functional, livable set by default, at least good enough that writing a transpiler doesn't sound like the time-effective solution.
I don't understand ASM.js very well but it sounds like it's a new type of bytecode that allows programs written in many different languages to be executed in the browsers' JavaScript VM. If this truly bring us first-class support for non-JavaScripts (which won't be real until browser vendors either ship or make it transparent and automatic to install additional DOM bindings), I will be so happy. I will also be curious to see if it has any impact on the popular use of JavaScript itself -- the node buzz already kind of seems to be fizzling out and moving onto things like Go, so maybe we won't have to wait too long.
Ok, so let me spell this out too (frameworks/librairies mixed):
- jquery: 10 years
- backbone: 6 years
- angular v1: 6 years
- ember: 5 years
- react: 3 years
Quoting from wikipedia:
> Qt 5 was officially released on 19 December 2012. This new version marked a major change in the platform, with hardware-accelerated graphics, QML and JavaScript playing a major role. The traditional C++-only QWidgets continued to be supported, but did not benefit from the performance improvements available through the new architecture.
Versioning your dependencies is good practice regardless of language and has been for decades. Javascript has enough cons, you don't have to resort to imaginary ones.
It can't be that web developers have been bitterly complaining about how poor HTML and CSS are at building UIs for years and years and suddenly it's become easy and enjoyable.
Actually it has become easy and enjoyable ;) Even for complex UIs.
Just think seriously about what a stack like es6/React/Redux brings on the table against plain old ES5, and you'll be struck by how well things have become.
Literally the description on GitHub, and a very similar line is the first line in the README. I admit that I have not tried Grumpy personally and do not have any real experience with it. My knowledge on it mostly comes from the HN discussion a few weeks back. It is absolutely possible, even likely, that I'm getting things wrong here. Would you kindly correct my misconceptions? Thanks.
The "runtime" comes in at this point. It sounds like `grumpc` compiles Python objects down to stubbed-out Go objects, which depend on the functionality implemented in grumpy for the implementation of those stubs. "The Go code generated by grumpc performs operations on data structures that represent Python objects in running Grumpy programs."
To me, this mostly sounds like a Python->Go transpiler with special hooks to more easily facilitate Pythonic access in Go. If anything, it seems to support my original point that transpilers are custom-built even more; from my high-level and probably wrong reading, it looks like instead of a full-scale Python-to-Go transpiler, Grumpy's developer realized it would just be easier to implement if he made the programs dependent on his "runtime", which he could freely do because he was running his own project on it and he can execute that project through `grumpy` just as easily as he could through anything else. Such options would probably not be available to someone who was tasked with writing a generic Python-to-Go transpiler that was expected to work anywhere that Go works.
I also could be misreading this, because again, I've never used it, and maybe by "runtime" the author really does just mean "library", and it all compiles down to a standard Go application. That'd be cool.
[0] https://github.com/google/grumpy/tree/aa58aa68717f6ac2ebf40f...
Totally granted, the web platform suffer from a very bad reputation. And what does not help at all is that one need to carefully choose his tooling among a zillion of short-lived, hyped github repos.
But there is future-proof gems for those who invest the time in trying and learning. In a jumble: React, Redux, Reagent, Re-frame, Typescript, Clojurescript, Om, Immutable.js, Om.next, and so on.
Popularity, and the fact that things were very bare-bones before ES6.
> If this truly bring us first-class support for non-JavaScripts (which won't be real until browser vendors either ship or make it transparent and automatic to install additional DOM bindings), I will be so happy
Interop with existing JS code/data(structures) will still be a problem. Shipping (or rather, not re-shipping every single time the user vists) your favorite language's runtime and standard library will become a problem (which can be solved). By that time JS will be good enough to make it even less worth it, especially for dynamic/GCed languages.
> the node buzz already kind of seems to be fizzling out and moving onto things like Go, so maybe we won't have to wait too long.
This is true. There hasn't been anything new happening in node land for quite a while now, and the basic core platform is showing its age. With tools such as typescript, async/await and generators available, however, a revival is possible. TS tooling combined with a well designed and documented "core standard library" in the style of Dart's stdlib could make node a very nice platform again.
You focus too much on ES5. It's not about the language, it's the platform.
It can't be performance, because Electron is slow. It's not conservative power usage, because browsers are power hungry. It's not disk space or memory usage either.
Nor is it a native-looking UI. Nor security. Nor privacy. Nor accessibility.
The only thing I can think of is that it's free and allows the typical web developer to avoid learning anything new.
NPM, even if it has plenty of do-not-use-that-packages crap, is still far more furnished that Qt will ever be, for example.
> The only thing I can think of is that it's free and allows the typical web developer to avoid learning anything new.
One could say the same for the typical Qt developer that refuse to get serious in learning the web platform.
By comparison web front end devs tend to cling much more tightly to their favored language+toolchain, taking it with them to every platform they decide to develop for.
Ignoring arguments, aggressive advocacy, "you too"s, asserting that web technologies are great in the face of so much evidence to the contrary and most of all, insisting to use the same inadequate tools for everything from desktop to mobile to embedded.
I've been having the same discussion for six years with different characters now. One thing has never changed - web apps consistently show poorer quality than their native counterparts, especially in performance, resource usage and usability.
The software this community so focused on PR and advocacy is building is not good in spite of the bragging.
And regarding your arguments:
* Java, C++, .NET, Python, etc can claim having ecosystems. JS has a continuously churning collection of libraries. Nothing has been forgotten.
* a lot of Qt developers use it where it makes sense by bulding hybrid apps or together with QML.
This has not been true for years now. There is a native port of Gtk that does not require an X server. Gimp is available natively, as are other Gtk apps (Gnucash, Deluge, etc).
Gtk has been ported to macOS in 2007. You don't need an X server anymore :)
Don't get me wrong, I'm actually a nice guys who has nothing against Qt/C++. I'm glad it exists because I can use it when what matters is power usage, native looking UI, security, privacy and all. It's just that I don't, personnaly, need those requirements.
> The only thing I can think of is that it's free and allows the typical web developer to avoid learning anything new
I'm sorry but this is simply wrong. And I think you don't need to show disregard to "typical web developers" when you're trying to make a point.
What do you choose when you need to quickly throw an MVP in front of a customer? Surely not C++/Qt (well, maybe yes if that's the only platform you master).
When you need a web-looking UI ? Not C++/Qt.
When you need to easily deploy on hundred's of windows workstations at a plant where IT is blocking you from installing anything on said workstations? A web app, not a C++/Qt client.
So, you see, maybe the web platform also has it advantages when you start looking outside of what you do everyday for a living.