Links

 

Metrics: library to measure behavior of critical components

Metrics is a Java library which gives you unparalleled insight into what your code does in production. Developed by Yammer to instrument their JVM-based backend services, Metrics provides a powerful toolkit of ways to measure the behavior of critical components in your production environment. With modules for common libraries like Guice, Jetty, Log4j, Apache HttpClient, Ehcache, Logback and reporting backends like Ganglia and Graphite, Metrics provides you with full-stack visibility.

Homepage:
http://metrics.codahale.com/

Getting started and Manual:
http://metrics.codahale.com/getting-started.html

Sourcecode:
https://github.com/codahale/metrics

Filed under  //   asl   java   jmx   library   metrics   monitoring   opensource  
Posted February 2, 2012 by email 
 

List.js: makes plain HTML lists flexible, searchable, sortable and filterable

Do you want a 9 KB cross-browser native JavaScript that makes your plain HTML lists super flexible, searchable, sortable and filterable? Do you also want the possibility to add, edit and remove items by dead simple templating?

Ihfbafgc

http://listjs.com/
https://github.com/javve/list

Filed under  //   github   javascript   opensource  
Posted January 27, 2012 by email 
 

pocode: C++ library for production of interactive media across multiple platforms

pocode is an open-source C++ library designed by Potion for the production of interactive media across multiple platforms.

pocode provides a robust, high-performance software infrastructure that allows for the creation of all types of software, from simple visual sketches to elegant mobile apps to entire software applications.

pocode is much more than a graphics library. pocode allows creative coders to construct complex interactive software. Thanks to pocode’s object-oriented architecture, applications stay organized and take care of themselves. pocoders don’t have to worry about the intricacies of event routing, the frustrations of font loading or the pitfalls of porting between platforms. All of these processes are performed automatically.

pocode is also an open system that allows pocoders to dive deep into the software architecture and implement alternative methods of their own. pocoders can extend pocode with their own poObjects, and share them with other pocoders. Since all poObjects fit within pocode’s object-oriented framework, shared poObjects can easily be incorporated into new applications, even across platforms.

Jbfhaiae

http://www.pocode.org/
http://www.creativeapplications.net/c/pocode-c/

Filed under  //   c++   cpp   ios   iphone   library   mac   multimedia   opensource   osx   windows  
Posted January 26, 2012 by email 
 

Chameleon: port UIKit for iOS to Mac OS X

Chameleon is a port of Apple's UIKit for iOS (and some minimal related frameworks) to Mac OS X

Image

If you're an iOS developer, you're already familiar with UIKit, the framework used to create apps for the iPhone, iPod and iPad. Chameleon is a drop in replacement for UIKit that runs on Mac OS X. In many cases, your iOS code doesn't need to change at all in order to run on a Mac.

This new framework is a clean room implementation of the work done by Apple for iOS. The only thing Chameleon has in common with UIKit are the public class and method names. The code is based on Apple's documentation and does not use any private APIs or other techniques disallowed by the Mac App Store.

http://chameleonproject.org/
https://github.com/BigZaphod/Chameleon

Filed under  //   ios   iphone   mac   opensource   osx  
Posted January 11, 2012 by email 
 

Open vSwitch: production quality, multilayer open virtual switch

Open vSwitch is a production quality, multilayer virtual switch licensed under the open source Apache 2.0 license. It is designed to enable massive network automation through programmatic extension, while still supporting standard management interfaces and protocols (e.g. NetFlow, sFlow, RSPAN, ERSPAN, CLI, LACP, 802.1ag). In addition, it is designed to support distribution across multiple physical servers similar to VMware's vNetwork distributed vswitch or Cisco's Nexus 1000V.

Key Features

* Visibility into inter-VM communication via NetFlow, sFlow(R), SPAN, RSPAN, and ERSPAN
* LACP (IEEE 802.1AX-2008)
* Standard 802.1Q VLAN model with trunking
* 802.1ag link monitoring
* Fine-grained min/max rate QoS
* NIC bonding with source-MAC load balancing, active backup, and L4 hashing
* OpenFlow protocol support (including many extensions for virtualization)
* IPv6 support
* Multiple tunneling protocols (Ethernet over GRE, CAPWAP, IPsec, GRE over IPsec)


Supported Platforms

Open vSwitch can operate both as a soft switch running within the hypervisor, and as the control stack for switching silicon. It has been ported to multiple virtualization platforms and switching chipsets. It is the default switch in XenServer "Project Boston", the Xen Cloud Platform and also supports Xen, KVM, Proxmox VE and VirtualBox. It has also been integrated into many virtual management systems including OpenStack, openQRM, and OpenNebula.


Jhbeaeff

 http://openvswitch.org/

Filed under  //   cloud   hypervisor   kvm   network   opensource   switch   virtualbox   virtualization   xen  
Posted September 23, 2011 by email 
 

node.x: JVM framework for event based, highly scalable applications

What is Node.x?

