Hello.

I'm a frustrated user of email, currently using GMail's webmail but want to 
use a local email client. The issue is that most email clients can't work 
reliably and in usable ways with my 900K+ email accounts.

Excuse me for being too verbose, unordered mess and probably being wrong in 
many aspects, including descriptions or suggestions. I just want to open a 
debate and see the possitilities of the ecosystem behind JMAP, nothing else.

What's the current status about JMAP? 

Are there efforts to make clients support it? From my biased POV, I would 
like to see: Thunderbird ( 
https://bugzilla.mozilla.org/show_bug.cgi?id=1322991 ), Evolution, KMail, 
Claws Mail, Zimbra Desktop (webapp), NeoMutt (WIP fork available 
https://github.com/robn/neomutt/tree/jmap ), Alpine ( 
http://repo.or.cz/alpine.git ), Geary, Apple Mail, Opera Mail, Balsa, 
Citadel/UX, Elm ME+ ( http://www.elmme-mailer.org ), GNUMail, Gnus (emacs), 
IBM Notes, IMP, Inky, Mailpile, Pegasus Mail, SquirrelMail, Sylpheed, K-9 
Mail ( see https://github.com/k9mail/k-9/wiki/Google-Summer-of-Code-2017 ), 
The Bat!, Trojitá, YAM ( https://github.com/jens-maus/yam ), Unibox ( 
https://www.uniboxapp.com ), Mail Pilot, Airmail ( http://airmailapp.com ), 
MailMate ( https://freron.com ), Postbox ( https://freron.com ), Polymail, 
Nylas Mail, Spark, Canary Mail, Mulberry, Mailsmith, Foxmail.


My (possibly wrong) point of view about how to make JMAP more popular and 
supported:

- Provide not only updated specs (as Vulkan does, for example), but also 
reference implementations (extremely robust, extremely reusable, extremely 
portable, extremely up-to-date, extremely resource efficient) for a wide 
variety of programming languages (such as CommonMark, Rosettacode.org code, 
Protobuf, https://raft.github.io/#implementations , smaller projects like 
https://github.com/bengsfort/8-puzzle-solutions 
https://github.com/biotool-paper/biotool 
https://github.com/kad-ecoli/pdb2fasta 
https://github.com/apauley/HollingBerries 
https://github.com/troeger/corba-example): Maybe you could automatize the 
task by using something like Quark ( https://github.com/datawire/quark ) 
but supporting more programming languages (Web Services Description 
Language? Web Application Description Language? OpenAPI Specification? Open 
Data Protocol? GData? Resource Description Framework? JSON-LD? JSON-WSP? 
CWM (Notation3? N-Quads?)? Open Service Interface Definitions? Messaging 
Open Service Interface Definition? Protocol Buffers? Apache Thrift? RESTful 
Service Description Language? Web IDL?
** What about *Advanced Message Queuing Protocol? Blocks Extensible 
Exchange Protocol? Distributed Data Management Architecture? Distributed 
Relational Database Architecture? **IPFS? Message Queue Telemetry 
Transport? Constrained Application Protocol? Web Application Messaging 
Protocol? MessagePack? BSON CBOR? JSONB? Smile? UBJSON? Protocol Buffers? 
ZeroMQ? Nanomsg? Enduro/X? Gearman?*

* Ada: A structured, statically typed, imperative, wide-spectrum, and 
object-oriented high-level computer programming language, extended from 
Pascal and other languages. It has built-in language support for 
design-by-contract, extremely strong typing, explicit concurrency, offering 
tasks, synchronous message passing, protected objects, and non-determinism. 
Ada improves code safety and maintainability by using the compiler to find 
errors in favor of runtime errors. Ada is an international standard; the 
current version (known as Ada 2012) is defined by ISO/IEC 8652:2012. It's 
the "military language" because it was designed by contract by the DoD, but 
it's used in many other safety-critical systems (avionics and air traffic 
control, commercial rockets such as the Ariane 4 and 5, satellites and 
other space systems, railway transport and banking). SPARK is based on Ada 
too.
* Brainf$ck and Malbolge: I'm joking here! But esoteric programming 
languages would provide fun by many twisted programmers and maybe testing 
the protocol in weird ways.
* C: A general-purpose, imperative computer programming language, 
supporting structured programming, lexical variable scope and recursion, 
static type system. Used in embedded devices, operating systems, 
supercomputers and more.
* C++: A general-purpose programming language. It has imperative, 
object-oriented and generic programming features, with facilities for 
low-level memory mani. The quite known evolution of C to become an object 
oriented language. Widely used too, from embedded to supercomputers.
* C♯: Microsoft's competitor to Java. It's a strong typing, multi-paradigm 
(imperative, declarative, functional, generic, object-oriented 
(class-based), and component-oriented) programming language. It's widely 
used in Microsoft software, web, enterprise and others.
* Go: Google's free and open source programming language. It's compiled 
(and got GCC support), statically typed language with garbage collection, 
limited structural typing, memory safety features and CSP-style concurrent 
programming. It's becoming quite popular too (13th at TIOBE).
* Haskell: A standardized, general-purpose purely functional programming 
language, with non-strict semantics and strong static typing. It's widely 
used in academia and also used in industry (Facebook uses it). 
* Java: A concurrent, class-based, object-oriented programming language. A 
popular language in enterprise and mobile due to Android. There also 
embedded versions of it.
** What about RabbitMQ? Google's Guava? Spring AMQ?

* JavaScript: An high-level, dynamic, weakly typed, object-based, 
multi-paradigm ( event-driven, functional, and imperative (including 
object-oriented and prototype-based)), and interpreted programming 
language. The language of web, but now used as a RAD one too.
* Julia: A dynamic, high level programming language. It's  effective for 
general-purpose programming, web use and specification language. It has a 
type system with parametric polymorphism and types in a fully dynamic 
programming language and multiple dispatch as its core programming 
paradigm. It allows concurrent, parallel and distributed computing, and 
direct calling of C and Fortran libraries without glue code. It's designed 
with supercomputing in mind.
* Lua: A lightweight, dynamically typed, multi-paradigm programming 
language designed primarily for embedded systems and clients. It's widely 
used by game programmers as a scripting language.
* Objective-C: Apple's general-purpose, object-oriented programming 
language. It adds Smalltalk-style messaging to the C programming language. 
* OCaml: It's multi-paradigm: imperative, functional, object-oriented. It's 
an evolution of Caml. It features static type system, type inference, 
parametric polymorphism, tail recursion, pattern matching, first class 
lexical closures, functors (parametric modules), exception handling, and 
incremental generational automatic garbage collection.It has a large 
standard library. Despite it's strong usage in academia, it's also used by 
many important projects ( Flow, Infer, and Pfff by Facebook. Haxe compiler. 
Xen Cloud Platform, Citrix Systems' XenServer, Unison).
* Perl: An high-level, general-purpose, interpreted, dynamic programming 
language. Aren't there one now? :)
* PHP: Used in lots of web apps, many of them being web email clients.
* Python: A widely used (top 5 at TIOBE) high-level, general-purpose, 
multiparadigm (object-oriented, imperative, functional programming, 
procedural, structured, aspect-oriented, reflection) programming language. 
With a very wide variety of libraries and multiplatform. It's used in a 
broad rane of use cases including embedded and web (Reddit is entirely 
written in Python, Dropbox uses it, etc).
* Ruby: A dynamic, reflective, object-oriented, general-purpose, multiple 
programming paradigms (including functional, object-oriented, and 
imperative) programming language. There's a web framework for it, called 
Ruby on Rails.
* Rust: A systems programming language sponsored by Mozilla Research. It's 
designed to be a safe, concurrent, practical language that supports 
functional and imperative-procedural paradigms. It's syntactically similar 
to C++, but designed for better memory safety while maintaining 
performance. It's used by the Servo project (parts of it are progressively 
merged to Firefox) and these days it's gaining a lot of market and 
community acceptance.
* Lisp and dialects: Scheme, Common Lisp.
* Swift: Apple's general-purpose, multi-paradigm, compiled programming 
language. It aims to be the sucessor of Objective-C. It's got quite popular 
(top 10 in TIOBE index).


Also, don't forget:
- Protocol Implementation Conformance Statement.
- Conformance test suite: Strict testing tools to check the implementation 
conforms the "standard"/expected behavior (I hope it gets accepted by IETF, 
then ISO). 
* There are stuff for this such as ETSI/ITU-T TTCN-3 ( 
http://www.ttcn-3.org ): Used by SIP, WiMAX, DSRC, Open Mobile Alliance, 
AUTOSAR, 3GPP...) by test cases, interoperability testing and more.

Are there email service providers interested in JMAP in both the evolution 
and implementation of it in their services other than Fastmail itself? What 
about Google, Yahoo and others?

What about the Mailbox format? Maildir is (not so) okay, but don't offers 
indexing. Other formats put all the messages in one large file, that seems 
hacky as hell. What about MIX ( 
http://repo.or.cz/alpine.git/blob/HEAD:/imap/docs/mixfmt.txt 
http://repo.or.cz/alpine.git/blob/HEAD:/imap/src/osdep/unix/mix.c 
http://repo.or.cz/alpine.git/blob/HEAD:/imap/src/osdep/amiga/mix.c 
http://www.washington.edu/imap/documentation/*mixfmt*.txt.html 
https://www.mail-archive.com/[email protected]/msg01802.html )? MIX 
is indexed and offers many features? It seems Dovecot's multi-dbox seem to 
offer somewhat similar, but I'm not sure. I firmly believe there's need for 
a new standarized Mailbox format designed to be highly scalable, from small 
devices to big datacenters.

Interesting conversation about GMail API and IMAP, despite it's many years 
old: https://news.ycombinator.com/item?id=7945798
Another one: Thunderbird's Future Home 
https://news.ycombinator.com/item?id=14299022
Proposal to start a new implementation of Thunderbird based on web 
technologies: 
https://groups.google.com/forum/#!topic/tb-planning/SPs8gzO5Wy0%5B1-25%5D 
Interesting part -> "Email is rife with buggy implementations and *has no 
general conformance testsuite*, so you're not going to find problems until 
you get actual users with their weird edge cases"
Proposal to start a new implementation of Thunderbird based on web 
technologies: https://news.ycombinator.com/item?id=14156251
More about Thunderbird here, with many interesting discussions: 
https://groups.google.com/forum/#!forum/tb-planning


Kind regards.

-- 
You received this message because you are subscribed to the Google Groups 
"JMAP" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to [email protected].
To post to this group, send email to [email protected].
To view this discussion on the web visit 
https://groups.google.com/d/msgid/jmap-discuss/c4d09145-aa5b-471c-8cc6-094203ecf249%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to