The really big list of really interesting Open Source projects.


Hi, dear developers and readers!

If you are interested in Open Source and are considering to join the community of Open Source developers, it is possible that in this list you will find the project that will suit you (In fact I am sure that you will find).

Here are you can see the really big list of really interesting Open Source projects on languages such as Elixir, Erlang, Haskell, Clojure, Python, Ruby, Lua, JS, Go, C++, Swift, Bash, R and etc.



# Emacs/Common Lisp

— — — — —

Magit is an interface to the version control system Git, implemented as an Emacs package. Magit aspires to be a complete Git porcelain. While we cannot (yet) claim that Magit wraps and improves upon each and every Git command, it is complete enough to allow even experienced Git users to perform almost all of their daily version control tasks directly from within Emacs. While many fine Git clients exist, only Magit and Git itself deserve to be called porcelains. (more)


Woo is a fast non-blocking HTTP server built on top of libev. Although Woo is written in Common Lisp, it aims to be the fastest web server written in any programming language.

How fast?


Clack is a web application environment for Common Lisp inspired by Python’s WSGI and Ruby’s Rack.

Usage:

(defvar *handler*
(clack:clackup
(lambda (env)
(declare (ignore env))
'(200 (:content-type "text/plain") ("Hello, Clack!")))))

Alchemist — an Elixir Tooling Integration Into Emacs. Alchemist comes with a bunch of features, which are:

  • Mix integration
  • Compile & Execution of Elixir code
  • Inline code evaluation
  • Inline macro expanding
  • Documentation lookup
  • Definition lookup
  • Powerful IEx integration
  • Smart code completion
  • Elixir project management
  • Phoenix support
  • Integration with company-mode

# Python

— — — — —

django-split-setting: Organize Django settings into multiple files and directories. Easily override and modify settings. Use wildcards and optional settings files.


Pelican is a static site generator, written in Python.

  • Write content in reStructuredText or Markdown using your editor of choice
  • Includes a simple command line tool to (re)generate site files
  • Easy to interface with version control systems and web hooks
  • Completely static output is simple to host anywhere

tensorflow — an open source software library for numerical computation using data flow graphs. Nodes in the graph represent mathematical operations, while the graph edges represent the multidimensional data arrays (tensors) that flow between them. This flexible architecture lets you deploy computation to one or more CPUs or GPUs in a desktop, server, or mobile device without rewriting code. TensorFlow also includes TensorBoard, a data visualization toolkit.


Magenta is a research project exploring the role of machine learning in the process of creating art and music. Primarily this involves developing new deep learning and reinforcement learning algorithms for generating songs, images, drawings, and other materials. But it’s also an exploration in building smart tools and interfaces that allow artists and musicians to extend (not replace!) their processes using these models


The Numenta Platform for Intelligent Computing (NUPIC) is a machine intelligence platform that implements the HTM learning algorithms. HTM is a detailed computational theory of the neocortex. At the core of HTM are time-based continuous learning algorithms that store and recall spatial and temporal patterns. NuPIC is suited to a variety of problems, particularly anomaly detection and prediction of streaming data sources.


Universe is a software platform for measuring and training an AI’s general intelligence across the world’s supply of games, websites and other applications. This is the universe open-source library, which provides a simple Gym interface to each Universe environment.


Theano — a Python library that allows you to define, optimize, and evaluate mathematical expressions involving multi-dimensional arrays efficiently. It can use GPUs and perform efficient symbolic differentiation.


http-prompt — an interactive command-line HTTP client featuring autocomplete and syntax highlighting.


HTTPretty — HTTP client mocking tool for Python, it’s like ruby’s FakeWeb for python.

Usage:

import requests
import httpretty
def test_one():
httpretty.enable() # enable HTTPretty so that it will monkey patch the socket module
httpretty.register_uri(httpretty.GET, "http://yipit.com/",
body="Find the best daily deals")
    response = requests.get('http://yipit.com')
    assert response.text == "Find the best daily deals"
    httpretty.disable()  # disable afterwards, so that you will have no problems in code that uses that socket module
httpretty.reset() # reset HTTPretty state (clean up registered urls and request history)

falcon — is a high-performance Python framework for building cloud APIs. It encourages the REST architectural style, and tries to do as little as possible while remaining highly effective.

Example:

import falcon

# Falcon follows the REST architectural style, meaning (among
# other things) that you think in terms of resources and state
# transitions, which map to HTTP verbs.
class ThingsResource(object):
def on_get(self, req, resp):
"""Handles GET requests"""
resp.status = falcon.HTTP_200 # This is the default status
resp.body = ('\nTwo things awe me most, the starry sky '
'above me and the moral law within me.\n'
'\n'
' ~ Immanuel Kant\n\n')
# falcon.API instances are callable WSGI apps
app = falcon.API()
# Resources are represented by long-lived class instances
things = ThingsResource()
# things will handle all requests to the '/things' URL path
app.add_route('/things', things)

eve — an open source Python REST API framework designed for human beings. It allows to effortlessly build and deploy highly customizable, fully featured RESTful Web Services.

Eve is powered by Flask, Redis, Cerberus, Events and offers support for both MongoDB and SQL backends.

from eve import Eve
app = Eve()
app.run()

The API is now live, ready to be consumed:

$ curl -i http://example.com/people
HTTP/1.1 200 OK

plotly.py— an interactive, browser-based charting library for Python.

Screenshot:


cerberus — a lightweight and extensible data validation library for Python.

Example:

>>> v = Validator({'name': {'type': 'string'}})
>>> v.validate({'name': 'john doe'})
True

Rainbow Stream— is a terminal-based Twitter Client. Realtime tweetstream, compose, search, favorite … and much more fun directly from terminal.


vispy — a high-performance interactive 2D/3D data visualization library for Python. Example:

Spiral galaxy

Mimesis is a fast and easier to use Python library for generate dummy data. These data are very useful when you need to bootstrap the database in the testing phase of your software. A great example of how you can use the library is a web applications on Flask or Django which need a data, such as users (email, username, name, surname etc.), posts (tags, text, title, publishing date and etc.) asf. The library use the JSON files as a datastore and doesn’t have any dependencies. The library offers more than 22 different data providers (from the personal to transport and not only).

Below you can see, how to generate fake paths using Mimesis:

>>> import mimesis
>>> person = mimesis.Personal(locale='en')

>>> person.full_name(gender='female')
'Antonetta Garrison'

>>> person.occupation()
'Backend Developer'

>>> templates = ['U_d', 'U-d', 'l_d', 'l-d']
>>> for template in templates:
... person.username(template=template)

'Adders_1893'
'Abdel-1888'
'constructor_1884'
'chegre-2051'

expynent — a library that provides regex patterns for Python. If you hate to write regular expressions, then expynent can help you. Examples are below.

Just import the pattern that you wanna use:

import re
import expynent.patterns as expas
if re.match(expas.ZIP_CODE['RU'], '43134'):
print('match')
else:
print('not match')
# Output: 'not match'

also you can use compiled patterns:

from expynent.compiled import username
u = input('Enter username: ')
if username.match(u):
print('valid')
else:
print('invalid')

the fuck — is a magnificent app which corrects your previous console command.


httpstat — httpstat visualizes curl statistics in a way of beauty and clarity. httpstart written in Python.

Screenshot:


pycallgraph — Python Call Graph is a Python module that creates call graph visualizations for Python applications.

Screenshot:


pgcli — Postgres CLI with autocompletion and syntax highlighting. pgcli written in Python.

Screenshot:


pendulum — Python datetimes made easy.

Usage:

>>> import pendulum
>>> now_in_paris = pendulum.now('Europe/Paris')
>>> now_in_paris
'2016-07-04T00:49:58.502116+02:00'
# Seamless timezone switching
>>> now_in_paris.in_timezone('UTC')
'2016-07-03T22:49:58.502116+00:00'
>>> tomorrow = pendulum.now().add(days=1)
>>> last_week = pendulum.now().subtract(weeks=1)
>>> if pendulum.now().is_weekend():
... print('Party!')
'Party!'
>>> past = pendulum.now().subtract(minutes=2)
>>> past.diff_for_humans()
>>> '2 minutes ago'
>>> delta = past - last_week
>>> delta.hours
23
>>> delta.in_words(locale='en')
'6 days 23 hours 58 minutes'
# Proper handling of datetime normalization
>>> pendulum.create(2013, 3, 31, 2, 30, 0, 0, 'Europe/Paris')
'2013-03-31T03:30:00+02:00' # 2:30 does not exist (Skipped time)
# Proper handling of dst transitions
>>> just_before = pendulum.create(2013, 3, 31, 1, 59, 59, 999999, 'Europe/Paris')
'2013-03-31T01:59:59.999999+01:00'
>>> just_before.add(microseconds=1)
'2013-03-31T03:00:00+02:00'

pagan — Python avatar generator for absolute nerds.

Screenshot:


python-prompt-toolkit— a library for building powerful interactive command lines and terminal applications in Python.

Screenshot:


superset — a data exploration platform designed to be visual, intuitive and interactive.

Screenshot:


astropy — a package intended to contain much of the core functionality and some common tools needed for performing astronomy and astrophysics with Python.


furl — a small Python library that makes manipulating URLs simple.

Example:

>>> from furl import furl
>>> f = furl('http://www.google.com/?one=1&two=2')
>>> f.args['three'] = '3'
>>> del f.args['one']
>>> f.url
'http://www.google.com/?two=2&three=3'

httpie — a command line HTTP client. Its goal is to make CLI interaction with web services as human-friendly as possible. It provides a simple http command that allows for sending arbitrary HTTP requests using a simple and natural syntax, and displays colorized output. HTTPie can be used for testing, debugging, and generally interacting with HTTP servers.

Screenshot:


compose — a tool for defining and running multi-container Docker applications. With Compose, you use a Compose file to configure your application’s services. Then, using a single command, you create and start all the services from your configuration.


keras — a high-level neural networks library, written in Python and capable of running on top of either TensorFlow or Theano. It was developed with a focus on enabling fast experimentation.


socli — a command line Stackoverflow written in Python. Using SoCLI you can search and browse stack overflow without leaving the terminal. Just use the socli command:


bokeh — a Python interactive visualization library, enables beautiful and meaningful visual presentation of data in modern web browsers. With Bokeh, you can quickly and easily create interactive plots, dashboards, and data applications.


# Lua

— — — — —

moonscript — a programmer friendly language that compiles into Lua. It gives you the power of the fastest scripting language combined with a rich set of features. It runs on Lua 5.1 and above, including alternative runtimes like LuaJIT.



middleclass — a simple OOP library for Lua. It has inheritance, metamethods (operators), class variables and weak mixin support.

Quick look:

local class = require 'middleclass'
local Fruit = class('Fruit') -- 'Fruit' is the class' name
function Fruit:initialize(sweetness)
self.sweetness = sweetness
end
Fruit.static.sweetness_threshold = 5 -- class variable (also admits methods)
function Fruit:isSweet()
return self.sweetness > Fruit.sweetness_threshold
end
local Lemon = class('Lemon', Fruit) -- subclassing
function Lemon:initialize()
Fruit.initialize(self, 1) -- invoking the superclass' initializer
end
local lemon = Lemon:new()
print(lemon:isSweet()) -- false

luarocks — a package manager for Lua modules.


telize — a REST API built on Nginx and Lua allowing to get a visitor IP address and to query location information from any IP address. It outputs JSON-encoded IP geolocation data, and supports both JSON and JSONP.

t  e  l  i  z  e
_______________________
______\ /_______
\\ \\ ___ // /
__ \ ____ \ __ / \ _____/\ / ____
___/ \____/ _//____/ \___\___/___\__ /__/ _//____
\\__ ____ __/ __ __ ____ ____ __/ __///
/ \_ |/ \_ / \/ /_/ |/ \_
\\\ ___/\___ /____/\_______/\ ___/\___ /
<0(--- \__/ -h7- \______/ \ . \__/ ---- \______/ --(0>
\ .\ /. .
\ .\ // /
\______\\ //______/
Y

vanilla — an OpenResty Lua MVC Web Framework.


lor — a fast and minimalist web framework based on OpenResty.

Example:

local lor = require("lor.index")
local app = lor()
app:get("/", function(req, res, next)
res:send("hello world!")
end)
app:run()

pegasus.lua — a http server to work with web applications written in Lua language.

Example:

local pegasus = require 'pegasus'

local server = pegasus:new({
port='9090',
location='example/root'
})

server:start(function (request, response)
print "It's running..."
end)

openresty— a full-fledged web platform by integrating the standard Nginx core, LuaJIT, many carefully written Lua libraries, lots of high quality 3rd-party Nginx modules, and most of their external dependencies. It is designed to help developers easily build scalable web applications, web services, and dynamic web gateways.


# C/C++

— — — — —

Torch is a scientific computing framework with wide support for machine learning algorithms that puts GPUs first. It is easy to use and efficient, thanks to an easy and fast scripting language, LuaJIT, and an underlying C/CUDA implementation.


Caffe is a deep learning framework made with expression, speed, and modularity in mind. It is developed by the Berkeley Vision and Learning Center (BVLC) and community contributors.


libuv is a multi-platform support library with a focus on asynchronous I/O. It was primarily developed for use by Node.js, but it’s also used by Luvit, Julia, pyuv, and others.


µWS is one of the most lightweight, efficient & scalable WebSocket server implementations available. It features an easy-to-use, fully async object-oriented interface and scales to millions of connections using only a fraction of memory compared to the competition. While performance and scalability are two of our top priorities, we consider security, stability and standards compliance paramount. License is zlib/libpng (very permissive & suits commercial applications).


RethinkDB — the first open-source scalable database built for realtime applications. It exposes a new database access model — instead of polling for changes, the developer can tell the database to continuously push updated query results to applications in realtime. RethinkDB allows developers to build scalable realtime apps in a fraction of the time with less effort.


RedisDesktopManager — an Open source cross-platform Redis Desktop Manager based on Qt 5


# Golang

— — — — —

Cayley is an open-source graph inspired by the graph database behind Freebase and Google’s Knowledge Graph.

Its goal is to be a part of the developer’s toolbox where Linked Data and graph-shaped data (semantic webs, social networks, etc) in general are concerned.


Kubernetes is an open source system for managing containerized applications across multiple hosts, providing basic mechanisms for deployment, maintenance, and scaling of applications. Kubernetes is hosted by the Cloud Native Computing Foundation.

Kubernetes builds upon a decade and a half of experience at Google running production workloads at scale using a system called Borg, combined with best-of-breed ideas and practices from the community.


cobra — a library for creating powerful modern CLI applications as well as a program to generate applications and command files.


Hyperd is a hypervisor-agnostic technology that allows you to run Docker images on plain hypervisor.


ginkgo — a BDD Testing Framework for Go


bild — a collection of parallel image processing algorithms in pure Go.

Basic example:

package main
import (
"github.com/anthonynsimon/bild/effect"
"github.com/anthonynsimon/bild/imgio"
"github.com/anthonynsimon/bild/transform"
)
func main() {
img, err := imgio.Open("filename.jpg")
if err != nil {
panic(err)
}
    inverted := effect.Invert(img)
resized := transform.Resize(inverted, 800, 800, transform.Linear)
rotated := transform.Rotate(resized, 45, nil)
    if err := imgio.Save("filename", rotated, imgio.PNG); err != nil {
panic(err)
}
}

Terraform is a tool for building, changing, and versioning infrastructure safely and efficiently. Terraform can manage existing and popular service providers as well as custom in-house solutions.


gago — genetic algorithm toolkit written in Go

The following example attempts to minimize the Drop-Wave function.


hugo — a static HTML and CSS website generator written in Go. It is optimized for speed, easy use and configurability. Hugo takes a directory with content and templates and renders them into a full HTML website.


gin — a web framework written in Go (Golang). It features a martini-like API with much better performance, up to 40 times faster thanks to httprouter. If you need performance and good productivity, you will love Gin.


goji — a minimalistic web framework that values composability and simplicity.

package main
import (
"fmt"
"net/http"
        "github.com/zenazn/goji"
"github.com/zenazn/goji/web"
)
func hello(c web.C, w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %s!", c.URLParams["name"])
}
func main() {
goji.Get("/hello/:name", hello)
goji.Serve()
}

gobot — a framework using the Go programming language for robotics, physical computing, and the Internet of Things.


utron — a lightweight MVC framework in Go (Golang) for building fast, scalable and robust database-driven web applications.


color lets you use colorized outputs in terms of ANSI Escape Codes in Go (Golang). It has support for Windows too! The API can be used in several ways, pick one that suits you.

Example:

// Print with default helper functions
color.Cyan("Prints text in cyan.")
// A newline will be appended automatically
color.Blue("Prints %s in blue.", "text")
// These are using the default foreground colors
color.Red("We have red")
color.Magenta("And many others ..")

fzf — a general-purpose command-line fuzzy finder.


delve — a debugger for the Go programming language. The goal of the project is to provide a simple, full featured debugging tool for Go. Delve should be easy to invoke and easy to use. Chances are if you’re using a debugger, most likely things aren’t going your way. With that in mind, Delve should stay out of your way as much as possible.


gallium — a Go library for managing windows, menus, dock icons, and desktop notifications. Each window contains a webview component, in which you code your UI in HTML. Under the hood, the webview is running Chromium.

Screenshot:


caddy — a general-purpose web server for Windows, Mac, Linux, BSD, and Android. It is a capable but easier alternative to other popular web servers.


drone — a Continuous Delivery platform built on Docker, written in Go.


realize — a Go build system with file watchers, output streams and live reload. Run, build and watch file changes with custom paths


gogs — Gogs (Go Git Service) is a painless self-hosted Git service.

Screenshots:


tile38— an open source, in-memory geolocation data store, spatial index, and realtime geofence. It supports a variety of object types including lat/lon points, bounding boxes, XYZ tiles, Geohashes, and GeoJSON.


logrus— a structured logger for Golang, completely API compatible with the standard library logger.

Screenshot:


traefik — a modern HTTP reverse proxy and load balancer made to deploy microservices with ease. It supports several backends (Docker, Swarm, Kubernetes, Marathon, Mesos, Consul, Etcd, Zookeeper, BoltDB, Eureka, Rest API, file…) to manage its configuration automatically and dynamically.


dry — a terminal application to manage Docker containers and images. It aims to be an alternative to the official Docker CLI when it is needed to repeatedly execute commands on existing containers and images, and also as a tool to monitor Docker containers from a terminal.

Screenshot:


bat— Go implemented CLI cURL-like tool for humans. Bat can be used for testing, debugging, and generally interacting with HTTP servers.

Screenshot:


pgweb — Web-based PostgreSQL database browser written in Go.

Screenshot:


goji — a minimalistic web framework for Golang that’s high in antioxidants.

Example:

package main
import (
"fmt"
"net/http"
        "github.com/zenazn/goji"
"github.com/zenazn/goji/web"
)
func hello(c web.C, w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %s!", c.URLParams["name"])
}
func main() {
goji.Get("/hello/:name", hello)
goji.Serve()
}

noms — a decentralized database based on ideas from Git. noms written in Golang.



termui— a cross-platform, easy-to-compile, and fully-customizable terminal dashboard, written purely in Go.

Screenshot:

termui

hget — Rocket fast download accelerator written in Golang.

Screenshot:


# Erlang/Elixir

— — — — —

cowboy — a small, fast and modern HTTP server for Erlang/OTP. I think that everyone who interested in Erlang heard about a cowboy.


ChicagoBoss — a server framework inspired by Rails and written in Erlang. It offers all the conveniences of modern web development, including Comet. What sets Chicago Boss apart from other non-Erlang frameworks is that it can handle large amounts of traffic without any drop in performance. What sets Chicago Boss apart from other Erlang frameworks is that it is easy to set up and use.


mochiweb — an Erlang library for building lightweight HTTP servers.


vernemq— a high-performance, distributed MQTT message broker. It scales horizontally and vertically on commodity hardware to support a high number of concurrent publishers and consumers while maintaining low latency and fault tolerance. VerneMQ is the reliable message hub for your IoT platform or smart products.


hackney — an HTTP client library for Erlang.


sync — a developer utility. It recompiles and reloads your Erlang code on-the-fly. With Sync, you can code without friction.


credo — a static code analysis tool for the Elixir language with a focus on teaching and code consistency.


guardian — an authentication framework for use with Elixir applications.

Guardian is based on similar ideas to Warden but is re-imagined for modern systems where Elixir manages the authentication requirements.

Guardian remains a functional system. It integrates with Plug, but can be used outside of it. If you’re implementing a TCP/UDP protocol directly, or want to utilize your authentication via channels, Guardian is your friend.

The core currency of authentication in Guardian is JSON Web Tokens (JWT). You can use the JWT to authenticate web endpoints, channels, and TCP sockets and it can contain any authenticated assertions that the issuer wants to include.


TableRex — an Elixir app which generates text-based tables for display.


httpoison — yet another HTTP client for Elixir powered by hackney.


maru — Elixir RESTful Framework

Usage:

defmodule Router.User do
use Maru.Router
  namespace :user do
route_param :id do
get do
json(conn, %{ user: params[:id] })
end
      desc "description"
params do
requires :age, type: Integer, values: 18..65
requires :gender, type: Atom, values: [:male, :female], default: :female
group :name, type: Map do
requires :first_name
requires :last_name
end
optional :intro, type: String, regexp: ~r/^[a-z]+$/
optional :avatar, type: File
optional :avatar_url, type: String
exactly_one_of [:avatar, :avatar_url]
end
post do
...
end
end
end
end
defmodule Router.Homepage do
use Maru.Router
  resources do
get do
json(conn, %{ hello: :world })
end
    mount Router.User
end
end

defmodule MyAPP.API do
use Maru.Router
  before do
plug Plug.Logger
plug Plug.Static, at: "/static", from: "/my/static/path/"
end
  plug Plug.Parsers,
pass: ["*/*"],
json_decoder: Poison,
parsers: [:urlencoded, :json, :multipart]
  mount Router.Homepage
  rescue_from Unauthorized, as: e do
IO.inspect e
    conn
|> put_status(401)
|> text("Unauthorized")
end
  rescue_from [MatchError, RuntimeError], with: :custom_error
  rescue_from :all do
conn
|> put_status(500)
|> text("Server Error")
end
  defp custom_error(conn, exception) do
conn
|> put_status(500)
|> text(exception.message)
end
end

then add the maru to your config/config.exs

config :maru, MyAPP.API,
http: [port: 8880]

hound — Elixir library for writing integration tests and browser automation.

ExUnit example:

defmodule HoundTest do
use ExUnit.Case
use Hound.Helpers
hound_session
test "the truth", meta do
navigate_to("http://example.com/guestbook.html")
element = find_element(:name, "message")
fill_field(element, "Happy Birthday ~!")
submit_element(element)
assert page_title() == "Thank you"
end
end

distillery — a pure Elixir implementation of release packaging functionality for the Erlang VM (BEAM).

Every alchemist requires good tools, and one of the greatest tools in the alchemist’s disposal is the distillery. The purpose of the distillery is to take something and break it down to it’s component parts, reassembling it into something better, more powerful. That is exactly what this project does — it takes your Mix project and produces an Erlang/OTP release, a distilled form of your raw application’s components; a single package which can be deployed anywhere, independently of an Erlang/Elixir installation. No dependencies, no hassle.

This is a pure-Elixir, dependency-free implementation of release generation for Elixir projects. It is currently a standalone package, but may be integrated into Mix at some point in the future.


timex — a rich, comprehensive Date/Time library for Elixir projects, with full timezone support via the :tzdata package. If you need to manipulate dates, times, datetimes, timestamps, etc., then Timex is for you! It is very easy to use Timex types in place of default Erlang types, as well as Ecto types via the timex_ecto package.

Here’s a few simple examples:

> use Timex
> Timex.today
~D[2016-02-29]
> datetime = Timex.now
#<DateTime(2016-02-29T12:30:30.120+00:00Z Etc/UTC)
> Timex.now("America/Chicago")
#<DateTime(2016-02-29T06:30:30.120-06:00 America/Chicago)
> Duration.now
#<Duration(P46Y6M24DT21H57M33.977711S)>
> {:ok, default_str} = Timex.format(datetime, "{ISO:Extended}")
{:ok, "2016-02-29T12:30:30.120+00:00"}
> {:ok, relative_str} = Timex.shift(datetime, minutes: -3) |> Timex.format("{relative}", :relative)
{:ok, "3 minutes ago"}
> strftime_str = Timex.format!(datetime, "%FT%T%:z", :strftime)
"2016-02-29T12:30:30+00:00"
> Timex.parse(default_str, "{ISO:Extended}")
{:ok, #<DateTime(2016-02-29T12:30:30.120+00:00 Etc/Utc)}
> Timex.parse!(strftime_str, "%FT%T%:z", :strftime)
#<DateTime(2016-02-29T12:30:30.120+00:00 Etc/Utc)
> Duration.diff(Duration.now, Duration.zero, :days)
16850
> Timex.shift(date, days: 3)
~D[2016-03-03]
> Timex.shift(datetime, hours: 2, minutes: 13)
#<DateTime(2016-02-29T14:43:30.120Z Etc/UTC)>
> timezone = Timezone.get("America/Chicago", Timex.now)
#<TimezoneInfo(America/Chicago - CDT (-06:00:00))>
> Timezone.convert(datetime, timezone)
#<DateTime(2016-02-29T06:30:30.120-06:00 America/Chicago)>
> Timex.before?(Timex.today, Timex.shift(Timex.today, days: 1))
true
> Timex.before?(Timex.shift(Timex.today, days: 1), Timex.today)
false

httpotion — an HTTP client for Elixir, based on ibrowse. Continues the HTTPun tradition of HTTParty, HTTPretty, HTTParrot and HTTPie.

Some basic examples:

iex> response = HTTPotion.get "httpbin.org/get"
%HTTPotion.Response{body: "...", headers: [Connection: "keep-alive", ...], status_code: 200}
iex> HTTPotion.Response.success?(response)
true
# HTTPotion also supports querystrings like
iex> HTTPotion.get("httpbin.org/get", query: %{page: 2})
%HTTPotion.Response{body: "...", headers: [Connection: "keep-alive", ...], status_code: 200}
# Form data
iex> HTTPotion.post "https://httpbin.org/post", [body: "hello=" <> URI.encode_www_form("w o r l d !!"),
headers: ["User-Agent": "My App", "Content-Type": "application/x-www-form-urlencoded"]]
%HTTPotion.Response{body: "...", headers: [Connection: "keep-alive", ...], status_code: 200}
iex> HTTPotion.request :propfind, "http://httpbin.org/post", [body: "I have no idea what I'm doing"]
%HTTPotion.Response{body: "...", headers: [Connection: "keep-alive", ...], status_code: 405}
iex> HTTPotion.get "httpbin.org/basic-auth/foo/bar", [basic_auth: {"foo", "bar"}]
%HTTPotion.Response{body: "...", headers: ["Access-Control-Allow-Credentials": "true", ...], status_code: 200}
# Passing options to ibrowse (note that it usually takes char_lists, not elixir strings)
iex> HTTPotion.get "http://ip6.me", [ ibrowse: [ proxy_host: 'fc81:6134:ba6c:8458:c99f:6c01:6472:8f1e', proxy_port: 8118 ] ]
%HTTPotion.Response{body: "...", headers: [Connection: "keep-alive", ...], status_code: 200}
# The default timeout is 5000 ms, but can be changed
iex> HTTPotion.get "http://example.com", [timeout: 10_000]
# If there is an error a `HTTPotion.ErrorResponse` is returned
iex> HTTPotion.get "http://localhost:1"
%HTTPotion.ErrorResponse{message: "econnrefused"}
# You can also raise `HTTPError` with the `bang` version of request
iex> HTTPotion.get! "http://localhost:1"
** (HTTPotion.HTTPError) econnrefused

ex_admin — an add on for an application using the Phoenix Framework to create an CRUD administration tool with little or no code. By running a few mix tasks to define which Ecto Models you want to administer, you will have something that works with no additional code.


kitto — a framework to help you create dashboards, written in Elixir/React.


edeliver is based on deliver enables you to build and deploy Elixir and Erlang applications and perform hot-code upgrades.


ejabberd — a distributed, fault-tolerant technology that allows the creation of large-scale instant messaging applications. The server can reliably support thousands of simultaneous users on a single node and has been designed to provide exceptional standards of fault tolerance. As an open source technology, based on industry-standards, ejabberd can be used to build bespoke solutions very cost effectively. ejabberd written in Erlang.



emqttd — a massively scalable and clusterable MQTT V3.1/V3.1.1 broker written in Erlang/OTP.


poison — a new JSON library for Elixir focusing on wicked-fast speed without sacrificing simplicity, completeness, or correctness.

Usage:

defmodule Person do
@derive [Poison.Encoder]
defstruct [:name, :age]
end

Poison.encode!(%Person{name: "Devin Torres", age: 27})
#=> "{\"name\":\"Devin Torres\",\"age\":27}"

Poison.decode!(~s({"name": "Devin Torres", "age": 27}), as: %Person{})
#=> %Person{name: "Devin Torres", age: 27}

Poison.decode!(~s({"people": [{"name": "Devin Torres", "age": 27}]}),
as: %{"people" => [%Person{}]})
#=> %{"people" => [%Person{age: 27, name: "Devin Torres"}]}

phoenix — Productive. Reliable. Fast. A productive web framework that
does not compromise speed and maintainability (seems that’s true).


Sugar is a modular web framework for Elixir.

Goals:

  • Speed. Sugar shouldn’t be slow and neither should your project.
  • Ease. Sugar should be simple because simple is easy to learn, use and maintain.
  • Effective. Sugar should aid development. You have better things to which to devote your time.

Example:

defmodule Router do
use Sugar.Router

get "/", Hello, :index
get "/pages/:id", Hello, :show
post "/pages", Hello, :create
put "/pages/:id" when id == 1, Hello, :show
end

smokkfiskur — a small (really small, ~ 50 SLOC) library for colored (ANSI) output in Erlang.

It looks like these guys are having sex, but I’m not sure (It does not matter).

Usage:

-import(smokkfiskur, [print/1]).
update_something() ->
%% ...
%% ...
%% ...
print({green, "Something has been updated successfully!"}).

Screenshot:


# Ruby

— — — — —

httparty — Makes http fun again!

Example:

# Use the class methods to get down to business quickly
response = HTTParty.get('http://api.stackexchange.com/2.2/questions?site=stackoverflow')
puts response.body, response.code, response.message, response.headers.inspect
# Or wrap things up in your own class
class StackExchange
include HTTParty
base_uri 'api.stackexchange.com'
def initialize(service, page)
@options = { query: { site: service, page: page } }
end
def questions
self.class.get("/2.2/questions", @options)
end
def users
self.class.get("/2.2/users", @options)
end
end
stack_exchange = StackExchange.new("stackoverflow", 1)
puts stack_exchange.questions
puts stack_exchange.users

redis-stat— a simple Redis monitoring tool written in Ruby.

Screenshot:


rails_db — Rails Database Viewer and SQL Query Runner.

Screenshot:


# JavaScript / Node

— — — — —

Chart.js — a simple HTML5 Charts using the canvas element.


Moment.js — a lightweight JavaScript date library for parsing, validating, manipulating, and formatting dates.


Hexo — a fast, simple & powerful blog framework, powered by Node.js.

Features:

  • Blazing fast generating
  • Support for GitHub Flavored Markdown and most Octopress plugins
  • One-command deploy to GitHub Pages, Heroku, etc.
  • Powerful plugin system

d3 — a JavaScript library for visualizing data using web standards. D3 helps you bring data to life using SVG, Canvas and HTML. D3 combines powerful visualization and interaction techniques with a data-driven approach to DOM manipulation, giving you the full capabilities of modern browsers and the freedom to design the right visual interface for your data.


N1 — an open-source mail client built on the modern web with Electron, React, and Flux. It is designed to be extensible, so it’s easy to create new experiences and workflows around email. N1 is built on the Nylas Sync Engine, which is also open-source free software.


Enzyme is a JavaScript Testing utility for React that makes it easier to assert, manipulate, and traverse your React Components’ output.

Enzyme’s API is meant to be intuitive and flexible by mimicking jQuery’s API for DOM manipulation and traversal.

Enzyme is unopinionated regarding which test runner or assertion library you use, and should be compatible with all major test runners and assertion libraries out there. The documentation and examples for enzyme use mocha and chai, but you should be able to extrapolate to your framework of choice.


Eve — a programming language and IDE based on years of research into building a human-first programming platform. You can play with Eve online here: play.witheve.com.


flux — more of a pattern than a framework, and does not have any hard dependencies. However, we often use EventEmitter as a basis for Stores and React for our Views. The one piece of Flux not readily available elsewhere is the Dispatcher. This module, along with some other utilities, is available here to complete your Flux toolbox.


sigma.js — a JavaScript library dedicated to graph drawing.


strider — an Open Source Continuous Deployment / Continuous Integration platform. It is written in Node.JS / JavaScript and uses MongoDB as a backing store. It is published under the BSD license.


eme — Elegant Markdown Editor.


async — a utility module which provides straight-forward, powerful functions for working with asynchronous JavaScript. Although originally designed for use with Node.js and installable via npm install --save async, it can also be used directly in the browser.


mongo-hacker — MongoDB Shell Enhancements for Hackers.

Screenshot:


mongotron— a MongoDB GUI built using Electron, and Angular JS.

Screenshot:


# OCaml

— — — — —

Merlin is an editor service that provides modern IDE features for OCaml.


Coq is a formal proof management system. It provides a formal language to write mathematical definitions, executable algorithms and theorems together with an environment for semi-interactive development of machine-checked proofs.


# Haskell

— — — — —

Pandoc is a Haskell library for converting from one markup format to another, and a command-line tool that uses this library. It can read Markdown, CommonMark, PHP Markdown Extra, GitHub-Flavored Markdown, MultiMarkdown, and (subsets of) Textile, reStructuredText, HTML, LaTeX, MediaWiki markup, TWiki markup, Haddock markup, OPML, Emacs Org mode, DocBook, txt2tags, EPUB, ODT and Word docx; and it can write plain text, Markdown, CommonMark, PHP Markdown Extra,GitHub-Flavored Markdown, MultiMarkdown, reStructuredText, XHTML, HTML5, LaTeX (including beamer slide shows), ConTeXt, RTF, OPML, DocBook, OpenDocument, ODT, Word docx, GNU Texinfo, MediaWiki markup, DokuWiki markup, ZimWiki markup, Haddock markup, EPUB (v2 or v3), FictionBook2, Textile, groff man pages, Emacs Org mode, AsciiDoc, InDesign ICML, TEI Simple, and Slidy, Slideous, DZSlides, reveal.js or S5 HTML slide shows. It can also produce PDF output on systems where LaTeX, ConTeXt, or wkhtmltopdf is installed.


stack is a cross-platform program for developing Haskell projects. It is intended for Haskellers both new and experienced.

See haskellstack.org or the doc directory for more information.


yesod — an advanced RESTful web framework using the Haskell programming language.


hakyll — a static site generator library in Haskell. More information (including a tutorial) can be found on the hakyll homepage.

WRITE YOUR CONTENT IN WHATEVER FORMAT YOU PREFER:

CREATE COMPILATION RULES IN A HASKELL EDSL:

COMPILE IT TO HTML AND UPLOAD IT!


yi — a text editor written in Haskell and extensible in Haskell. The goal of Yi is to provide a flexible, powerful and correct editor core scriptable in Haskell.

Its features include

  • a purely functional editor core;
  • keybindings written as parsers of the input;
  • Emacs, Vim and Cua (subset) emulations provided by default;
  • Vty (terminal) and Gtk-based Pango UIs

Leksah aims to integrate various Haskell development tools to provide a practical and pleasant development environment. The user interface is a mix of GTK+ and WebKit based components.


scotty — a Haskell web framework inspired by Ruby’s Sinatra, using WAI and Warp.

{-# LANGUAGE OverloadedStrings #-}
import Web.Scotty
import Data.Monoid (mconcat)
main = scotty 3000 $ do
get "/:word" $ do
beam <- param "word"
html $ mconcat ["<h1>Scotty, ", beam, " me up!</h1>"]

intero — Complete interactive development program for Haskell


eta — a dialect of Haskell which runs on the JVM.


hadolint — a smarter Dockerfile linter that helps you build best practice Docker images. The linter is parsing the Dockerfile into an AST and performs rules on top of the AST. hadolint written in Haskell.

Screenshot:


postgrest — PostgREST serves a fully RESTful API from any existing PostgreSQL database. It provides a cleaner, more standards-compliant, faster API than you are likely to write from scratch. PostgREST written in Haskell.


# Rust

— — — — —

redox — an operating system written in Rust, a language with focus on safety and high performance. Redox, following the microkernel design, aims to be secure, usable, and free. Redox is inspired by previous kernels and operating systems, such as SeL4, Minix, Plan 9, and BSD.

Screenshot:


# Clojure

— — — — —

Metabase is the easy, open source way for everyone in your company to ask questions and learn from data.


riemann — a network event stream processing system, in Clojure.


compojure — a small routing library for Ring that allows web applications to be composed of small, independent parts.

Usage:

This small Compojure application demonstrates creating a Ring handler from two routes:

(ns hello-world.core
(:require [compojure.core :refer :all]
[compojure.route :as route]))
(defroutes app
(GET "/" [] "<h1>Hello World</h1>")
(route/not-found "<h1>Page not found</h1>"))

Aleph exposes data from the network as a Manifold stream, which can easily be transformed into a java.io.InputStream, core.async channel, Clojure sequence, or many other byte representations. It exposes simple default wrappers for HTTP, TCP, and UDP, but allows access to full performance and flexibility of the underlying Netty library.


datascript — an immutable in-memory database and Datalog query engine in Clojure and ClojureScript.


test.check— a Clojure property-based testing tool inspired by QuickCheck. The core idea of test.check is that instead of enumerating expected input and output for unit tests, you write properties about your function that should hold true for all inputs. This lets you write concise, powerful tests.


pulsar — Fibers, Channels and Actors for Clojure. Pulsar wraps the Quasar library with a Clojure API that’s very similar to Erlang.


schema — a Clojure (ClojureScript) library for declarative data description and validation.


Quil is a Clojure/ClojureScript library for creating interactive drawings and animations.


yada — a web library for Clojure, designed to support the creation of production services via HTTP.


hoplon — a set of tools and libraries for making web applications.

Example:

(page "index.html")

(defn my-list [& items]
(div
:class "my-list"
(apply ul (map #(li (div :class "my-list-item" %)) items))))

(def clicks (cell 0))

(html
(head
(title "example page"))
(body
(h1 "Hello, Hoplon")

(my-list
(span "first thing")
(span "second thing"))

(p (text "You've clicked ~{clicks} times, so far."))
(button :click #(swap! clicks inc) "click me")))

# C#

— — — — —

Flurl — a modern, fluent, asynchronous, testable, portable, buzzword-laden URL builder and HTTP client library.

Example:

var result = await "https://api.mysite.com"
.AppendPathSegment("person")
.SetQueryParams(new { api_key = "xyz" })
.WithOAuthBearerToken("my_oauth_token")
.PostJsonAsync(new { first_name = firstName, last_name = lastName })
.ReceiveJson<T>();

[Test]
public void Can_Create_Person() {
// fake & record all http calls in the test subject
using (var httpTest = new HttpTest()) {
// arrange
httpTest.RespondWith(200, "OK");

// act
await sut.CreatePersonAsync("Frank", "Underwood");

// assert
httpTest.ShouldHaveCalled("http://api.mysite.com/*")
.WithVerb(HttpMethod.Post)
.WithContentType("application/json");
}
}

Nancy — a lightweight, low-ceremony, framework for building HTTP based services on .NET Framework/Core and Mono. The goal of the framework is to stay out of the way as much as possible and provide a super-duper-happy-path to all interactions.

Example:

public class Module : NancyModule
{
public Module()
{
Get("/greet/{name}", x => {
return string.Concat("Hello ", x.name);
});
}
}

suave — a simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition. Suave is inspired in the simplicity of Happstack and born out of the necessity of embedding web server capabilities in my own applications. Still in its early stages Suave supports Websocket, HTTPS, multiple TCP/IP bindings, Basic Access Authentication, Keep-Alive.


# Swift

— — — — —

Eureka — is an elegant iOS form builder in Swift.


Alamofire — an HTTP networking library written in Swift.


Kingfisher is a lightweight, pure-Swift library for downloading and caching images from the web. This project is heavily inspired by the popular SDWebImage. It provides you a chance to use a pure-Swift alternative in your next app.


Quick is a behavior-driven development framework for Swift and Objective-C. Inspired by RSpec, Specta, and Ginkgo.


SwiftLint — a tool to enforce Swift style and conventions.


Kitura is a web framework and web server that is created for web services written in Swift. For more information, visit www.kitura.io.


vapor — the most used web framework for Swift. It provides a beautifully expressive and easy to use foundation for your next website, API, or cloud project.


# Bash/Shell

— — — — —

pyenv lets you easily switch between multiple versions of Python. It’s simple, unobtrusive, and follows the UNIX tradition of single-purpose tools that do one thing well.


Dokku is an docker powered mini-Heroku. The smallest PaaS implementation you’ve ever seen.


git-secret— a bash tool to store your private data inside a git repo. How’s that? Basically, it just encrypts, using gpg, the tracked files with the public keys of all the users that you trust. So everyone of them can decrypt these files using only their personal secret key. Why deal with all this private-public keys stuff? Well, to make it easier for everyone to manage access rights. There are no passwords that change. When someone is out - just delete his public key, re-encrypt the files, and he won’t be able to decrypt secrets anymore.


# R

— — — — —

Shiny is a new package from RStudio that makes it incredibly easy to build interactive web applications with R.


plotly — an R package for creating interactive web graphics via the open source JavaScript graphing library plotly.js.


# Scala

— — — — —

GitBucket — a Git platform powered by Scala with easy installation, high extensibility & github API compatibility.


Finatra — a lightweight framework for building fast, testable, scala applications on top of TwitterServer and Finagle. Finatra provides an easy-to-use API for creating and testing Finagle servers and apps as well as powerful JSON support, modern logging via SLF4J, Finagle client utilities, and more.


Scalatra is a tiny, Sinatra-like web framework for Scala.

Example:

import org.scalatra._
class ScalatraExample extends ScalatraServlet {
get("/") {
<h1>Hello, world!</h1>
}
}

algebird— an abstract algebra for Scala. This code is targeted at building aggregation systems (via Scalding or Apache Storm). It was originally developed as part of Scalding’s Matrix API, where Matrices had values which are elements of Monoids, Groups, or Rings. Subsequently, it was clear that the code had broader application within Scalding and on other projects within Twitter.

Example:

Welcome to Scala version 2.10.5 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_40).
Type in expressions to have them evaluated.
Type :help for more information.
scala> import com.twitter.algebird._
import com.twitter.algebird._
scala> import com.twitter.algebird.Operators._
import com.twitter.algebird.Operators._
scala> Map(1 -> Max(2)) + Map(1 -> Max(3)) + Map(2 -> Max(4))
res0: scala.collection.immutable.Map[Int,com.twitter.algebird.Max[Int]] = Map(2 -> Max(4), 1 -> Max(3))

That’s all. Thanks!