Compile a list of Aleph users

[ztellman]

We'd like to get a list of companies/organizations using Aleph in production (and which pieces of Aleph they're using), both for bragging rights and to understand who the stakeholders are in future design discussions. If you're using Aleph, please respond to this issue with any details you can provide.

[mccraigmccraig]

we (yapster) are using aleph via juxt/yada

we have an http rest/json api, and also use websockets quite a lot. we do multipart upload with the implementation that yada provides. we're heavy users of manifold deferreds and streams

[edit] oops - we use the http client a fair bit too

[gsnewmark]

We're using following pieces of Aleph at Attendify:

• HTTP client: mostly internal inter-service communication, as well as using REST APIs of internal data storages
• HTTP server: both internal services and public-facing APIs (a variant of JSON-RPC in both cases)
• Multipart support
• WebSockets (only for the internal chatbot)

We've also tried proxy support in the HTTP client, but not using it in production yet.

Not directly connected to Aleph, but quite a lot of our code also uses Manifold's deferred to define async operations. We're not using streams that much though.

Edit: corrected usage of WebSockets.

[piranha]

Kasta uses Aleph for the following:

• HTTP server: our web servers use Aleph.
• HTTP client: we have some (not much) internal communication through HTTP APIs, where we use Aleph as client (together with multipart support).
• Websockets: public service, where we provide current information on product stocks. Every client (be it web or app) opens a connection to websockets, so they sustain some load.

[danielcompton]

Deps (private Maven repository hosting) is using Aleph for the main web application and handling uploads. Downloads go through Varnish. All of the usage of Aleph is via juxt/yada which also makes heavy use of Manifold.

Our use is pretty basic, just an HTTP server, no web sockets or HTTP client.

[jhimanka]

Priima LMS uses Aleph as a ring-compatible HTTP server. Pretty basic functionality now but we are looking into asynchronous cases and Manifold.

[wzimrin]

organizetogether.com is using the aleph web server as our main web sever, and all of our server code is built around manifolds. We're also using the aleph http client to talk to external services whenever reasonable (mostly because it uses manifolds). We're using sente and sente's aleph adaptor for websockets.

In practice, our server code is built around manifolds, then we convert the resulting manifold-based handler to a cps style so we can use ring middleware, and then we convert the cps style handler back into a manifold based one in order to pass it to aleph. It works, but the result feels a tad clunky.

[jcf]

A number of companies and clients I’ve worked with use the Aleph HTTP client and Manifold in production, and a small number of clients used Yada (which as already mentioned is built on top of Aleph).

Aleph and Manifold will play a role in some of my upcoming work, and I’m happy to discuss some of the details privately if that would be helpful.

[ztellman]

@jcf feel free to contact me with any details you're not comfortable sharing publicly

[scramjet]

Systematic is using Aleph in production for both client websocket connections, and for serving web pages at signup (+ Ring + Hiccup + Garden).

We're making active use of Aleph's async request/response support in Ring, and Manifold's integration with core.async (most of our async logic is in core.async, although we'll likely experiment with using Manifold directly at some point).

In future, we'll likely also use Aleph for providing a B2B REST API for our clients.

We love Aleph for many reasons, but it's especially nice for us because we already have a heavy investment in Netty for our other backend services (APNs, DNS, etc).

[jaju]

I'm using the http part for a client that is in "soft" production mode right now. (Can't reveal the name, but will ask). I expect to use manifold soon in another part.

[danjohansson]

KPSystem in Sweden is using the following Aleph functionality: webserver, client, websockets and multipart. We are very happy with it!

[alexander-yakushev]

Grammarly uses Aleph in a part of its backend stack. Things used substantially: HTTP server, HTTP client, asynchronous flows with Manifold, fine-tuned and monitored executors and pools.

[pyr]

Hi!

After a detour through some direct Netty interaction - mostly as a learning exercice - Exoscale now defaults to aleph and manifold for the following in Clojure:

• RPC servers and clients
• HTTP servers and clients
• Most database clients
• The up & coming exoscale api client library in Clojure is purely async thanks to aleph and manifold for instance.

Thanks a lot for your work!

[rborer]

Finity.ai is using Aleph for our internal counters & events component. Aleph HTTP server is used there, responding to roughly 7.5 million requests per day.

We also have started work to transition our web crawler (crawling ~ 26 million URLs per day) from our venerable internal Netty 3.10 wrapper into Aleph. It's a long process as I realized that our current execution model had a few quirks. It's currently running on our testing infrastructure and I intend to deploy it to production beginning next year (I still have to figure out why it gives an OOM every few days of runtime...).

We're also relying a lot on manifold for our whole stream processing platform (which is really awesome btw!).

[superstructor]

@flybot-sg (Flybot Ltd, Singapore) is using it for our HTTP+WebSocket APIs for all sorts of multiplayer game services. Clients are built with the Unity game engine.

[fmnoise]

