Month: April 2014

GoLang HTTP load testing tool and library

Vegeta image
ᔥ

Not as poweful as JMeter, but way simpler to get setup, especially from the command line. I am currently using it to throw some load at a dev server to observe the memory utilization over time.

$ vegeta -h
Usage: vegeta [globals] <command> [options]

attack command:
  -body="": Requests body file
  -duration=10s: Duration of the test
  -header=: Request header
  -ordering="random": Attack ordering [sequential, random]
  -output="stdout": Output file
  -rate=50: Requests per second
  -redirects=10: Number of redirects to follow
  -targets="stdin": Targets file
  -timeout=0: Requests timeout

report command:
  -input="stdin": Input files (comma separated)
  -output="stdout": Output file
  -reporter="text": Reporter [text, json, plot]

global flags:
  -cpus=8 Number of CPUs to use

examples:
  echo "GET http://localhost/" | vegeta attack -duration=5s | tee results.bin | vegeta report
  vegeta attack -targets=targets.txt > results.bin
  vegeta report -input=results.bin -reporter=json > metrics.json
  cat results.bin | vegeta report -reporter=plot > plot.html

RoboVM: Create native iOS apps in Java

RoboVM Logo

From the RoboVM website:

Java bytecode to native
RoboVM translates Java bytecode into native ARM or x86 code. Apps run fast
directly on the CPU. No interpreter involved.

Native API and hardware access
RoboVM includes a Java to Objective-C bridge that makes it possible to call
into the native iOS CocoaTouch APIs. Objective-C objects can be used just like
any other Java object.

Code reuse
Easily share code between desktop, Android and iOS apps. The standard classes
(java.lang.*, java.util.*, etc) included in RoboVM are based on Android’s
runtime.

Open-source
The compile time tools are GPLv2 licensed. Runtime code is licensed under
business friendly licenses, mostly the Apache License v2.0.

Familiar tools
RoboVM comes with Eclipse and Maven integration. Use the tools you’re used to
from the Java world.

GitHub Cheat Sheet

GitHub Cheat Sheet

Here’s the list of items from the table of contents:

  • GitHub
    • Ignore Whitespace
    • Commit History by Author
    • Cloning a Repository
    • Comparing Branches
    • Compare Branches across Forked Repositories
    • Gists
    • Git.io
    • Keyboard Shortcuts
    • Line Highlighting in Repositories
    • Closing Issues via Commit Messages
    • Cross-Link Issues
    • Syntax Highlighting in Markdown Files
    • Emojis
    • Images/GIFs
      • Embedding Images in GitHub Wiki
    • Quick Quoting
    • Quick Licensing
    • Task Lists
    • Relative Links
    • Metadata and Plugin Support for GitHub Pages
    • Diffs
      • Rendered prose Diffs
      • Diffable Maps
      • Expanding Context in Diffs
    • Hub
    • Decreasing Contributor Friction
    • Contributing Guidelines
    • Git
    • Previous Branch
    • Checking out Pull Requests
    • Empty Commits :trollface:
    • Styled Git Status
    • Styled Git Log
    • Git Query
    • Merged Branches
    • Web Server for Browsing Local Repositories
    • Git Configurations
      • Aliases
      • Auto-Correct
      • Color

Spray: Build REST/HTTP-based integration layers on top of Scala & Akka

Spray Logo

From the Spray Website:

Spray is a suite of lightweight Scala libraries providing client- and
server-side REST/HTTP support on top Akka.

Fully asynchronous, non-blocking
All APIs are fully asynchronous, blocking code is avoided wherever at all
possible.

Actor- and Future-based
spray fully embraces the programming model of the platform it is built upon.
Akka Actors and Futures are key constructs of its APIs.

High-performance
Especially sprays low-level components are carefully crafted for excellent
performance in high-load environments.

Lightweight
All dependencies are very carefully managed, sprays codebase itself is kept
as lean as possible.

Modular
Being structured into a set of integrated but loosely coupled components your
application only needs to depend onto the parts that are actually used.

Testable
All spray components are structured in a way that allows for easy and
convenient testing.