Awesome List Updates on Dec 14 - Dec 20, 2015

ResponseDetective (⭐2k) - A non-intrusive framework for intercepting any outgoing requests and incoming responses between your app and server for debugging purposes.

UI / Barcode

BreakOutToRefresh (⭐2.5k) - A playable pull to refresh view using SpriteKit.

FloatRatingView (⭐549) - Floating rating system.

Menu / Barcode

ENSwiftSideMenu (⭐1.8k) - Sliding side menu.

GuillotineMenu (⭐2.9k) - Guillotine style menu.

Transition / Barcode

PinterestSwift (⭐1.9k) - Pinterest style transition.

StarWars.iOS (⭐3.8k) - Transition animation to crumble view-controller into tiny pieces.

Utility / Barcode

Swiftx (⭐219) - Functional data types and functions for any project.

9. Awesome Malware Analysis

Network / Other Resources

Maltrail (⭐5.9k) - A malicious traffic detection system, utilizing publicly available (black)lists containing malicious and/or generally suspicious trails and featuring an reporting and analysis interface.

10. Es6 Tools

Code generation / Brunch Plugins

generator-gulp-babelify (⭐3) - Yeoman generator for Babel, Browserify and Gulp

11. Engineering Blogs

12. Awesome Polymer

Theming/Styling

Polystyle Wrap existing stylesheets with Polymer's style module system.

13. Awesome Ruby

API Builder and Discovery

Grape - An opinionated micro-framework for creating REST-like APIs in Ruby.

Database Drivers

TinyTDS (⭐606) - FreeTDS bindings for Ruby using DB-Library.

14. Amas

Ask these organizations anything!

Vim Taiwan (⭐16) - Helping vimmers in Taiwan with any questions.

15. Inspire

Concept / These sites are good to get a general idea of possible layouts and style paths to take.

CodePen - Central repository of user submitted code concepts/snippets. Great for experiments.

16. Awesome Groovy

Blogs of core committer

Jochen Theodorou's blog

17. Awesome Computer Vision

Visual Tracking / Nearest Neighbor Field Estimation

Online-boosting Tracking

Enhanced adaptive coupled-layer LGTracker++

TLD: Tracking - Learning - Detection

Kernelized Correlation Filters

Accurate Scale Estimation for Robust Visual Tracking

Multiple Experts using Entropy Minimization

TGPR

18. Awesome Bitcoin

Open Source Wallets

Electrum

19. Awesome Stock Resources

Icons / Icon Fonts

Iconfinder - Iconfinder provides beautiful icons to millions of designers and developers. Most icons are available under attribution. See individual licenses for more details.

20. Awesome Security

Other Awesome Lists / Other Security Awesome Lists

Awesome Incident Response (⭐7.1k) - A curated list of resources for incident response.

21. Awesome Rxjava

Bindings

RxTuples (⭐113) - Simple tuples to use with RxJava.

22. Awesome Relay

Documentation

Official Docs - Official Relay documentation.

Tutorials

Getting Started with Relay - One of the few detailed walk throughs of hand-on Relay.

Overviews

React Data Fetching with Relay - Clear conceptual overview of Relay's moving parts and magic.

Lists of Lists

Relay and GraphQL Introduction Materials

Tooling

GraphiQL (⭐14k) - A library to introspect GraphQL, test queries and mutations.
- GraphiQL App (⭐2.9k) - A standalone app for viewing GraphQL, introspection docs, and testing queries/mutations. Invaluable for debugging your Relay app.

Starter Kits

Relay Starter Kit (⭐1k) - An app that it already set up with a basic setup. Just clone and tweak to suit your needs!

23. Awesome Pcaptools

Traffic Capture

clj-net-pcap (⭐66): clj-net-pcap is a packet capturing library for Clojure. clj-net-pcap uses jNetPcap and adds convenience functionality around jNetPcap for easing the usability. A paper on clj-net-pcap was published in scope of COMPSACW 2014.

Yaf: It's a reliable piece of software, quite solid and able to generate flow records from pcap. This is very nice for indexing huge pcap or even doing packet capture. The recent version can even extract payloads and put in the flow records.

Traffic Analysis/Inspection

AIEngine: is a next generation interactive/programmable packet inspection engine with capabilities of learning without any human intervention, NIDS functionality, DNS domain classification, network collector and many others. AIEngine also helps network/security professionals to identify traffic and develop signatures for use them on NIDS, Firewalls, Traffic classifiers and so on.

HttpSniffer (⭐185): A multi-threading tool to sniff TCP flow statistics and embedded HTTP headers from PCAP file. Each TCP flow carrying HTTP is exported to text file in JSON format.

