Finagle: Protocol agnostic extensible RPC system for the JVM with Java & Scala APIs

http://twitter.github.io/finagle/ (via)

Finagle is an extensible RPC system for the JVM, used to construct high-concurrency servers. Finagle implements uniform client and server APIs for several protocols, and is designed for high performance and concurrency. Most of Finagle’s code is protocol agnostic, simplifying the implementation of new protocols.

Finagle is written in Scala, but provides both Scala and Java idiomatic APIs.

Quasar: Java library providing high-performance lightweight threads similar to go-routines

http://docs.paralleluniverse.co/quasar/

From the Quasar website:

Java 7 is required to run Quasar.

Quasar is a Java library that provides high-performance lightweight threads, Go-like channels, Erlang-like actors, and other asynchronous programming tools.

Quasar’s chief contribution is that of the lightweight thread, called fiber in Quasar.
Fibers provide functionality similar to threads, and a similar API, but they’re not managed by the OS. They are lightweight in terms of RAM (an idle fiber occupies ~400 bytes of RAM) and put a far lesser burden on the CPU when task-switching. You can have millions of fibers in an application. If you are familiar with Go, fibers are like goroutines. Fibers in Quasar are scheduled by one or more ForkJoinPools.

Fibers are not meant to replace threads in all circumstances. A fiber should be used when its body (the code it executes) blocks very often waiting on other fibers (e.g. waiting for messages sent by other fibers on a channel, or waiting for the value of a dataflow-variable). For long-running computations that rarely block, traditional threads are preferable. Fortunately, as we shall see, fibers and threads interoperate very well.

Fibers are especially useful for replacing callback-ridden asynchronous code. They allow you to enjoy the scalability and performance benefits of asynchronous code while keeping the simple to use and understand threaded model.

Spring Boot: Create Spring applications with minimal configuation

Spring Logo

From Spring Boot page:

Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that can you can “just run”. We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration.

  • Create stand-alone Spring applications
  • Embed Tomcat or Jetty directly (no need to deploy WAR files)
  • Provide opinionated ‘starter’ POMs to simplify your Maven configuration
  • Automatically configure Spring whenever possible
  • Provide production-ready features such as metrics, health checks and externalized configuration
  • Absolutely no code generation and no requirement for XML configuration

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.

Presentation Slides: Micro services – Java, the Unix Way

Here are some interesting slides from a talk on Micro services:

http://2012.33degree.org/talk/show/67

From the summary:

“Write programs that do one thing and do it well. Write programs to work
together” was accepted 40 years ago yet we have spent the last decade building
monolithic applications, communicating via bloated middleware and with our
fingers crossed that Moore’s Law keeps helping us out. There is a better way.

Micro services. In this talk we will discover a consistent and reinforcing set
of tools and practices rooted in the the Unix Philosophy of small and simple.
Tiny applications, communicating via the web’s uniform interface with single
responsibilities and installed as well behaved operating system services. So,
are you sick of wading through tens of thousands of lines of code to make a
simple one line change? Of all that XML? Come along and check out what the
cools kids are up to (and the cooler grey beards).

This is a talk about building micro-services using simple java tools