Usman Aziz is a technical lead at TunaCode, Inc., a startup that delivers GPU-accelerated computing solutions to time-critical application domains.

After a Clojure development sprint, the next step is to deploy the web application and make it useful for clients, or to conduct some testing. As with Java, the web applications written with Clojure are usually deployed as Web Servlets. The servlets interact with web clients using a request and response model managed by a servlet container. By design, the Clojure web applications support all of the capabilities and interfaces as Java counterparts, making it easier to deploy them on a Java application server with possible support of multi-tenancy. In practice, multiple applications developed using Clojure and Java can be deployed and made to interact on a single application server.

Continue reading →

A guest post by Salman Ul Haq, a techpreneur, co-founder and CEO of TunaCode, Inc.

Frequent and regular data backups are important in most environments, and though data backups are a standard procedure, there are multiple ways they can be achieved. When it comes to Big Data, the stakes get higher so the cost of failure is great. HBase is an open source distributed Big Data store with billions of rows and millions of columns that can be quickly deployed over commodity servers. Because of this, HBase makes an ideal candidate for your Big Data storage needs. In this post, we will examine the different ways you can back up data on a live HBase cluster.
Continue reading →

Camel is an integration framework that helps you build integration projects. It consists of a routing engine builder that provides the capability of building custom rules for routing. This allows you to decide upon the message sources and formats, to process these messages according to set rules, and then to dispatch these messages to their respective destinations. Camel allows you to set up data routing rules that are similar to business processes. Furthermore, Camel imposes no restrictions on data types or transfer protocols, allowing them to work with both standard and custom data types. The engine currently supports more than eighty data types or protocols, and the list is being constantly extended.

Camel includes enterprise integration patterns to solve most of your integration problems. Its domain specific language integrates with popular programming languages such as Java, Spring, and Scala. Additionally, Camel includes an automatic type converter, it has a lightweight core, and it provides a Test Kit to easily test Camel-based applications.
Continue reading →

Camel provides a powerful framework for enterprise application integration. Databases are a vital part of any enterprise application, and therefore it’s mandatory for any integration framework to offer first-class database support, which includes connecting with various data sources and accessing data. There are several ways you can achieve this in Camel, and in this post you will see how the JDBC component – one of the most commonly used components for database access in Camel – may be used.
Continue reading →

In a previous post, I introduced Storm, the distributed and fault-tolerant stream processing system for Big Data. This post covers some details about Storm clusters and then examines an actual Storm example.

In general, a Storm cluster is superficially similar to a Hadoop cluster. One key difference is that a MapReduce job eventually finishes, while a Storm job processes messages forever (or until the user kills it). Figure 1 illustrates the architecture of a Storm Cluster. In principle, there are two kinds of nodes on a Storm cluster: Continue reading →

One week after details of NSA’s PRISM program were made public, revealing the government’s direct access to the data of social media giants like Google and Facebook, a parody account on Twitter posted this status update:

This post isn’t about the government accessing our social media data; at least, not in any way that differs from anybody else accessing it. Furthermore, the NSA isn’t a very good yardstick for understanding the computational power and data access available to marketers, potential employers, exes, or stalkers. Continue reading →

Storm, a big-data processing system, has been presented by Twitter as a distributed and fault-tolerant stream processing system with the following key design features:

• Horizontal scalability: Computations and data processing are performed in parallel using multiple threads, processes and machines.
• Guaranteed message processing: The system guarantees that each message will be fully processed at least once. The system takes care of replaying messages from the source when a task fails.
• Fault-tolerance: If there are faults during execution of the computation, the system will reassign tasks as necessary.
• Programming language agnostic: Storm tasks and processing components can be defined in any language, making Storm accessible to nearly anyone. Clojure, Java, Ruby, Python are supported by default. Support for other languages can be added by implementing a simple Storm communication protocol.

In this blog post we provide you with a solid overview that will help you take advantage of implementing big-data analytics over streaming data.
Continue reading →

In our last article we covered how you can connect two Node.js processes using streams. In this article we will explore that same technique, but this time we’ll connect a browser to a Node.js websocket server and implement a simple ping service as an example. Read more about websocket servers in the Node Cookbook.
Continue reading →

Web applications and systems are hard to write. They start off simple, but as time goes on and features are added or changed, they can become complicated. Adhering to RESTful practices can help simplify those systems by focusing on the state of your applications.

It’s possible to bolt a RESTful service onto a system that does not focus on state, but REST can be much easier, and more useful if designed into the system from the start. Read 8.4. State and Statelessness in RESTful Web Services to learn more about state in REST.

When you’re starting out in REST, one of the hardest things to do is to leave behind the mentality of the command pattern.
Continue reading →

Writing user authorization systems RESTfully can be tricky for any newcomer to REST. This blog post is meant to provide some ideas on how you can do this in a RESTful manner.

When people first think of user authorization, they often think in terms of commands:
Continue reading →