The really big list of really interesting Open Source projects.

Image for post

Hi, dear developers and readers!

If you are interested in Open Source and are considering joining 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.

I have a blog where I write about software development and stuff, so feel free to subscribe me: https://isaak.dev/

HERE YOU CAN FIND THE LAST VERSION OF THIS LIST (ON GITHUB).

# 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)

Image for post

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?

Image for post

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

Image for post

# Python

? ? ? ? ?

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

Image for post

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.

Image for post

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

Image for post

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.

Image for post

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.

Image for post

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.

Image for post

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

Image for post

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

Usage:

import requestsimport httprettydef 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.

Image for post

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 Kantnn’)# falcon.API instances are callable WSGI appsapp = falcon.API()# Resources are represented by long-lived class instancesthings = ThingsResource()# things will handle all requests to the ‘/things’ URL pathapp.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 Eveapp = Eve()app.run()

The API is now live, ready to be consumed:

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

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

Screenshot:

Image for post

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:

Image for postSpiral 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).

Image for post

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 reimport expynent.patterns as expasif 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 usernameu = input(‘Enter username: ‘)if username.match(u): print(‘valid’)else: print(‘invalid’)

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

Image for post

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

Screenshot:

Image for post

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

Screenshot:

Image for post

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

Screenshot:

Image for post

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.hours23>>> 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:

Image for postImage for post

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

Screenshot:

Image for post

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

Screenshot:

Image for post

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

Image for post

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:

Image for post

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.

Image for post

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.

Image for post

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:

Image for post

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.

Image for post

# 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.

Image for post

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’ namefunction Fruit:initialize(sweetness) self.sweetness = sweetnessendFruit.static.sweetness_threshold = 5 — class variable (also admits methods)function Fruit:isSweet() return self.sweetness > Fruit.sweetness_thresholdendlocal Lemon = class(‘Lemon’, Fruit) — subclassingfunction Lemon:initialize() Fruit.initialize(self, 1) — invoking the superclass’ initializerendlocal lemon = Lemon:new()print(lemon:isSweet()) — false

luarocks ? a package manager for Lua modules.

Image for post

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.

Image for post

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.

Image for post

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.

Image for post

# 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.

Image for post

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.

Image for post

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.

Image for post

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).

Image for post

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.

Image for post

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

Image for post

# 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.

Image for post

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.

Image for post

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

Image for post

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

Image for post

ginkgo ? a BDD Testing Framework for Go

Image for post

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

Image for post

Basic example:

package mainimport ( “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.

Image for post

gago ? genetic algorithm toolkit written in Go

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

Image for post

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.

Image for post

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.

Image for postImage for post

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

package mainimport ( “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.

Image for post

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

Image for post

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.

Image for post

Example:

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

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

Image for post

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.

Image for post

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:

Image for post

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.

Image for post

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

Image for post

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

Image for post

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

Screenshots:

Image for postImage for postImage for post

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.

Image for post

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

Screenshot:

Image for post

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.

Image for post

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:

Image for post

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

Screenshot:

Image for post

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

Screenshot:

Image for post

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

Example:

package mainimport ( “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.

Image for post

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

Screenshot:

Image for posttermui

hget ? Rocket fast download accelerator written in Golang.

Screenshot:

Image for post

# 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.

Image for post

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.

Image for post

mochiweb ? an Erlang library for building lightweight HTTP servers.

Image for post

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.

Image for post

hackney ? an HTTP client library for Erlang.

Image for post

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

Image for post

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

Image for post

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.

Image for post

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

Image for post

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 endenddefmodule Router.Homepage do use Maru.Router resources do get do json(conn, %{ hello: :world }) end mount Router.User endenddefmodule 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) endend

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.Helpershound_sessiontest “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” endend

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 likeiex> HTTPotion.get(“httpbin.org/get”, query: %{page: 2})%HTTPotion.Response{body: “…”, headers: [Connection: “keep-alive”, …], status_code: 200}# Form dataiex> 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 changediex> HTTPotion.get “http://example.com”, [timeout: 10_000]# If there is an error a `HTTPotion.ErrorResponse` is returnediex> HTTPotion.get “http://localhost:1″%HTTPotion.ErrorResponse{message: “econnrefused”}# You can also raise `HTTPError` with the `bang` version of requestiex> 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.

Image for post

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

Image for post

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

Image for post

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.

Image for post

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

Image for post

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]endPoison.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 thatdoes not compromise speed and maintainability (seems that?s true).

Image for post

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, :showendImage for post

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

Image for postIt 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:

Image for post

# Ruby

? ? ? ? ?

httparty ? Makes http fun again!

Example:

# Use the class methods to get down to business quicklyresponse = 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 classclass StackExchange include HTTParty base_uri ‘api.stackexchange.com’def initialize(service, page) @options = { query: { site: service, page: page } } enddef questions self.class.get(“/2.2/questions”, @options) enddef users self.class.get(“/2.2/users”, @options) endendstack_exchange = StackExchange.new(“stackoverflow”, 1)puts stack_exchange.questionsputs stack_exchange.users

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

Screenshot:

Image for post

rails_db ? Rails Database Viewer and SQL Query Runner.

Screenshot:

Image for post

# JavaScript / Node

? ? ? ? ?

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

Image for post

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

Image for post

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

Image for post

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.

Image for post

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.

Image for postImage for post

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.

Image for post

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.

Image for post

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

Image for post

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.

Image for post

eme ? Elegant Markdown Editor.

Image for post

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.

Image for post

mongo-hacker ? MongoDB Shell Enhancements for Hackers.

Screenshot:

Image for post

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

Screenshot:

Image for post

# OCaml

? ? ? ? ?

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

Image for post

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.

Image for post

# 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.

Image for post

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.

Image for post

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:

Image for post

CREATE COMPILATION RULES IN A HASKELL EDSL:

Image for post

COMPILE IT TO HTML AND UPLOAD IT!

Image for post

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.

Image for post

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

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

intero ? Complete interactive development program for Haskell

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

Image for post

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:

Image for post

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.

Image for post

# 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:

Image for post

# Clojure

? ? ? ? ?

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

Image for post

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 “/” “<h2>Hello World</h2>”) (route/not-found “<h2>Page not found</h2>”))

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.

Image for post

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

Image for post

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.

Image for post

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

Image for post

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.

Image for post

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 (h2 “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.

Image for post

# Swift

? ? ? ? ?

Eureka ? is an elegant iOS form builder in Swift.

Image for post

Alamofire ? an HTTP networking library written in Swift.

Image for post

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.

Image for post

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

Image for post

SwiftLint ? a tool to enforce Swift style and conventions.

Image for post

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

Image for post

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.

Image for post

# 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.

Image for post

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

Image for post

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.

Image for post

# R

? ? ? ? ?

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

Image for postImage for post

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

Image for postImage for postImage for post

# Scala

? ? ? ? ?

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

Image for post

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.

Image for post

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

Image for post

Example:

import org.scalatra._class ScalatraExample extends ScalatraServlet { get(“/”) { <h2>Hello, world!</h2> }}

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!

No Responses

Write a response