Category Archives: Newsletter

Caucho Newsletter March 2017

          main caucho logo 3      
    Caucho at Devoxx - for the developers!

     Q1 has been filled with activity at Caucho!

Developer Sean Wiley is on the road presenting at key events including Devoxx US. We continue to collect valuable feedback from Resin users and look forward to the next release, Resin 4.0.51. We encourage you to report any issues with reproducible behavior to website, or by reaching out directly to us at

Newsletter at a Glance:Sun_with_Sunglasses_Transparent_Picture.png

  • Caucho presents Baratine @ Devoxx 2017, March 21-23 in San Jose
  • Caucho presents webinar with Elastic Beam
  • Caucho presents @ San Diego JUG
  • Resin High Availability Settings (Part 2)
Caucho Presenting Baratine @ Devoxx 2017

Join Caucho Engineer Sean Wiley for a “Tools in Action” presentation on server side Java. Sean will be presenting on operational service views using Caucho’s MicroService Platform Baratine (link to

Sean’s presentation will provide details into how MicroServices can improve high volume web services, making bottlenecks a thing of the past. The talk will integrate these services with current architecture, allowing developers to use platforms they are familiar with for next generation applications.


If you’d like to meet up with Sean for a coffee or beer during Devoxx, contact him at


Devoxx conferences in Europe are famous for being vendor neutral community events, organized by developers, for developers. The events are always highly intellectual, geeky and fulfilling conversations with some of the best speakers and attendees in the industry.

Register for the event and find out more information here:

Caucho/Elastic Beam Webinar

Ouch!!! We saw that Gartner estimates that downtime costs are >$300,000/hr with variation based on industry vertical and other factors. So we partnered with Elastic Beam to build a robust web application server environment that delivers performance, security and minimizes costly downtime.


Our webinar focused on simplifying and securing application infrastructures with example deployments. We also touched on the following questions: 


   What is causing availability issues with today’s Java EE application servers?

   What are the critical requirements to consider when building robust web-scale infrastructure?

   How do you build highly available web infrastructure with a software only approach to avoid significant costs?

   What types of hacker attacks do you need to worry about?

   How to secure your applications against malicious activity? 

   How to track API usage and detect abnormal behavior?


To  learn more, please reach out to us at

San Diego JUG

We gave a talk at the San Diego Java Users Group on high availability of the Resin Application Server. The talk was well received and we were glad to share with the San Diego developer community details to improve their application deployments.

Check out the abstract: Uptimes, scalability, clustering and performance monitoring are all important aspects of running a successful Java Web Application. This talk will focus on real world examples of features and advanced configurations deployed in the Resin Application Server to achieve success in the aforementioned aspects. Features and examples covered will reveal how users of the Resin Application Server are achieving 99.99% uptime with their enterprise deployments.

Details and presentation slides are online at


High Availability Part II - How does the Web Tier find the App Tier

Following up on Part I presented in January's newsletter, here is Part II. As always, we value your feedback so take a look and feel free to send your comments to  

​The Web Tier hosts the load balancer, which is configured in resin.xml with the following:


New Picture (1)

Note that resin:LoadBalance has a cluster parameter which will be used to find servers that serve that cluster (Tier). In the case above the cluster is called 'app'.

New Picture (2)

Web Tier resolves servers in the App Tier using configuration file must have a correct app_serversproperty which lists static App Tier servers. Once the Web Tier can find core servers of the App Tier it can resolve the dynamic servers using the cluster state that is communicated by the App Tier to Web Tier.

Deploying Web Applications

Web Applications should be deployed into App Tier using Resin deploy command. Once deployed into one of the three founding members of the cluster (the first three static servers defined in app_servers) application is replicated to the rest of the static and dynamic servers in the cluster. Deploying a foo.war application will look as so:

New Picture (3) 2

New Picture (4)

Configuring user name and password

Username and password are configured in with admin_user and admin_password properties.

For production deployment the password must be generated with Resin's password command as so:

New Picture (5)

Lines admin_user and admin_password can be copied into replacing the commented out admin_user and admin_password properties


For testing the password can be specified in plain text as so:

New Picture (6)

Cluster Security: Cluster Key

Cluster Key is used as a security token which allows participants in Resin Cluster Resin Servers to communicate. Cluster key should be specified in as so:

New Picture (7) 

Extended – New Years gift to optimize your configuration! 

Contact Caucho engineer Sean Wiley at or (858) 456-0300 to set up a complimentary review of your deployment, including learning about new Resin features and tips to optimize your configuration.

Download Resin                                                   Facebook: Caucho Technology  Resin Twitter page



Caucho Newsletter January 2017

​  Celebrating 19 years as the #1 Java app server!

Sun_with_Sunglasses_Transparent_Picture.png"Though it rarely happens, whenever one of our domains goes down, Resin's watchdog monitor restarts it automatically. We have been using Resin for five years and have achieved 99.99% up time. It is very reliable and fast. We host several websites and we particularly like the ability to run each domain in its own isolated java virtual machine”

- Peter BetBasoo, Assyrian International News Agency


Resin 4.0.50 will be available for download this week on With many new fixes in the latest release, the number of open requests is down to 15! We recommend upgrading to the latest version for the highest performance and stability.

Notable bug fixes in 4.0.50:

  • 0006027:  ref #6009: Shutdown doesn't appear to give requests time to finish
  • 0006025: add ignore-lock
  • 0006023: NPE: tld discovery
  • 0006022: command jmx-list -operations NPE
  • 0005990: IndexOutOfRangeException in Caucho.IIS.LoadBalancer.OpenServer
  • 0005948: apr_pool_cleanup_register(config->web_pool, s, cse_cleanup_, NULL) at modules/c/src/common/stream.c:1848 cause segfault
  • 0006021: JSTL Custom tag upper to lowercase
  • 0006002: add custom global error page for 503 service unavailable
  • 0005918: resin crashes on server shutdown on windows with openssl
  • 0005916: OPENSSL: SIGSEGV
  • 0006017: db pool issues when full
  • 0006020: defaults with persistent sessions on
  • 0005969: forward in include with context /foo
  • 0006008: resin:Forward at host level does not forward if @regexp matching context exists
  • 0006015: Allow server id be muted on error pages
  • 0006014: proxy-cache not showing updated files
  • 0005957: Deployment of war file causes Java to use 100% CPU and Resin to crash
  • 0005989: Resin pauses for 30 or more seconds during startup performing some git operations

For bug fixes, email us at or submit bugs directly at

Resin High Availability – easy default setup!

We want to make sure you are getting the best out of your Resin deployment. Through best practices gathered from emails, phone calls, and on-site visits, we continue to craft the default setup of Resin as a High Availability setup. To this end, we have put together a two-part overview that describes this setup.


The purpose of this overview is to familiarize new users with the architecture and configuration of Resin, and cement what long-time users may already know. As always, we value your feedback so take a look and feel free to send your comments to

Overview – Part I

Running a web application in high availability configuration requires a Resin Cluster. Resin cluster is a feature of Resin Pro which provides load distribution and session and cache replication.


In a minimal configuration with two application servers load can be split in two, with each server serving 50% of requests. In such a cluster consisting of two servers, sessions can be maintained in-memory or can be replicated between the two servers with each server has a copy of a every live session. This determination is dependent upon the session_store property in the file which defaults to false.


A suggested Resin High Availability cluster with failover support should have three or more servers. Such configuration ensures that sessions and distributed cache data are triplicated providing extra redundancy for session data.


The core three servers of the cluster should be configured as static servers in file. These three servers will construct the cluster core with each storing a full copy of all live sessions and distributed cache data.


Additionally a Load Balancer is required to balance load between cluster peers. Resin Pro provides Load Balancing capability as one of the core features of its Web Tier. If a hardware load balancer is used instead, it should be capable of supporting sticky sessions i.e. be capable of forwarding all requests from one client to the same Resin server. Sticky sessions help make the most efficient use of Resin cluster as each request is forwarded to the server where corresponding session was originated.

Configuration Files Overview

Default installation using:

1.  ./configure

2.  make

3.  sudo make install

will install Resin configuration files in the in /etc/resin directory

Resin Properties File

Named the file configures values for Resin Pro standalone and Resin Pro cluster. Values from are imported into resin.xml and cluster-default.xml

Resin Configuration File

Named resin.xml the file provides configuration for application and web (load balancer) clusters. File resin.xml imports values from

Resin Default Configuration Files

Resin extracts default configuration into cluster-default.xml, app-default.xml files. Default configuration is imported into resin.xml and should rarely be changed.

Default Cluster Configuration

By default clusters for application and Web Tiers are defined in resin.xml. Application tier is used for hosting web applications while Web Tier is used for load balancing. Typically, requirements for Web Tier may not be as high as they are for App Tier which makes using fewer Web Tier servers with more servers in the App Tier possible.

Web Tier servers provide load balancing and web content caching, reducing load on the servers in App Tier.

Configuring App Tier Cluster in

Resin.xml exports server configuration for app and web clusters into

Servers for App and Web tiers are mapped to app_servers and web_servers properties respectively.

Excerpt below shows how to configure three servers in the App Tier cluster; let the App Tier ips range be between and .19

Dynamic Servers

Both App Tier and Web Tier clusters support dynamic servers. Dynamic servers can be taken in and out of rotation on an as needed basis.

Enabling dynamic servers requires setting the following property in


Starting Servers in the App Tier

Servers defined statically in needs to start first. They will form the core of the cluster. Since the first three static servers compose the cluster core, cluster will operate normally as long as at least one of those servers is operational.

Starting the servers is achieved with bin/resinctl start –server app-33443 command.
​The 33443 parameter comes from the position of the server in app_servers (or web_servers )property.
For example server should be started with command:


Starting Dynamic servers in the App Tier

After static servers are started dynamic servers can join the cluster. Let the dynamic servers ip range start with and start two dynamic servers:
Note, that the command requires specifying the ip and port to which to bind the new dynamic server. Note also, that specifying cluster name is required as well.

The cluster name maps to servers in the cluster using cluster servers property defined in All servers in the cluster should be using identical configuration i.e. they should all share the same resin.xml and file, along with cluster-default.xml and app- default.xml if these files were changed.


Configuring Web Tier Cluster

Web Tier cluster exports its server configuration into web_servers property. Configuring the Web Tier servers is identical to configuring the App Tier's. Both tier clusters support adding dynamic servers.

Let the Web Tier have ips range start with

 Jan_NL_PIC F 

Web Tier servers can be started independently of App Tier but the Web Application will start being served only after servers of the App Tier become operational.

Stay tuned for Part II in the next Caucho newsletter!

Resin Tip – Secure Virtual hosts Redirect
Did you know that you can issue secure redirects in Resin at the host level? This setup is advantageous for users who might use a load balancer listening on their secure port to redirect traffic to Resin. By having the response from Resin secure, you can avoid a “double redirect” for your traffic.
There are two ways to configure the host for the redirect.
1. Add a <host-name> to the <host>.
<host id="" host-name="">
The redirect will use the host-name when filling in the redirect. That assumes you've got a single fixed virtual host, of course.
2. Add a secure="true" to the <web-app>.
<web-app secure="true">
That secure="true" will tell Resin to assume the real connection is secure even though Resin itself isn't using an SSL connection. So redirects will use “https:” instead of “http:”.

New Years gift to optimize your configuration!
Contact Caucho engineer Sean Wiley at or (858) 456-0300 to set up a complimentary review of your deployment, including learning about new Resin features and tips to optimize your configuration.

Download Resin                                                   Facebook: Caucho Technology  Resin Twitter page



Newsletter September 2016

Resin application server - Java EE 6 Web Profile Certified

Baratine News

Introducing Baratine 1.0 – introducing the first fully reactive programming framework!

Baratine features include:

  • Websockets
  • Journaling
  • Automatice batching
  • Child services
  • Session services
  • Worker services
  • Templates and views
  • Publish/subscribe
  • Timers
  • Flow control support
  • Jackson JSON support
  • Zero dependencies
  • Kraken, an embedded, fully reactive database

Top 3 reasons to use Baratine!

  1. Reactive Programming - Asynchronous request processing can improve response times and lower resource consumption. Combining this with the ability to operate continuously on data solves many of the issues that plague multi-threaded and multi-tier programming.

  2. No database or concurrency bottlenecks – Most applications can operate with their data in-memory and persist state when needed. Baratine makes this possible as well as transparent to the developer as requests no longer need to touch a bottleneck database for every read & update.

  3. Agile development - One of the biggest hurdles for releasing into production is the unintended consequiences (i.e. resource consumption & dependencies) of a new service. However, if the service is a standalone .jar communicating with your app via REST or WebSocket, you can release new features to production with no potential impact to current application performance.

White Paper Preview

Abstract: Asynchronous and non-blocking execution is a highly coveted attribute of high volume web services. Server side web services strive to make contractual agreements upon interface based APIs to other services, assuming their environments to be highly-available, recoverable, & loosely-coupled. However these attributes are often in direct disagreement with an APIs implementation given: (1) the underlying multi-threaded libraries an API must rely upon and (2) the outside data source whose assets must be operated upon before an API can complete. This hindrance often results in contractual agreements across services tying down & blocking the multithreaded resources of a given architecture. This bottleneck is only half solved by frameworks where asynchronous request processing is paired with either NoSQL or SQL databases whose data access must block an incoming thread in order to make durable mutations on an asset. Techniques such as caching & sharding in-memory data structures alleviate the bottleneck for modifications on data at the cost of added complexity; exposing a view of the data that cannot be atomically mutated, results in complex and eventually consistent architectures.

In this paper we introduce Baratine… 
Continue reading the entire Baratine Technical White Paper here!

Check out the Baratine introduction page:
Baratine 5 min Overview Introduction

Why is Baratine a game changer?

Reactive processing meets reactive data.

Working with data is the critical path of every application. Baratine guarantees only a single service owning thread will mutate a service's data. This unique threading & data model does three things:

  1. Allows data to be operated on continuously
  2. Eliminates database bottlenecks
  3. Eliminates multi-threaded concurrency concerns

Baratine's internals guarantee every service to be highly available, recoverable, and operate within an isolated thread context.

Encapsulation boundary_Aug2016

Clean & understandable asynchronous REST services are the perfect fit for Baratine's model. Services are fast, as in millions of operations per second per instance fast, clients can be in any programming language, and applications operate entirely in-memory.

However, Baratine is much more than just a simple async REST framework. What has been described by SOA for years and recently rebranded as Microservices is for the first time achievable with Baratine in a 5 MB .jar. Baratine is designed for high performance, scalability, security, and stability – something that Java EE and Spring cannot deliver.

Baratine eliminates the hassles created by multithreaded environments including writing lines of complex concurrency code, debugging database bottlenecks and ensuring applications meet the best known industry standards.

Check out the following examples of how Baratine can immediately help your infrastructure:

Resin News

Resin 4.0 Tip – Max thread count

Every application is different in terms of threads used for answering requests. Resin ships with a default thread max count of 256, which is appropriate for many applications, but may be limiting how fast your application is running.
If you suspect this setting is impeding performance, first turn on finer logging. Then increase the max thread count in your Resin configuration file as follows:
While this isn’t guaranteed to resolve every performance issue, having more workers answering requests in your application can significantly increase the overall performance. Who knows, you may find the actual bottleneck in your application (a database or cache perhaps? ;)  

Resin 4.0.49

The next release will be Resin version 4.0.49 and is scheduled for September. Contact us at if you’d like to receive an automated alert for this release. 

Helpful Information 

Arian Crockcoft's full presentation Microservices: State of the Union can be viewed at:
You'll notice he details a plethora of stacks one must combine in order to truly have a MicroService. We recommend using Baratine plus the likes of Docker, a build tool, and a security framework to get a leg up on the competition and outpace your rivals!


Copyright (c) 1998-2016 Caucho Technology, Inc. All rights reserved.
Caucho®, resin®, quercus® and baratineTM are registered trademarks of Caucho Technology, Inc.



Presentations & Links



Baratine Overview

GitHub examples

Baratine Download


  Resin 4

Follow Us!

Facebook: Caucho Technology
Resin Twitter page
Caucho Blog


Contact Us
(858) 456-0300 

Caucho Newsletter – December 2015

Resin application server - Java EE 6 Web Profile Certified

Happy Holidays! We have lots of updates for you. Here's a snapshot:
  • Resin 4.0.47 release
  • Baratine tutorials
  • Speak with a Caucho Engineer!
  • Resin tip of the day
Resin News

Resin 4.0.47 on

The latest release of Resin v4.0.47 is now available for download. As with previous 4.0 releases, the upgrade process is as simple as stopping Resin, saving your configuration, installing the latest version, and copying over your config.

Many of our clients who have upgraded to this latest version report an increase in performance of their clustered applications.

Check out the following enhancements in 4.0.47:
JDK 6 compatibility

Distributed session database synchronization issues, specifically: 

  • session: fixes related to Java deserialization (#5947i)
  • distcache: locking overhead reduced (#5962)
  • distcache: update remove query and locking (#5952)
  • session: fixes related to session removal/timeout (#5952)
  • compile: jdk5 compile issues (#6940)
  • cache/mmap: jdk6 compatibility (#5959, #5960i)
The latest releases of Resin continue to improve performance and reliability as we work hard to fix any bugs that are reported. For this reason, we always recommend users update their Resin installation and take advantage of these improvements.

Baratine News

Baratine Patterns Tutorial

The latest version 1.0.3 is available at As more users implement and prototype services, we are seeing a common set of questions arise around functionality. Many of these questions relate to the use of Baratine, such as “What JSRs are supported by the Baratine Framework?”  This is actually a basic question in terms of functionality for Baratine. In short, Baratine does not support any of the JSRs specifically. Instead, Baratine supports the use of Java 8 and many programming patterns ( that can be used to build services. We believe that as it currently stands a large majority, upwards of 90%, of the web services developers are looking to build can be created with these patterns and the Baratine framework. 

What’s more, rather than coding to specific JSRs, Baratine allows you to code directly to Java 8. This means code is more standard, easier to read, and you’ll automatically enjoy the performance and scalability aspects of Baratine. While there is coding required that is specific to the Baratine framework, we have restricted it to Service level Annotations ( These annotations allow developers to quickly and succinctly manage the lifecycle event of a service, similar to how annotations can be used to modify the lifecycle of a servlet.

If you know how to code in Java 8, then you are capable of building fully distributed web services with the ability to speak to any language and perform millions of operations per second per instance. Of course, this is made possible by the underlying Baratine framework which is complex in its coding, but exposes a POJO API that is naturally familiar to many developers.

Currently we are providing 10-15 minute tutorials ( that can be used to implement portions of an application or service. Here is the list: 

  • Hello World - How to deploy a Baratine Service and create a client to call into it
  • Single-Page Session - A session service used by a single-page application for user login state. Each user sessions creates a new session service instance
  • Singleton Resource Service - A service with a single resource, used to create new services from existing modules or from scratch
  • Queue with Application API - A user of a queue service submits a request and continues processing without waiting for a result
  • Local Microservice - Wrapping an existing module into a local microservice, similar to external creates encapsulated clean boundaries
  • Microservice - A microservice service is useful to convert an existing multi-threaded, blocking module into a loosely coupled service
  • Protocol for a Module - gives an existing module a HTTP protocol interface that supports HTTP request-response & WebSocket async protocol
  • In-Memory with External Database - An in-memory service layer that encapsulates a database better than a traditional passive cache
  • In-Memory Service with Internal Database - An in-memory service layer that persists data internally rather than an external database
  • Child Services - Build a REST-like Service with multiple child instances, each instance responsible for its own data
  • Setting up a Cluster - how to build a sharded service and deploy it to a cluster
  • Publish/Subscribe Stream - how to build a publish/subscribe service for Java and JavaScript clients
  • Publish/Subscribe Events - how to use publish/subscribe events in your services
  • Data Access Service - how to use Hibernate with Baratine
  • Singleton List Service - A single instance list service that maintains its own data
  • Multiple List Service - A multiple instance list service each independently maintaining their own data
  • REST Service - How to create a REST interface for a service
  • Facade Service - A facade service that allows you to expose an external API to a service, separate than the internal API

Are we missing a pattern? Let us know and we will implement it! :)

Helpful Information 


Have Questions Around Setting Up Clustering / HA?

Our Sales and Engineering teams are available to schedule calls with you to discuss Resin and Baratine as they apply to your specific environment. This benefit is included with your license and is a great way to learn about underlying models, features, performance and best practices that could be valuable to your development efforts and deployments.

Send an email to to schedule a call or contact us directly at 858-456-0300! Alternatively, if you are planning on being in the San Diego area, drop us a line and come by our offices to meet us in person!

Resin Tip

One of the most useful tools Resin provides for debugging is its logger. Resin has the ability to log any instance of a class and provide a detailed report of method invocation leading into and out of a class. Because of this, the log is usually the first place to look when something has gone awry with an application. By adding a simple one line logger to your resin.xml, you can enable the level of detail our engineers use to sort through various bugs. The following example details how quickly this can be done:

  1. Choose the name of the class or package you wish to log​.
    • Resin will log every class under a package name, i.e. logs
  2. Choose the level of detail you wish to have logged.
  3. Add the logger to your resin.xml and restart your application
  4. Resin will output log files to /var/log/jvm-*app-server*.log

 (in resin.xml)
//Log HTTP-related debugging
<logger name="com.caucho.http”.server level=“finer”/>
//Log every class that matches
<logger name="” level=“finer”/>
Alternatively, you can provide logging in a specific class as follows:
import java.util.logging.Logger;
import java.util.logging.Level;
public class Foo {
  private static final Logger log
    = Logger.getLogger(Foo.class.getName());
  void doFoo(String bar)
    // check for log level if your logging call does anything more
    // than pass parameters
    if (log.isLoggable(Level.FINER))
        log.finer(this + "doFoo(" + bar + ")");
    try {
    } catch (ExpectedException ex) {
      log.log(Level.FINEST, "expected exception", ex);


Copyright (c) 1998-2015 Caucho Technology, Inc. All rights reserved.
Caucho®, resin®, quercus® and baratine
TM are registered trademarks of Caucho Technology, Inc.

 Presentations   & Links

  Resin 4


Baratine Overview

Follow Us!

Facebook: Caucho Technology
Resin Twitter page
Caucho Blog


Contact Us
(858) 456-0300    


Caucho Newsletter – April 2016

Resin application server - Java EE 6 Web Profile Certified

Greetings! We have lots of updates for you. Here's a snapshot:
  • Baratine – bringing you the 4-day work week!
  • JSON messaging service capable of 5 million messages/second in 15 lines of code
  • TechEmpower benchmarks
  • Resin 4.0 upgrade success story
  • Resin 4.0 improvements
  • Resin tips
  • Technical paper: Scalability! But at what COST?
Baratine News


The 4-day work week is closer than you think   8-)

Caucho is making the 4-day work week a reality. OK, while we can’t guarantee your boss will let you take Fridays off, we can say that major breakthroughs in Baratine are just around the corner and should free up a lot of your time!

Consider your typical LAMP stack (Linux, Apache, MySQL & PHP). Not too long ago these technology stacks were extremely common building blocks in application development. Buidling out a proof of concept was familiar to developers and numerous examples and explanations can be found online. But how do they handle availability, scalability, performance and concurrency? These factors are generally figured out later as improvements to the system. All this work means added complexity and overhead costs.

Baratine is a game changer. It ensures concurrent access to data with no thread management code needed! Baratine persists data to disk without requiring a data schema. Scalability, partitioning, dependency management, performance are all at the forefront of Baratine development. This means you're exposed to an environment that avoids the pitfalls of previous technologies and you'll be done building in no time.

Caucho's experience as one of the first implementers of Servlet and Cloud technology allows us to build such a powerful solution. Resin's success in particular has also allowed us to GPL Baratine as we look to push the next breed of high performing web applications into the world.

What does this mean for you as a developer? 

Happy hour just got happier :-) In short, Baratine is giving you a cheaper (free) and higher performing technology stack that fits more use cases while using less resources than a traditional LAMP stack. We're excited to see where this technology takes your application.

JSON WebSocket Messaging in Baratine

Quick! You need to implement a thread-safe streaming pub/sub (over Websocket) capable of millions of messages per second, isolated as its own service and integrate it with your current application. Oh and it needs to be done yesterday! How fast can you implement this?
If you use Baratine, the answer is 5 minutes and ~13 lines of Java code!
This is the promise of Baratine, whether you are building single JSON processing pub/sub services or fully fledged auctions (, Baratine has been engineered from the thread and data level up to ensure your application automatically fits reactive manifesto (
Take a look at the Java code below. In three files we are able to create a session service that adheres to our requirements:
(Note: we chose to send the current Date at time of request as our message)
public class fooService {
               public void Receive(Result<String> r) {
 Date date = newDate();
public class client implements ServiceWebSocket<String, String>{
                fooService fs;
                public void open(WebSocket<String> ws) {
                           fs.Receive((x,e) -> {
                public static void main(String[] args){
<script type="text/javascript">
var connection = new WebSocket("ws://localhost:8080/msg");
connection.onmessage = function(e) {
Looking at this code, you might be wondering if Baratine a messaging platform. The answer is no, but it can be used as such. It’s 5mb in package size and since we thought all meaningful applications will need some sort of communication to link services, stream updates, etc., we’ve exposed an API for exactly this purpose.
While there are companies out there that will charge you by the message for similar functionality, Baratine is GPL & free to use. We took this example a step further in our documentation and linked it to a RabbitMQ broker (giving you the ability to do big data processing on your existing messages). Take a look at our tutorials and get started with Baratine today! 

TechEmpower Benchmarks

TechEmpower has been running benchmarks for quite some time now, attempting to measure and compare the performance of web frameworks. The term “framework” is used loosely to include platforms and micro-frameworks. Recently, we were able to have Baratine accepted into its next round of benchmark testing ( While benchmarks don’t give an absolute in terms of which framework will be the best for your specific application, it does let you know where a framework measures up for common use cases. If a framework is in the bottom 10% for common use cases, why would you even consider it? If a framework is in the top 10%, it’s worthwhile to be aware of it in case it fits a use case for your business.
In any case, look for Baratine to put up some quite impressive numbers in the field. Interestingly enough, TechEmpower uses our Resin Application Server for the servlet model for the following reason:

Resin is a Java application server. The GPL version that we used for our tests is a relatively lightweight Servlet container. We tested on Tomcat as well but ultimately dropped Tomcat from our tests because Resin was slightly faster across all Servlet-based frameworks.
Note: If they used Resin Pro, the numbers would be even higher :-)  


Resin News

Resin 4.0 Upgrade succuess story

We always recommend upgrading to the latest version of Resin 4.0. Here’s an example of why:
“I also wanted to give you some feedback about the triad. In a nutshell, it's been working great and we are glad we moved to a cluster architecture and upgraded to Resin 4.0.47. We normally use about 10% of each server's processing power so that gives us a lot of leeway and scalability for the future. So many thanks to the team for the advice and support!”
-Y.G. / (Company details removed for privacy)
 If you are running a version of Resin 4.0, the upgrade process simply means running three install commands and copying over your current configuration. For clients running earlier versions of Resin (3.1 or lower) we recommend first installing the latest version of 4.x and deploying your .war file to it. As always, we are available to discuss and provide guidance so that you can take advantage of the upgraded performance features. Contact us at or (858) 456-0300 when you’re ready to go!

Resin 4.0 improvements

The latest version of Resin is 4.0.48 and includes bug fixes related to database and session corruption. It can be downloaded at We continue to improve Resinwith bug fixes and feature requests ensuring it remains the best multithreaded Java Application Server in the world.
If you’ve noticed any odd behavior in your deployment, please do not hesitate to contact us directly or file a report on our bug site at:
Note: you'll need to register an account to log bugs

Resin tips

Looking to use Resin’s hot swap technique from within your IDE (no restarts on a redeploy of code)? If you deploy as a directory or deploy from your workspace, then this is possible!
Check for details.
Deployment options are in “Configure Server” section. Instead of selecting “use remote deployment”, you’ll want to choose either Deploy as a directory or Deploy from workspace.

This tip can cut down on restarts, similar to JRebel. 

Helpful Information 


Technical Paper – Scalability! But at what COST?

COST (Configuration that Outperforms a Single Thread) is a new metric for measuring big data platforms. The paper is quite revealing in both examining your programming model and cost to scale that system. It points out that scaling a system doesn’t guarantee the work will be done faster.
This paper dives into the reality of scalable multicore clusters and compares their performance to a single in-memory thread. Surprisingly, many configurations have a large COST, often hundreds of cores and still underperform one thread for all of their reported configurations.
You can find a copy of the paper here for your reading:
It begs the question, are single threaded models the models of the future? Take a look at and decide for yourself!


Copyright (c) 1998-2016 Caucho Technology, Inc. All rights reserved.
Caucho®, resin®, quercus® and baratine
TM are registered trademarks of Caucho Technology, Inc.

 Presentations   & Links

  Resin 4


Baratine Overview

Follow Us!

Facebook: Caucho Technology
Resin Twitter page
Caucho Blog


Contact Us
(858) 456-0300    


Caucho Newsletter – October 2015

Resin application server - Java EE 6 Web Profile Certified

Hi Caucho Followers! We're deep into the year and we have lots of updates for you. Here's a snapshot:
  • Baratine 0.10 Released - We're close!
  • Resin 4.0.45 on
  • Caucho Rodeo Trip – Texas in Fall!
  • On-site Training now available
  • Caucho Expands Reseller Network

Baratine News

Baratine 0.10 Released 

Asynchronous reactive applications (See are the future of web applications. However, the large base of developers building asynchronous distributed applications has not yet come to fruition. We believe that this is due to the sheer complexity needed to build and maintain these solutions. Toolkits and frameworks currently require very low level message handling and force developers into a programming model that is not natural to the object oriented style of Java.
Baratine is a platform for building a network of loosely-couple POJO microservices. In this way, Baratine can be thought of as a “high-level” abstraction for reactive programming. Within Baratine, the only requirement of developers is to implement the methods from the API they design. This is in stark contrast to models that enforce an “extends” statement in base level classes and opens up the understanding of an application from just a few expert engineers, to an entire team of engineers now able to create enterprise quality distributed applications.
Baratine is moving Java forward with the next stage of encapsulation. Currently we are updating our documentation to illustrate how many models can be implemented within Baratine. The list currently stands at: 

  1. Hello world
  2. Batching
  3. In-memory
  4. Sharded
  5. Id generation
  6. Multi-pod
  7. Pub-sub
  8. Workers/integration with legacy
  9. Map-reduce
  10. Store
  11. BFS
  12. Database bardb
  13. Mysql/mongodb
  14. Child services
  15. Compute
  16. Facade APIs
  17. Vertx integration

If you have any questions about Baratine and current use cases please reach out to us at:!forum/baratine-io or drop us a line at (Don’t worry Baratine is Open Source and free to use!)

Resin News

Resin 4.0.45 on

Along with working on the technology to fuel the next generation of web apps, we continue to improve our long-standing cloud platform in Resin. The lastest version of Resin, 4.0.45, is now available for download. It includes bug fixes and increases Resin's stronghold as the top tier web and application server. Please report any bugs you come acoress to If you’re looking to expedite a bug fix, a short demo reproducting the issue always helps us out.

One other item to note is that we will be back porting the new Resin 5 database into Resin 4. Our new model will provide even better stability when corruptions occur and should be out in 2-3 weeks. 

Notable bug fixes in the 4.0.45 release include: 

  • session: change shutdown state machine to allow getAttribute on invalidating session (#5919, rep by Shinomiya Nobuaki)\
  • build: remove LoadTimeWeaver (#5923, rep by M. Barker)
  • watchdog: change default -Xss to 1m (#5927, rep by anupmondal)
  • servlet: check for dual registration of ServletContextListener (#5893, rep by Matias Lagerwall)
  • jsp: share classloading of .tag files (#5914, rep by nfedorov)
  • dyn-server: on server restart, allow same address:port (#5903, rep by Tom Pohl)
  • dyn-server: added lock in resin-data to ensure multiple servers cannot use same data (#5902, rep by Tom Pohl)
  • ssl: allow OpenSSL ECC support for forward secrecy (#5906, rep by Nick Stephens)
  • db: add validation and restart for corrupted BTree index (#5912, rep by wesleywu)
  • build: allow for JDK 8 build (#5901, rep by dave)
  • health: removed perm gen checks (#5910)
  • ejb: ejbTimer.cancel() needs to remove timer from getTimers() (#5891, rep by bbik)
  • servlet: FileService character-encoding should exclude images (#5907, rep by Mathias Lagerwall)

On-site Training

Caucho Rodeo Trip

We will be in Texas in November visiting customers as well as providing on-site training. We have reached out to a number of our customers in the Dallas area, but if we have not heard from you, feel free to contact Sean Wiley to request a meeting or after work BBQ/drinks. 

On-site Training

Caucho’s Advanced Developer Training may now be scheduled as on-site training. We cover the following topics in order to get your development team up to speed utilizing the Best Resin Practices: 

  • Understand Resin architecture & configuration files
  • Deploy, support, & troubleshoot Java apps on Resin
  • Configure database connectivity for a multitude of data structures
  • Configuring dynamic servers to respond to web app traffic & mitigating DDoS attacks
  • Monitor & profile applications using the administration application
  • Secure Resin & Applications running on it
  • Embed Resin for reliable & dynamic OEM solutions
  • Implement application failover for horizontal scaling
  • Utilizing Resin as a private/public/hybrid massive cloud solution
  • Versioned deployment and graceful upgrades for zero downtime  

To schedule your on-site training, please contact Alexandra Garmon (

Reseller Program


Caucho Expands Reseller Network

Recently, we have seen much growth in our US and global reseller program.

If you would like to become a Caucho reseller, please contact Alexandra Garmon (  


Copyright (c) 1998-2015 Caucho Technology, Inc. All rights reserved.
Caucho®, resin®, quercus® and baratine
TM are registered trademarks of Caucho Technology, Inc.

 Presentations   & Links

  Resin 4


Baratine Overview

Follow Us!

Facebook: Caucho Technology
Resin Twitter page
Caucho Blog


Contact Us
(858) 456-0300    

Caucho Newsletter – May 2015

Resin application server - Java EE 6 Web Profile Certified

Greetings! Let's get you up to speed with what has been going on at Caucho!

Baratine News

Baratine 0.9 Release 

We pride ourselves on being able to identify and provide the latest implementation technology for web applications. Considering the sheer number of devices that can now access web apps, the landscape for building these applications is constantly evolving. In order to respond to the growing number of connections, more emphasis is being placed on the asynchronous ability of new apps and this is also a major focus for us.
Currently we are working on what we see as the de facto standard for building fully asynchronous, scalable, and independent SOA services in Baratine. We see this technology as the dominant driver of what new applications will need and much of our time has been devoted to building this platform. The upcoming Baratine 0.9 release moves us very close to production ready. You can find more news about Baratine on or below in the Baratine section.


Baratine Projects

Two early projects we are working on as proof of concepts for the Baratine platform are:
• Baratine + Lucene – For indexing and searching files stored in the Baratine Distributed File System
• Bartwis – A Baratine clone of a Twitter-toy clone written in PHP & Redis
These two projects are close to reaching their final stage and can be explored currently on the baratine github ( We are very excited to see how the community will expand on these applications within the Baratine environment.
The Lucene + Baratine plugin illustrates Baratine’s ability to take a previously written library, that was designed as a fully blocking and locking service, and with just a few lines of Baratine coding, transform it into a fully asynchronous service.
The Bartwis project highlights Baratine’s flexibility and performance. We have fully implemented Redis in Baratine to show the magnitude of Baratine’s capabilities. In this example, Baratine transforms simple POJO classes into fully redundant services under the hood, so users are able to use this application to achieve Redis-like functionality with no restrictions on what data structures are supported. In fact, if developers found a particular data structure more efficient than what is available in Redis today, they could simply implement that structure as a Baratine service and receive the microservice and asynchronous capabilities of Baratine automatically.
Of course this is just the beginning, head over to our github and take a look at the projects for yourself today!

Resin News

Along with working on the technology to fuel the next generation of web apps, we have continued to improve our long-standing cloud platform in Resin. We are encouraged to see new deployments in the areas of mobile and desktop alike benefiting from Resin’s stable environment as customer’s utilize it in hosted environments as well as on premise at their own sites. We have continued to fix bug requests (see below). If you’re seeing odd behavior in your application, please file a bug at

• jsee: self signed cert should support Firefox and Chrome default cipher-suites(#5884)
• jsee: self signed cert should check expire (#5885)
• class-loader: excessive reread of jar certificates (#5850, rep by konfetov)
• log: add sanity check for log rollover (#5845, rep by Keith F.)
• deploy (git): use utf-8 to store path names (#5874, rep by alpor9)
• websocket: setTimeout was being overridden by Port keepaliveTimeout (#5841, rep by A. Durairaju)
• jni: on windows, skip JNI for File metadata like length (#5865, rep by Mathias Lagerwall)
• db: isNull issues with left join (#5853, rep by Thomas Rogan)
• websocket: check for socket close on startTextMessage (#5837, rep by samadams)
• log: when log rollover fails, log to stderr (#5855, rep by Rock)
• filter: allow private instantiation (#5839, rep by V. Selvaggio)
• rewrite: added SetRequestCharacterEncoding (#5862, rep by Yoon)
• health: change health check timeout to critical instead of fatal to allow for development sleep (#5867)
• alarm: timing issue with warnings and alarm extraction (#4854, rep by Shinomiya Nobuaki)
• session: orphan deletion throttling needs faster retry time (rep by Thomas Rogan)
• mod_caucho: slow PUT/POST uploads with Apache 2.4 (#5846, rep by Stegard)

Resin v3 to v4 Migration

Earlier this year we held an Advanced Resin 4 training session going over the many aspects of Resin that can be utilized for high availability, resilient recovery, and post mortem analysis. Quite a few deployments are still utilizing Resin 3. While Resin 3 is a great platform, we’d like to encourage our users to move to the better performing Resin 4 platform.
Resin 4 has significant features including cloud support, application health visibility, and unprecedented high availability.
Understandably, there might be current technologies in your application stack that are preventing you from upgrading. Resin 3 support will be sunset in January 2016, we’d like to offer an upgrade path for our current users. If you are currently running Resin 3 and would like a review of your application stack to gauge what would be necessary in an upgrade, contact  Our developers will work with you to mitigate any potential conflicts with your current stack and also help layout similar configurations to get you up and running on Resin v.4 in no time!

Resin 5 is currently in alpha as we continue to implement the Servlet 3.1 (4.0 when available), HTTP 2.0, and WebSocket specs.

Resin 4 Tip

REST config for Nagios

Looking to setup remote monitoring software with your Resin installation?
The /resin-admin directory, contains an index page with a “rest” example toward the bottom. You can customize this rest page to get the information about your application that you are interested in.
Equivalently, by browsing to the /php/admin/WEB-INF/php/*.rest pages, you can get an example of how JMX values can be extracted from Resin in simple PHP pages. These can then return the result in a format for one of the standard monitoring software plugins such as Nagios.


Copyright (c) 1998-2015 Caucho Technology, Inc. All rights reserved.
Caucho®, resin®, quercus® and baratine
TM are registered trademarks of Caucho Technology, Inc.

Caucho Newsletter – January 2015

Resin application server - Java EE 6 Web Profile Certified

January 2015 News

Resin 4.0.43

Greetings! Hope your 2015 is off to a great start. We started the year ramping up development for Resin and Baratine. 

Customer Highlight

Congratulations to TouchCommerce for earning a “Digital Power Player” honor by Website Magazine and moving the web forward! See the cover story of the January print issue (p.28)

“As our business expands, Resin Pro provides us with the enterprise class high-availability clustering needed for our RightTouch platform. We chose Resin because it provides great Java monitoring, administration and performance needed to operate a large scale web application”

Soma Bulusu, CIO, TouchCommerce

Resin News

Resin 4

We closed out some lingering bugs and included their fixes in the latest release version 4.0.42. If you are currently running an older version of Resin 4, we recommend upgrading to the latest version as a simple uninstall and reinstall without changing any config.  Bug fixes include:

* Creating DB pools dynamically

* Faster and more full-featured RPM upgrades for simple deployments

* Documenting Resin Anomaly Analyzer for Health Warnings

* Ordering ServletContainerInitializers according to the web

* Fragment order and more!

Resin 3 users migrating to Resin 4 saw an increase in performance because they were able to replicate portions of their applications, reduce load during peak hours, use the latest OpenSSL security bug fixes and more accurately monitor resource consumption.

Please visit the Resin mantis page for a full change log description at:

Early release testing is something we provide to allow our end users to have direct, fast, and verified input into our development. If this is something you would like to be involved in, please drop us a line at

Look for Resin 4.0.42 on our website,

Resin 4 – Documentation Revival!

Based on customer feedback, we will be providing greater detail for some of the most popular Resin installations and setups. Be on the look out for new documentation covering shorthanded syntax, high-availability setups, and details on how to use our health features.

Topics will include:

* Using Resin’s distributed Jcache for performance

* Building a customer RPM for mass rollout

* Using Resin PDF reports for debugging

* Security in Resin

We will be sampling the direct support request setups we have received.

For more insight into a topic, please submit your question by going to:

Resin 5 alpha!

Resin 5 is currently available for download and includes implementation of JSR 356 Websocket, as well as core Servlet 3.0 specifications JSP, EL and CDI.

Development of HTTP Services is focused Load Balance/Proxy using HTTP/2.0, HTTP Cache, Session distribution and persistence and URL rewriting and dispatch

Read more and download at:


Resin Developer Training in San Diego, Feb 23 & 24

Only 5 spaces left!

Join Sean Wiley and learn how some of the largest sites on the web are using Resin for security, performance, software load balancing and caching. Utilize the latest features of Resin Pro for your physical and virtual deployments, including easy techniques for using AWS.

Our training also features a  some of the largest sites on the web are ustime with the Caucho team and speak about your deployment. It includes gourmet coffee, catered lunches and a reception featuring San Diego’s finest culinary delights, microbrews and wines

Topics Include:

* Understand Resin architecture & configuration files 

* Deploy, support, & troubleshoot Java apps on Resin 

* Configure database connectivity for a multitude of data structures

* Configuring dynamic servers to respond to web app traffic & mitigating DDoS attacks 

* Monitor & profile applications using the administration application 

* Secure Resin & Applications running on it 

* Embed Resin for reliable & dynamic OEM solutions 

* Implement application failover for horizontal scaling 

* Utilizing Resin as a private/public/hybrid massive cloud solution 

* Versioned deployment and graceful upgrades for zero downtime  

Questions & Registration Info: Contact Alexandra Garmon

Office: (858) 456-0300 |

Ask us for a discount rate for groups of 5 or more!!

Date: Feb 23-24, 2015 (Monday & Tuesday)

Time: 9:30am to 4:30pm PST

Location: 4455 Morena Blvd., Suite 210, San Diego CA 92117 (near airport, hotels & freeways)

Instructor: Caucho Engineer, Sean Wiley

Tuition: $2,200, Register by 2/10/2015 and save $250/enrollee!


San Diego Java Users Group

Our last meeting of the year was a great presentation by Brian Sletten entitled Doing REST “Right”. Brian has been speaking on REST for the past 9 years and his presentation focused on how a properly decoupled REST system should function and the benefits it would withhold. 

After two years of hosting the San Diego Java Users Group we are passing the torch to ResMed for the new location of SDJUG meetings. 

More info at:

Baratine News

Baratine: 0.8.7 In Progress!

With technologies such as Docker, Mesos, Finagle, and etc., becoming more prevalent in enterprise architectures, Microservices have become more than just another buzz word. Baratine’s premise to lower what is needed in terms of lines of code as well as complexity will undoubtedly push us towards a truly agile and reactive age of infrastructure. Why deal with complex multi-tiered caching when you can have a fully redundant, writable file system, capable of speaking any protocol over REST, Websocket, or HTTP and is capable of sharding and sharing its data to multiple clients asynchronously? Of course, that is just a slice of what Baratine is capable of doing and we are excited to continue pushing forward on this project.

The latest Baratine release will feature a simplified deployment structure allowing for multiple jar deployments to a single pod as well as simplified configuration. Head over to to download and get started with it today!

Also, we are currently answering questions on our Google Groups forum at:!forum/baratine-io

Copyright (c) 1998-2015 Caucho Technology, Inc. All rights reserved.

Caucho®, resin®, quercus® and baratineTM are registered trademarks of Caucho Technology, Inc.


Caucho Newsletter – May 2014

Resin application server - Java EE 6 Web Profile Certified

May 2014 News

Resin 4.0.40
Happy May! It has been a busy past few months for the Caucho team with exciting new developments. We are on the brink of a cool new open source project release as well as developing Resin 5 (more below). Check out our updated web site that features a better interactive look and feel. If you’ve had a chance to play around on the site, let us know how we did!

The current release is the most stable release of Resin to date and is a maintenance release. We fixed the following bugs:
-Resin Administration cross site scripting
-Resin remote deployment
-Quercus: We continue to improve the stability of Quercus as it is a useful tool for those looking to combine PHP and Java

Resin 4.0.40 is now available for download at

Resin 5 – Faster and Lightweight

Resin 5 is currently under development with a roadmap release of early Q3 2014. With this version we are focusing in on the performance components of Resin including websocket optimizations, our asynchronous servlet implementation, incorporating HTTP 2.0, and Java EE spec updates. Resin’s new packaging will be inline with the anti-fragile and agile wave of technologies.

Resin 5 will feature an even smaller file size as we strip out our jms, ejb, jsf, jca, jcache, apache, and iis implementations. The reason behind this is twofold: it allows us to focus on the architecture vital to performance and reliability and also reduces the possibility of bugs within our codebase. Of course, Resin is pluggable and will still support these technologies (jms, ejb, jsf, jcache) if you need them.

Core Resin 5 development is focused around:

-Clustering revamp
-Deploying revamp
-Configuration revamp
-CDI, EL, other EE specs
-Proxy load balancer
-Http cache
-DB revamp

 …and more!

Looking to update your current or legacy architecture to a simple and more efficient model?

Resin 4 offers many advanced features and exceptional performance in a lightweight container. Users migrating from WebLogic or Websphere to Resin will initially find the workflow associated with development and administration differs greatly between the two products. However Resin users tend to find configuration and development to be very natural and efficient, especially compared with other application servers.
Architecture migration is slow and cumbersome. However, it is a necessary for highly competitive companies that want the ability to utilize the latest technologies within their product. Whether you are looking to cut back the expensive costs of licensing or want to begin moving your application to a more resource conscious environment, we have a detailed wiki guide that will get you started:
Who Should Migrate:

Current Application Status Action Next steps
Application developed on Resin or Tomcat, deployed to WLS or WAS Migrate to Resin Resin is used in production for highly demanding and heavy load sites. Migrating production deployment to Resin is fast and familiar to developers.
Application uses Servlets, JSPs, or frameworks like Spring, Struts, or Wicket Migrate to Resin Resin is known for its fast Servlet and JSP implementations that offer lightweight, low complexity, yet enterprise-ready stability and reliability
Next generation of the application will use JavaEE 6 Web Profile technologies like CDI or EJB 3.1 Lite Migrate to Resin Resin is a Java EE 6 Web Profile licensee and has high quality early access implementations of CDI (Resin CanDI) and EJB 3.1 Lite that are fully integrated into the application server.
Application uses clustered sessions for improved reliability Migrate to Resin Resin's Clustering implementation offers high reliability, easy configuration, and dynamic clustering for both internal and external cloud deployments
Application integrates or runs side-by-side with PHP applications Migrate to Resin with Quercus Resin include Quercus, Caucho Technology's reimplementation of PHP, written in Java. With Quercus, PHP applications can integrate and/or run side-by-side with Java application in the same container, often with vastly improved performance.
Application testing environment uses an embedded server such as Jetty or Tomcat Migrate to Resin Resin offers a sophisticated embedded test environment that allows not only HTTP request-style testing, but also unit testing for EJB and CDI components.

JDK 7 Certification

We are months away from passing Java 7 certification. Resin supports many of the new features in Java 7, including websocket.  Since Caucho was an early implementer of websocket, we are providing a code change for the final Java 7 TCK’s.

Development of Resin 4 has been finalized and we will continue to fix bugs. Our efforts are now focused on Resin 5 and our newest project Baratine, a GPL in-memory service platform.

Java Users Group

We had a packed house for our April Java Users Group as John Clingan from Oracle presented what’s new in Java 8. He covered topics including Lambdas, Functional Interfaces, Type Interfaces, Streams, Java Profiles, and more. He presented cool demos to show what these code implementations look like.
The May JUG was a lively “Hands-on workshop for Better Unit Testing” presented by Llewellyn Falco (in Google Glass). We all look at unit testing in a different light. 
Caucho engineers Nam Nguyen and Sean Wiley to present the June San Diego JUG
Baratine offers unprecedented support for building distributed in-memory resource services and is a culmination of over 16 years of industry experience all packed into a 7MB file size. By allowing your resources to own their own data within the same JVM, Baratine presents a truly object orientated approach to building resource services without developers needing to worry about cache coherency, database migration schema, and performance. Don’t miss out!
For more information:

New Community Support


Resin Google Group

Due to an influx of spam on our forums and improvements made surrounding Google groups, we have moved the community support for Resin to:!forum/caucho-resin
One common question seems to be surrounding the Resin Pro licensing. Resin Pro licensing is available on a yearly or enterprise basis. The optimized features within Resin Pro will function when a valid license is present. Upon expiration, Resin Pro automatically reverts to it’s GPL state. This means that to continue using and benefiting from the performance and administration that Resin Pro provides you will need to keep your license up to date.
If you have any questions about what we’re up to or are coming to San Diego in the future, feel free to contact us at or (858) 456-0300 and drop by office to say hello and talk code.


Copyright (c) 1998-2013 Caucho Technology, Inc. All rights reserved.
Caucho®, resin® and quercus® are registered trademarks of Caucho Technology, Inc.


Success Note

"After using almost every available application server on the market, Resin’s stability, reliability, and advanced load-balancing make it the obvious choice for us. We selected Resin because of the demands that our high-visibility web site puts on server performance."

-Brandon Cruz / CTO / GoHealth Insurance 

Caucho Resources

  Intro to Resin 4

Interview with Paul Cowan
Cloud-optimized Resin Java EE Web Profile Java application server

Interview with Reza Rahman
Resin 4, CDISource and Java EE 7 & 8

Resin Java EE Web Profile
A truly lightweight standards-based runtime that focuses on ease-of-use for web application development (whitepaper PDF)

Resin 4.0 for Cloud Computing
Easily scale web applications in a cloud environment (whitepaper PDF)

Resin RefCardz
The must have Resin cheat sheet for network administrators and developers (PDF)

CDI AOP Tutorial
Java Standard Method Interception Tutorial

Follow Us!

Facebook: Caucho Technology
Resin Twitter page
  Caucho Blog
Caucho Blog


Contact Us
(858) 456-0300

Caucho Newsletter – January 2014

Resin application server - Java EE 6 Web Profile Certified

January 2014 News

Resin 4.0.38
We hope everyone is off to a great beginning in 2014! With the start of the New Year we thought it would be beneficial to begin an in-depth review of Resin’s architectural stack. For Part 1, we will dive into the world’s fastest web server that, if you aren’t already, should be taking advantage of! Resin is meant for data-rich and intensive enterprise web applications. As such, the internal components are coded to provide the extra performance and insight needed to give your applications a true edge.
General feature updates and bug fixes in 4.0.38:

  • Resin Cluster – Dynamic server improvements to aid in the automatic restart after a triad server has been restarted
  • Resin Cache – Configuration added to maintain minimum thresholds in cloud environments
  • Resin Health – Thread pool analysis from PDF reports now available in new formatting

Visit for a complete list of bug fixes and improvements in this release.
Download Resin 4.0.38

Resin Essentials (Part 1) – Resin Web Server
Resin is engineered to work from end to end with specific thread optimizations made at each level of the architecture. Often is the case that applications will include components chosen by familiarity rather than performance. If your application includes an Apache Web Server, your architecture will handle 40-150% more load with fewer errors by utilizing Resin’s Web Server. If your application includes an NginX server, your architecture will handle 20%-25% more load with fewer errors by utilizing Resin’s Web Server.  In deployment you not only pay this fine in dollars spent on hardware and resources, but also on time managing multiple configuration files. Resin’s Web Server is yet another finely crafted component in an architecture that simply works.
Resin Web Server functionality:

  • Powerful and Easy to configure URL rewrite rules
  • Added security and functionality through Virtual Hosting
  • FastCGI so you can work with Python (Django), Ruby (RoR), native PHP, and more
  • Built-in HTTP Proxy Cache so you can speed dynamic pages to near-static speeds
  • Built-in mod_php like support via Quercus
  • Cluster aware load balancer that auto shares loads to new application server nodes
  • Security: Immune to buffer overflow attacks that plague other Web Severs (mostly Java with small, tight, fast JNI/C)  

Resin’s Web Server can make the difference in your application’s ability to seamlessly scale from one to millions of concurrent sessions. As an added benefit, the load balancing and clustering ensure that your application optimizes its resources redundantly across your stack.
Scott Ferguson, Chief Architect of Caucho said the following:
“For years Resin has not needed Apache httpd as a load balancer or to serve static HTML files and images. With Resin you get a complete web solution. Resin pieces are designed to work together, and designed to be fast and scalable. Performance is easy to demonstrate with our web tier, and it is the same type of performance you can expect throughout our product for session replication, proxy cache, object cache, and more. Using Resin means you value craftsmanship, and are a discerning, informed developer.”

San Diego Java User's Group – January 21

This months San Diego Java User’s Group focused on “Simple and Fun Functional Programming in Java” by Allan Schougaard. It was a very interactive JUG, with audience members debating different code segments and best practices (exactly the kind we want!). On the basis of maintainability, readability, and abstraction we’re sure participants left the meeting with some code refactoring of their own to do!  
Abstract: Functional programming is all the rage right now, and for good reason. It promises simpler and faster programs. Some of the holdbacks are that many people believe that it requires you to change programming language. Not so! In this talk I will show that you can use functional programming techniques and reap many benefits in the current incarnation of the Java language.
Check out the slide deck on the SDJUG’s site!
Please join us at the next JUG scheduled Feb 18, 2014 for a great night!
Visit the SDJUG website
Moving to the Cloud?
As cloud environments continue to mature, more companies are benefiting from migrating towards newer infrastructure. Flexibility, increased collaboration, and disaster recovery are among the top reasons fueling the movement. However, concerns about sensitive user data and having to rearchitect legacy apps mean in house systems will not be going away anytime soon. Whether a public, private, or hybrid environment is right for you, Resin is architected to work in all environments. For those wanting to port certain applications to the cloud, check out our cookbook on how to deploy Java apps on Amazon EC2:
Tip of the Month


Enabling Resin Web Administration

Since the resin-admin is just a web-app implemented with Quercus/PHP, enabling it is just adding an appropriate <web-app> tag.
To enable the /resin-admin, you'll need to create an admin user and password.

  1. Create an admin user following the prompt at /resin-admin.
  2. Copy the conf/admin-users.xml.generated to conf/admin-users.xml.
  3. Change the resin_admin_external to true if you need access from a non-local IP address.
  4. Browse /resin-admin with an HTML 5 browser. 

The steps are for security reasons. Copying the admin-users.xml verifies that you have access to the server. And the default resin_admin_external=false makes sure you're not exposing the /resin-admin to the internet.
A detailed walkthrough can be found here!

Quercus Corner

As the PHP adoption rate continues to grow, we continue to make improvements to Quercus.  The Agile movement has led to more client-side scripting and Quercus continues to bridge the gap to the server side Java components. Quercus highlights: 

  • Meets or exceeds the performance of the C PHP implementation with common PHP applications
  • Optimized compilation of PHP to Java
  • Single process model of Java reduces unnecessary switching overhead
  • Shared data allows for caching across multiple requests
  • Java implementation eliminates many traditional security problems such as buffer overflows
  • Input/output filtering for cross site-scripting and other attacks is simple with Java EE
  • Natural, high performance integration of Java libraries in PHP applications
  • Allows Java developers to use PHP as a front-end technology

Download Quercus Today!


Copyright (c) 1998-2013 Caucho Technology, Inc. All rights reserved.
Caucho®, resin® and quercus® are registered trademarks of Caucho Technology, Inc.


Success Note

"Here at IBRC, we use Resin 4 to maintain high availability and secure transmissions for our flagship SaaS product Open-Line Customer Experience Improvement Tool™.  We take full advantage of load balancing and SSL encryption to achieve our goals of making Open-Line always available and secure to all who use it."

- Stewart Morse

Caucho Resources

  Intro to Resin 4

Interview with Paul Cowan
Cloud-optimized Resin Java EE Web Profile Java application server

Interview with Reza Rahman
Resin 4, CDISource and Java EE 7 & 8

Resin Java EE Web Profile
A truly lightweight standards-based runtime that focuses on ease-of-use for web application development (whitepaper PDF)

Resin 4.0 for Cloud Computing
Easily scale web applications in a cloud environment (whitepaper PDF)

Resin RefCardz
The must have Resin cheat sheet for network administrators and developers (PDF)

CDI AOP Tutorial
Java Standard Method Interception Tutorial

Follow Us!

Facebook: Caucho Technology
Resin Twitter page
  Caucho Blog
Caucho Blog

Caucho Forum


Contact Us
(858) 456-0300