Libnids: designed by Rafal Wojtczuk, is an implementation of an E-component of Network Intrusion Detection System. It emulates the IP stack of Linux 2.0.x. Libnids offers IP defragmentation, TCP stream assembly and TCP port scan detection. The most valuable feature of libnids is reliability. A number of tests were conducted, which proved that libnids predicts behaviour of protected Linux hosts as closely as possible.

NetDude: (NETwork DUmp data Displayer and Editor). From their webpage, "it is a GUI-based tool that allows you to make detailed changes to packets in tcpdump tracefiles."

Ntop: Ntop is a network traffic probe that shows the network usage, similar to what the popular top Unix command does. ntop is based on libpcap and it has been written in a portable way in order to virtually run on every Unix platform and on Win32 as well.

Pcap2har (⭐232): A program to convert .pcap network capture files to HTTP Archive files using library dpkt.

pkt2flow (⭐161): A simple utility to classify packets into flows. It's so simple that only one task is aimed to finish. For Deep Packet Inspection or flow classification, it's so common to analyze the feature of one specific flow. I have make the attempt to use made-ready tools like tcpflows, tcpslice, tcpsplit, but all these tools try to either decrease the trace volume (under requirement) or resemble the packets into flow payloads (over requirement). I have not found a simple tool to classify the packets into flows without further processing.

Scapy: Scapy is a powerful interactive packet manipulation program. It is able to forge or decode packets of a wide number of protocols, send them on the wire, capture them, match requests and replies, and much more. It can easily handle most classical tasks like scanning, tracerouting, probing, unit tests, attacks or network discovery (it can replace hping, 85% of nmap, arpspoof, arp-sk, arping, tcpdump, tethereal, p0f, etc.). It also performs very well at a lot of other specific tasks that most other tools can't handle, like sending invalid frames, injecting your own 802.11 frames, combining technics (VLAN hopping+ARP cache poisoning, VOIP decoding on WEP encrypted channel, ...), etc.

Sniff: Makes output from the tcpdump program easier to read and parse.

TCP-Reduce: TCP-Reduce is a collection of Bourne shell scripts for reducing tcpdump traces to one-line summaries of each TCP connection present in the trace. The scripts look only at TCP SYN/FIN/RST packets. Connections without SYN packets in the trace (such as those on- going at the beginning of the trace) will not appear in the summary. Garbaged packets (those missing some of their contents) are reported to stderr as bogon's and are discarded. Occasionally the script gets fooled by retransmissions with altered sequence numbers, and reports erroneous huge connection sizes - always check large connections (say 100 MB or more) for plausibility.

Tcpdpriv: Tcpdpriv is program for eliminating confidential information (user data and addresses) from packets collected on a network interface (or, from trace files created using the -w argument to tcpdump). Tcpdpriv removes the payload of TCP and UDP, and the entire IP payload for other protocols. It implements several address scrambling methods; the sequential numbering method and its variants, and a hash method with preserving address prefix.

Tcplook: Tracelook is an Tcl/TK program for graphically viewing the contents of trace files created using the -w argument to tcpdump. Tracelook should look at all protocols, but presently only looks at TCP connections. The program is slow and uses system resources prodigiously.

TraceWrangler: TraceWrangler is a network capture file toolkit running on Windows (or on Linux, using WINE) that supports PCAP as well as the new PCAPng file format, which is now the standard file format used by Wireshark. The most prominent use case for TraceWrangler is the easy sanitization and anonymization of PCAP and PCAPng files (sometimes called "trace files", "capture files" or "packet captures"), removing or replacing sensitive data while being easy to use.

Tstat: A passive sniffer able to provide several insight on the traffic patterns at both the network and transport levels with a tremendous set of flow features.

Xplot: The program xplot was written in the late 1980s to support the analysis of TCP packet traces.

File Extraction

Tcpick: is a textmode sniffer libpcap-based that can track, reassemble and reorder tcp streams. Tcpick is able to save the captured flows in different files or displays them in the terminal, and so it is useful to sniff files that are transmitted via ftp or http. It can display all the stream on the terminal, when the connection is closed in different display modes like hexdump, hexdump + ascii, only printable characters, raw mode and so on.

Tcpxtract: is a tool for extracting files from network traffic based on file signatures. Extracting files based on file type headers and footers (sometimes called "carving") is an age old data recovery technique.

Xplico: The goal of Xplico is extract from an internet traffic capture the applications data contained. For example, from a pcap file Xplico extracts each email (POP, IMAP, and SMTP protocols), all HTTP contents, each VoIP call (SIP), FTP, TFTP, and so on. Xplico isn't a network protocol analyzer. Xplico is an open source Network Forensic An alysis Tool (NFAT). Xplico is released under the GNU General Public License and with some scripts under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0) License.

