This document provides summaries of Grape, Goliath, EventMachine, Fibers, and Node.js. It then discusses the Grape_Goliath gem, which generates a Goliath application skeleton using the Grape API framework. The gem leverages Rubigen and NewGem to quickly generate the directory structure and include necessary files. The generated application can then be run with the Goliath server.

1. CONTENTS
● Brief Description on:
1. Grape
2. Goliath
3. Eventmachine
4. Fiber
5. Node.JS
6. Node.JS vs EM
● Grape_Goliath Gem and Usage

2. GRAPE
● REST-like API micro-framework for
Ruby
● Designed to run on Rack or
complement existing web application
frameworks.
● Grape APIs are Rack applications
that are created by subclassing
Grape::API.

3. Advantages
● No need of rails to create simple
API's.
● Grape allows you to build lightweight
APIs with Ruby when you don't need
the heavy lifting power of large
frameworks like Rails.

4. GOLIATH
● Non-blocking Ruby web server
● Serves to requests using a
EventMachine loop.
● Uses a Fiber to process a request.

5. Significance of Goliath
● Bare metal performance
● Rack API and middleware support
● Simple configuration
● Fully asynchronous processing
● Readable and maintainable code

6. Goliath Advantage
● Major advantage over other frameworks is
that by leveraging Ruby fibers introduced
in Ruby 1.9+, it can untangle the
complicated callback-based code into a
known format.
● Linear execution, leads to more
maintainable and readable code.

7. ..contd
● Each HTTP request within Goliath is
executed within its own Ruby fiber and all
asynchronous I/O operations can
transparently suspend and later resume
the processing without requiring the
developer to write any additional code.
● Both request processing and response
processing can be done in fully
asynchronous fashion:
streaming uploads, firehose API's,
request/response, websockets, and so on.

8. Goliath compared to
other servers like Thin
● Goliath is able to run on different Ruby
platforms.
● It uses a different HTTP parser, supports
HTTP keepalive & pipelining.
● Offers a fully asynchronous API for both
request and response processing.

9. ..contd
● Goliath claims to works its magic by
“leveraging Ruby fibers introduced in Ruby
1.9+”.
● Fibers are primitives for implementing light
weight cooperative concurrency in Ruby.
Basically they are a means of creating
code blocks that can be paused and
resumed, much like threads.
● The main difference is that they are never
preempted and that the scheduling must
be done by the programmer.

10. EVENTMACHINE
● EventMachine is an event-driven I/O and
lightweight concurrency library for Ruby.
● It provides event-driven I/O using the
Reactor pattern, much like JBoss Netty,
Apache MINA, Python's Twisted, Node.js,
libevent and libev.

11. EM Significance
● Extremely high scalability, performance and
stability for the most demanding production
environments.
● An API that eliminates the complexities of
high-performance threaded network
programming, allowing engineers to
concentrate on their application logic.
● This unique combination makes
EventMachine a premier choice for critical
networked applications, including Web
servers and proxies, email and IM production
systems, authentication/authorization
processors, and many more.

12. EventMachine Usage
● Scalable event-driven servers. Examples:
Thin or Goliath.
● Scalable asynchronous clients for various
protocols, RESTful APIs and so on.
Examples: em-http-request or amqp gem.
● Efficient network proxies with custom
logic. Examples: Proxymachine.
● File and network monitoring tools.
Examples: eventmachine-tail and logstash.

13. FIBERS
● Primitives for implementing light weight
cooperative concurrency in Ruby.
● They are never preempted and that the
scheduling must be done by the
programmer and not the VM.
● Small 4KB stack enables it to be paused
from deeply nested function calls within
the fiber block.
● Run using the Fiber#resume method. The
code running inside the fiber can give up
control by calling Fiber.yield.

14. Client Example

15. Server Example

16. Node.JS vs EM

17. Pros and Cons
EM
● Clever DSL
● Also Fast
● Its Ruby
● Mature
● Restricted EM Libraries.
● More difficult to write
than normal ruby.
Node.JS
● Shared Code
betweeen Client
and Server.
● Lightning Fast
● Javascript used
● Callback Hell
● Less Mature.

18. EventMachine Better
than Node.JS?
YES
● EventMachine’s concurrent processing
ability is stronger than Node.js 50%.
● When request number goes up, Node.js’s
connection rate goes down.

19. Gem Grape_Goliath
●
Gem which creates an application with
tree structure specified for a Goliath
application having Grape API framework.
● Included Gems in tree structure :
grape, goliath, em_synchrony
● Added dependencies of rubigen included.

20. Basic tree structure
/config

21. Important Gems Used
Rubigen
● A framework to allow Ruby applications to
generate file/folder stubs.
● RubiGen will be normally integrated into
another RubyGem, such as newgem, rails or
camping.
● Here we have used newgem.
`` NewGem
● Quickly bundle any Ruby libraries into a
RubyGem and share it with the world.

22. Generators
● There are two types :
1. Application generators – Used by
developers for the framework to get started.
Generally used to generate a basic stub
directory files/folders.
2. Component generators - Used by
developers to extend their application.
● Here we have used application generator for
basic goliath app tree structure generation.

23. grape_goliath_generator.rb
● Application generator for the gem.
● Its manifest method includes the
directories that are to be created and the
files that should be inlcuded in the tree
structure.
● The files that should get added with
specified code are to be included in the
templates folder in the path
app/application_generator/grape_goliath
/templates.

24. Usage
● grape_goliath application_name
● cd application_name
● bundle install (To install all dependencies)
● ruby server.rb -vs (To run the Goliath server)
● For further info visit:
https://github.com/qburstruby/grape_goliath

25. Enjoy Grape_Goliath!!
Thank You