Bargad - A Data Integrity framework for building efficient #blockchain (like #Ethereum Plasma does), transparency logs and secure file systems and more Written in #Elixir with focus on reliability, concurrency and scalability. https://github.com/ZanjeerPlatform/bargad
GitHub Repo: https://github.com/whitfin/local-cluster
LocalCluster is a tiny module to make it easy to startup child nodes to test your applications against distributed environments. It’s a plain module without DSLs, so it plugs easily into ExUnit as needed.
A pattern that is really successful in other ecosystems is using conventional commits to generate changelogs, manage version changes, and otherwise inform behavior of their tools.
All you need is
mix git_ops.release to update your version numbers in
mix.exs, as well as generate a changelog based on your commit history. Then you or your contributors use conventional commits to convey this information from their changes.
I just published a new post today ’Querying RDF with Elixir: Using SPARQL.ex to query over RDF datastores’:
It also presents a small demo which shows the Observer being used to inspect data from SPARQL result sets retrieved from DBpedia and stored in ETS tables.
This release add new options to the iterators, bytewise comparator support and many other improvements and fixes: https://gitlab.com/barrel-db/erlang-rocksdb/tags/0.23.0
I’m pleased to officially announce our latest project to you:
Planga is a webservice, providing a seamless chat integration to whatever application you are building: Live-chat in one form or another is something that many applications (especially platforms) require, but it is difficult and extremely time-consuming to get it right:
- Users expect all the features they know from dedicated messaging applications.
- Users expect it to work flawlessly, regardless of how large the system becomes, intermittent connection problems, etc.
Rather than every platform developer spending a lot of time and resources to build a semi-working solution, we set out to solve this problem for once and for all, by creating a simple-to-use system that uses your user accounts and your way of deciding whom should talk to whom, but otherwise completely gets out of the way of your application, and therefore is scalable.
The Planga Chat service has been built using Elixir and Phoenix: We use Phoenix channels (using websockets, falling back to longpolling) to connect the browsers from users with each-other. To persist the chat messages, we are currently using the built-in datastore Mnesia, although we are in the process of comparing Riak, Cassandra, CouchDB and a few others to find out what would be the best distributed option to move towards once the system starts growing.
The current version of the dashboard where you, as a developer, manage your API keys, was built in Ruby on Rails, mostly because the Ruby language is great for fast prototyping, a larger group of our team had experience with working with Ruby already, and because it is a conceptually simple, replaceable piece of the technology stack.
To keep the chat as scalable as possible, your application only sends configuration (what is the user in this browser connection’s ID, name and what chat channel is he/she allowed to connect to?) to the user’s browser on page load. After this, all communication happens between the user’s browser and Planga’s chat server.
To make this secure, this configuration information is of course sent encrypted (using the JOSE-JWE encryption suite).
Because the communication has been set up in this way, your application only has to care about sending the configuration to the browser (and we are releasing a slew of language integration libraries to make this even simpler).
We want to give back to the community, and we do not believe in ‘black box’ solutions: If anyone is able to inspect your work, it is a lot easier to find out how it could be improved. And besides this, of course not everyone is comfortable with sharing their user’s data.
And this is why we are releasing the Planga Chat application as an open-source project. (Of course, if you decide to use our service, we will be able to manage scalability-issues for you, as well as being able to provide a set of extra features that are difficult to provide on a self-hosted system, but the core application is and will always remain free!)
What we are releasing right now, is the initial Beta-version of Planga. In the spirit of the Agile Manifesto, this version is very basic. We have a lot of ideas for functionality that could be added, but first we want to start interacting with you, the potential user of the system, and find out what you want!
Please, ask all your questions and be honest with your criticisms! We would love to hear your unfiltered opinions about his project to continuously make it better :-) .
In the Elixir Foundation Video series we show you how to setup an elixir project from scratch.
In this episode we’ll show you how to accept web requests using cowboy and plug. https://www.codemy.net/posts/elixir-setup-plug-and-cowboy-004
Recently my friend and benchee co-maintainer Tobi had an idea to use benchee to run benchmarks with random data. This is an interesting idea, since you can get what is probably a more accurate picture of how your function behaves with real-world wierdness. It’s essentially the idea of using different inputs for a function, but turned up to 11. And you can do (some of) it today with benchee: http://devonestes.herokuapp.com/benchmarking-with-stream-data
In this article, I’m explaining how you can benefit from LISTEN and NOTIFY Postgres database features in Elixir applications: https://k.lelonek.me/postgres-pubsub-elixir
I recently finished switching an existing open source Phoenix app from Brunch to Webpack. I have blogged about the steps which I followed. Check out the full article!
I really struggled with verifying signing secrets on Slack so I decided to post on how to do it yourself if you’re working with the Slack API at all. This goes over some gotchas including Gregorian to UNIX timestamps, HMAC cryptography, and more:
I just published a post ‘Early steps in Elixir and RDF: Using RDF.ex to work with RDF vocabularies in Elixir’. This post demonstrates how the RDF.ex package can be used for interacting with the RDF data model in Elixir. Specifically it provides a walkthrough on how to define new RDF vocabulary terms for two well-known schemas and then applies them to a simple use case – generating a basic bibliographic record for the ‘Adopting Elixir’ book by Ben Marx, José Valim, and Bruce Tate – and it links to the project TestVocab code on GitHub.
I needed an easy way to intercept function calls, so I could send metrics whenever a function completed successfully or not. After looking at the current offers, I’ve decided to scratch my own itch!
At SmartLogic we use Prometheus to monitor our Elixir applications. This post goes over how to set up instrumentation of your application and the basics of viewing those metrics in Grafana.