Related Projects / Analysis

Haka: An open source security oriented language which allows to describe protocols and apply security policies on (live) captured traffic. The scope of Haka language is twofold. First of all, it allows to write security rules in order to filter/alter/drop unwanted packets and log and report malicious activities. Second, Haka features a grammar enabling to specify network protocols and their underlying state machine.

RIPE-NCC Hadoop for PCAP (⭐203): A Hadoop library to read packet capture (PCAP) files. Bundles the code used to read PCAPs. Can be used within MapReduce jobs to natively read PCAP files. Also features a Hive Serializer/Deserializer (SerDe) to query PCAPs using SQL like commands.

24. Awesome Dotnet

ORM

AsyncPoco (⭐128) - A long-"awaited" fully asynchronous PetaPoco fork

NPoco (⭐846) - Simple microORM that maps the results of a query onto a POCO object. Based on Schotime's branch of PetaPoco

25. Awesome Bigdata

Machine Learning

BidMach (⭐914) - CPU and GPU-accelerated Machine Learning Library.

26. Motion Ui Design

Guidelines / SVG

SalesForce Lightning

27. Nginx Resources

Understanding Nginx

History of Nginx

Understanding Nginx versioning

Architecture

Inside NGINX: How We Designed for Performance & Scale

Thread Pools in NGINX

Configuration

Nginx Pitfalls

Tutorials

NGINX as a WebSockets Proxy

HTTP Keepalive Connections and Web Performance

Hacks

Nginx JSON hacks

Capture and delay unwanted requests (⭐25)

Nginx + Lua

Pushing Nginx to its limit with Lua

Nginx and Lua

Talks

NGINX Conference

28. Awesome Laravel

Popular Packages / Databases, ORMs, Migrations & Seeding

Eloquence (⭐467) - Extra features for Eloquent models

Sofa/Eloquence (⭐1.1k) - Extensions for the Eloquent ORM

Books / Videos

Laravel Collections Unraveled by Jeff Madsen

29. Awesome Elixir

Applications

medex (⭐6) - Medical Examination - application for register health check callbacks and represent their state via HTTP.

Audio and Sounds

synthex (⭐44) - A signal synthesis library.

Authentication

ueberauth_twitter (⭐36) - Twitter Strategy for Überauth.

Build Tools

rebar3_protobuffs (⭐10) - rebar3 protobuffs provider using protobuffs from Basho.

Caching

lru_cache (⭐36) - Simple LRU Cache, implemented with ets.

Examples and funny stuff

butler_cage (⭐3) - A Butler plugin for showing silly photos of Nick Cage.

butler_tableflip (⭐2) - Flipping tables with butler.

Framework Components

exdjango (⭐20) - A few elixir libraries for working with django.

Geolocation

distance_api_matrix (⭐29) - Provide distance and heading calculations via Google distance matrix api.

HTTP

yuri (⭐13) - Simple struct for representing URIs.

Images

imgex (⭐33) - Unofficial client library for generating imgix URLs in Elixir.

Macros

kwfuns (⭐2) - Macros to create functions with syntax based keyword parameters with default values.

ORM and Datamapping

ets_map (⭐8) - An Elixir package that provides a Map-like interface (Map/Access/Enumerable/Collectable) backed by an ETS table.

OTP

erlexec (⭐525) - Execute and control OS processes from Erlang/OTP.

Queue

stream_weaver - Library for working with streams.

Text and Numbers

bencode (⭐18) - A Bencode encoder and decoder for Elixir. The decoder will return the checksum value of the info dictionary, if an info dictionary was found in the input.

elixir-range-extras (⭐8) - Elixir range utilities: constant-time random sampling and set operations.

Third Party APIs

apns (⭐70) - Apple Push Notifications Service client library for elixir.

zanox (⭐1) - Zanox API.

YAML

fast_yaml (⭐51) - Fast YAML is an Erlang wrapper for libyaml "C" library.

Screencasts

ExCasts - Elixir and Phoenix screencasts for all skill levels.

30. Awesome Neo4j

REST API / Other

ineo (⭐76)- A simple but useful Neo4j instance manager.

31. Awesome Salesforce

Table of Contents / Plugins for Salesforce

ApexMate (⭐23)- Apex Plugin for TextMate.

Force.com CLI- Command-line interface to Force.com.

Table of Contents / Developer Utilities

CassaCloud- Nice salesforce debug helps you to understand logs from Salesforce developer console. For example if you have Map of map with lists, it is hard to find value where it exactly is.