Links

 

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 
 

Lager: logging framework for Erlang/OTP

Lager (as in the beer) is a logging framework for Erlang. Its purpose is to provide a more traditional way to perform logging in an erlang application that plays nicely with traditional UNIX logging tools like logrotate and syslog.

http://blog.basho.com/2011/07/20/Introducing-Lager-A-New-Logging-Framework-fo...
https://github.com/basho/lager

Filed under  //   erlang   framework   library   logging   opensource   otp  
Posted July 21, 2011 by email 
 

raphters: web framework for C

Raphters is a web framework for C based on the rapht architectural pattern
.

C is fast and fun, when you use well-tested code it can be secure too. It also has a low memory foot-print. The aim of the project is that all of the usual functionality that you have in other frameworks (cookie handling, session management, templating etc) will be implemented via loosly coupled components with clean APIs.


Deployment

The examples are deployable via fastcgi.


RAPHT was designed for the web. It is basically an extension to MVC that
provides greater security and flexibility.


R - Resource
A - Action
P - Processor
H - Handler
T - Template

Resources: Resources are things that you can interact with. This could be a database or an
external API for example.

Action: A action is a way to interact with a resource. Typically it is given
information that relates to authentication as well as information about the
request. Resources are not accessed without actions.

Processor: A transformation of data.

Handler: The entry point for a request. In a web application, a url regex is typically
mapped to a handler.

Template: Renders data.


https://github.com/DanielWaterworth/raphters

Filed under  //   C   framework   web  
Posted April 5, 2011 by email 
 

Treesaver: JavaScript framework for magazine-style layouts

Treesaver is a JavaScript framework for creating magazine-style layouts that dynamically adapt to a wide variety of browsers and devices. Designers use standards-compliant HTML and CSS for both content and design, no JavaScript programming is required.

Key features and aspects:

  • Fast and compact: The JavaScript is under 25K gzipped (important for mobile).
  • Highly compatible: Works with most modern browsers, and degrades gracefully for older browsers (or those with JavaScript disabled).
  • Liberally licensed: Dual-licensed as MIT and GPL.

What Treesaver is not

  • Complete: The framework is still quite immature. There are still a lot of bugs that need to be fixed.
  • WYSIWYG: Treesaver is not designed to provide designers with the ability to create pixel-perfect layouts -- quite the opposite in fact. Treesaver is designed to give designers the ability to create general design guidelines, which are then used to quickly construct a layout appropriate to the current browser and device.
  • Suited for all content: Treesaver currently works best with simply-formatted text and images. Complex tables, videos, and JavaScript widgets might work, or they might not. Once again, the framework is not yet complete.

Project page: http://treesaverjs.com/

Code (GitHub): https://github.com/Treesaver/treesaver

Wiki: https://github.com/Treesaver/treesaver/wiki

Demo: http://www.publicintegrity.org/treesaver/tuna/index.html

(download)

Filed under  //   framework   javascript   layout   library   ui   web  
Posted February 14, 2011 by email 
 

Three20: collection of iPhone UI classes

Three20 is an iPhone development library. It's the code that powers the Facebook iPhone app and many other apps in the app store.

Core

Think of core as your swiss-army knife of Objective-C development. You should take some time to familiarize yourself with its features.

With the Three20 Core you can

  • generate md5 hashes from NSData objects,
  • extend the logging and debug capabilities of Xcode,
  • compare two version strings (is 3.0 older than 3.1?),
  • create non-retaining NSArrays and NSDictionaries for delegate use,
  • strip HTML tags from strings,
  • safely add non-empty, non-nil strings to NSDictionaries,
  • and format dates in relative time (5 hours ago).

You'll find all of these methods in the Three20 Xcode project in the
Global => Core and Global => Additions => Core groups.

Network

If you're building an app that uses a web-based API, Three20's Network component is going to make your job easier. Three20 supports disk and memory network caching. There is also a layer built upon requests that makes it easy to process the response data.

UI

A growing set of common views and controllers is available within the Three20 UI. The well-known Facebook photo browser/thumbnail viewer is one such controller.

http://three20.info/

http://github.com/facebook/three20/

(download)

Filed under  //   framework   ios   ipad   iphone   library   ui  
Posted October 18, 2010 by email 
 

Composite Bundles - Isolating Applications in a Collaborative OSGi World

The OSGi specification (R4.2) introduced a provisional specification called composite bundles. In this talk the lead developers of two prominent open source OSGi framework implementations will join forces to discuss lessons learned with the provisional composite bundle specification and what improvements are expected for the next release of the core framework specification for composite bundles. Richard Hall is the chair of the Apache Felix project and Tom Watson is the co-lead of the Eclipse Equinox project. Together they will explain the issues with the R4.2 provisional composite specification and discuss the changes being done in order to graduate the composite bundle specification for the next OSGi core specification release.

The OSGi framework provides a powerful runtime for the Java platform, which promotes strong modularity, versioning and dynamic management of applications. Bundles (or modules) installed in the framework are expected to collaborate and live together sharing the same service registry and public class space. Until now there was no standard way to provide additional isolation to a group of bundles installed in a single framework. In this talk we will discuss how composite bundles can be used to provide additional isolation to a group of bundles or applications installed into the framework.

Composite bundles are managed in a similar way as other bundles installed into an OSGi framework. The key difference is the content of a composite bundle is composed by a set of bundles called constituents. Conceptually a composite bundle provides a virtual framework, called a composite framework, where constituent bundles are installed and running. The composite bundle can be used to manage the composite framework. Composite bundles support a two-way relationship between the parent framework and composite framework instances, where packages and services can be shared from the parent to the composite framework and vice versa.

During this talk we will go into the gory details of the composite bundle specification and demonstrate composite bundles running on an OSGi framework implementation.


Thomas co-leads the Equinox Project at Eclipse and is a member of the Eclipse Runtime PMC. Thomas has 10 years of experience as an IBM software architect and developer, and is currently working for IBM Lotus. Thomas's focus is on modularity and the OSGi Framework design and development. He is the lead developer for the Equinox OSGi Framework implementation in Eclipse.

Thomas has been involved in the development of OSGi technologies since 2002 and played a key role in the adoption of OSGi technologies by the Eclipse platform. He is currently a member of the OSGi Core Platform Expert Group (CPEG) and made significant contributions to the OSGi Release 4 specifications.

(From http://www.eclipsecon.org/2010/sessions/?page=sessions&id=1224)

Filed under  //   equinox   framework   osgi  
Posted April 9, 2010 by email 
 

Vaadin: Java web application framework

http://vaadin.com/

Vaadin is a Java web application framework. It is designed for creating rich and interactive applications that run in the browser, without any plugins. A server-driven architecture together with reusable component model is used to simplify programming of applications and for better web application security. No HTML, XML or JavaScript necessary and all Java libraries and tools at your disposal.

Vaadin is is designed to build web applications, not just web sites. This positions it for application development rather than website development. The programming model is much like in traditional desktop programming too with events and listeners rather than requests and responses. If you have written Swing or SWT-applications you'll feel right at home with Vaadin. The most significant differences between Vaadin and other web application libraries are summarized in the comparison matrix.

GWT applications run in the browser while Vaadin applications run on the server. We do actually use GWT as a "rendering engine" on the browser side so you can combine Vaadin and GWT.

Outlook

Filed under  //   framework   gwt   java   ui   web  
Posted August 12, 2009 by email