* A general purpose framework that uses an event based style for
building highly scalable applications
* Runs on the JVM.
* Everything is asynchronous.
* Embraces the style of node.js and extends it to the JVM. Think
node.js/on steroids/. Plus some.
* Polyglot. The same (or similar) API will be available in multiple
languages: Initially Ruby (JRuby), Groovy and Java and going
ahead... JavaScript (Rhino/Nashorn), Python (Jython), Clojure, Scala
etc.
* Goes with the recent developments with InvokeDynamic in Java 7 and
bets on the JVM being the future premier runtime for dynamic languages.
* Enables you to create network servers or clients incredibly easily.
* True threading. Unlike node.js, Python Twisted or Ruby EventMachine,
it has true multi-threaded scalability. No more spinning up 32
instances just to utilise the cores on your server.
* Incredibly simple concurrency model. Write your code as single
threaded like node.js, watch it scale across multiple cores (unlike
node.js)
* Understands multiple network protocols out of the box including:
TCP, SSL, UDP, HTTP, HTTPS, Websockets
* Sendfile support for writing super scalable web servers
* Will provide plugins for talking AMQP, STOMP, Redis etc
* Provides an elegant api for composing asynchronous actions together.
Glue together HTTP, AMQP, Redis or whatever in a few lines of code.


https://github.com/purplefox/node.x

Filed under  //   event   framework   groovy   java   jruby   jvm   node.js   opensource   scalable  
Posted September 20, 2011 by email 
 

Restkit: Objective-C framework providing HTTP request/response API with object mapping

RestKit is an Objective-C framework for iOS that aims to make interacting with RESTful web services simple, fast and fun. It combines a clean, simple HTTP request/response API with a powerful object mapping system that reduces the amount of code you need to write to get stuff done.

Cahahgcd

What does Restkit Provide?

A simple, high level HTTP request / response system.
RestKit ships with an HTTP client built on top of NSURLConnection and provides a library of helpful methods for inspecting MIME types and status codes. Submitting form data is as simple as providing a dictionary of parameters and a native params object is included for easily creating multi-part submissions.

Core Data support.
Building on top of the object mapping layer, RestKit provides integration with Apple’s Core Data framework. This support allows RestKit to persist remotely loaded objects directly back into a local store, either as a fast local cache or a primary data store that is periodically synced with the cloud. RestKit can populate Core Data associations for you, allowing natural property based traversal of your data model. It also provides a nice API on top of the Core Data primitives that simplifies configuration and querying use cases.

Database Seeding.
When the Core Data object store is used, you can seed a database from a collection of data files. This lets you submit your apps to the App Store with a database in the app bundle that is ready for immediate use.

Framework level support for switching servers & environments (development/production/staging).
RestKit uses a base URL and resource paths rather than full URL’s to allow you to switch target servers quickly. Interpolating URL strings and constructing NSURL objects is a thing of the past.

An object mapping system.
RestKit provides a modeling layer for mapping processed data payloads into native Cocoa objects declaratively. This lets the application programmer stop worrying about parsing and simply ask the framework to asynchronously fetch a remote resource and call the delegate with the results. Object mapping is implemented using key-value coding, allowing for quick traversal of the parsed object graph. Reflection is used on the property types to allow for mapping from remote dates encoded as a string back to NSDate objects.

Pluggable parsing layer.
RestKit currently supports JSON via the SBJSON and YAJL parsers. Parsing is implemented behind a simple interface to allow additional data formats to be handled transparently.

http://restkit.org/
https://github.com/RestKit/RestKit

Filed under  //   ios. apple   ipad   iphone   objective-c   opensource   rest   webservices  
Posted September 12, 2011 by email 
 

AChartEngine: charting library for Android

AChartEngine 

is a charting library for Android applications. It currently supports the following chart types:
  • line chart
  • area chart
  • scatter chart
  • time chart
  • bar chart
  • pie chart
  • bubble chart
  • doughnut chart
  • range (high-low) bar chart
  • dial chart / gauge
  • combined (any combination of line, cubic line, scatter, bar, range bar, bubble) chart
  • cubic line chart
All the above supported chart types can contain multiple series, can be displayed with the X axis horizontally (default) or vertically and support many other custom features. The charts can be built as a view that can be added to a view group or as an intent, such as it can be used to start an activity.

http://code.google.com/p/achartengine/

(download)

Filed under  //   android   asl   charts   graphs   opensource  
Posted September 1, 2011 by email 
 

Ripple: declarative dataflow language for the Semantic Web

Ripple is a declarative, stack-oriented dataflow language for exploring the Semantic Web and other multi-relational networks. Ripple programs resemble path expressions as in XPath and postfix-style procedures as in Forth. Every program has an RDF representation, so you can embed programs in the Web of Data as well as querying against it. This implementation is written in Java and includes an interactive command-line interpreter as well as a query API which interoperates with Sesame 2.0.

https://github.com/joshsh/ripple
http://ripple.fortytwo.net/

Filed under  //   java   json   linkeddata   opensource   rdf   semanticweb  
Posted August 18, 2011 by email