Eventum (https://eventum.no) is using Aleph for HTTP(servers and clients) and SSE. We also use Manifold for async flows.

[lvh]

We (Latacora) use Aleph/Manifold for some software that talks to AWS a bunch. (It's not a particularly judicious use of Aleph, since it's all blocking AWS SDK goop under the hood.)

[jeroenvandijk]

At adgoji, we're using the Aleph http server as the main http endpoint of our realtime bidder, running on 50-100 servers.

We use Engulf, an application that is build upon (an older version of) Aleph, for load testing. We are using yada in several of our internal endpoints. We use manifold in a lot of our async code as it is more composable than core.async.

[miikka]

At Metosin, I'm using Aleph in one project (a SaaS application) as the HTTP server and I've written some HTTP API clients with it as well.

[dev-smx]

Smxemail uses Aleph for our internal HTTP APIs to the components of our email archive and analytics products running on Azure.

[csm]

At Noon Home we use Aleph in a number of publicly-facing and internal HTTP services; we also use the HTTP client for communication between services. We use the TCP server, with TLS, for all communication with our devices in the field, and use TCP client and server for an internal message queue we developed in-house.

To expand a bit:

• Our public and internal HTTP servers are RESTful services, and they serve mostly very small requests/responses (JSON, and some GraphQL and MessagePack). We use compojure-api with a handful of hacks to let us do async responses. We front these with load balancers in AWS (terminating HTTPS at the load balancer).
• Our HTTP client usage is internal, using some of the above RESTful APIs.
• Our TCP services (device-facing and message queue) are both custom binary protocols. We leverage some Netty internals here, to do things like message framing. We formerly used gloss but migrated off that some time ago.

[aengelberg]

At Amperity we:

• use the Aleph HTTP server for our externally-facing microservices, wrapped with Yada to give us routing and some more HTTP features for free.
  • largely dealing with small payloads, but we have a couple of file-upload endpoints that exercise Aleph's streaming capabilities and parse multi-part form data.
• batch-load data to/from various external APIs with the Aleph HTTP client.
• use Manifold deferreds and async composition religiously around the codebase, even for our internal microservices which are backed by finagle-clojure, not Aleph.

[bostonaholic]

At CircleCI, we use it in a few different services. As of yet, we are utilizing only aleph.http/start-server for some internal and externally exposed services. Routing handled by ring and compojure.

[shayanjm]

We use Aleph at Watchful to power our RESTful API and SSE streaming interfaces!

[loomis]

SixSq uses Aleph for its core ring handler in its (micro) services. We also indirectly use the client indirectly through the kvlt library. As kvlt is deprecated, we will likely use the Aleph client directly in the future. We use the streaming features of Aleph via SSE in some parts of our RESTful APIs.

[tanzoniteblack]

At Yummly, we use aleph (via yada) for the API responses that drive our smart oven & app integration (Whirlpool new release on this), but currently don't actively use it to make http requests or to serve the traffic that runs our website (we use http-kit for that).

We are, however, starting to become very heavy users of manifold in our main API.

[mrijk]

VakantieDiscounter uses Aleph (as http client) mostly for async calls to our internal API's, as well as asynchronous flows with Manifold.

[bhurlow]

We use Aleph at yellowdig for general HTTP server needs, as well as streaming for large data sets

[rgm]

Using aleph with ring/reitit at opengb for some fairly straightforward SPA backends.

[JarredLHumphrey]

We use Aleph at Adaptly (recently acquired by Accenture) as an http client for high volume requests to 3rd party apis.

[ztellman]

I've just been told there's the possibility of Clojurists Together sponsoring work on Aleph. If anyone has pain points they'd like to see addressed in Aleph, or is interested in having their own work on Aleph being sponsored, please contact me.

[borkdude]

Aleph is used at https://drevidence.com in combination with yada.

[vigneshsarma]

We the Identity team at SAP Concur uses Clojure and aleph in many of the services we run. We use both the HTTP client and server.

[cddr]

It has recently been introduced in the testing component of Funding Circle's kafka library (https://github.com/FundingCircle/jackdaw). We use async http requests to exercise tests against the confluent rest proxy, and just ported the internals of the test-machine which uses manifold to improve e2e test resiliency.

[johanatan]

I’m using Aleph’s ‘http client’ and Manifold’s ‘deferred’ for my personal software projects.

[ryuuseijin]

Atlassian Confluence's collaborative editing service Synchrony is using aleph and manifold together with core.async. Aleph is used for websocket support, to talk with browser clients as well as for communication within cluster nodes.

Aleph streams are hooked up on the edges to core.async channels and most of the logic has been implemented in core.async. In restrospect I think it would have been better to embrace aleph streams more fully as they are a richer abstraction and better to work with than core.async channels.

Aleph has been working very well at a relatively high scale (10s of thousands of messages per second).

[lispyclouds]

Zalando's in-house Continuous Delivery Platform is using Aleph as the server to implement the CI/CD service.

It serves as the main entry point into the entire service, serves out the GraphQL API and maintains long connections to various services and performs well with less resources consumption.

[taurauko]

Teachme Biz uses Aleph for its Salesforce connector service.

[jeaye]

We at OkLetsPlay use this for our in-house Firebase alternative.

[ztellman]

I've opened an issue with @clj-commons to discuss the possibility of formally handing off stewardship of this project: https://github.com/clj-commons/meta/issues/59. If anyone in this thread would like to potentially become a maintainer, please say so in that thread. I would be happy to spend whatever time is necessary to get the maintainer (or, ideally, maintainers) up to speed on the internals of the library.