Skip to main content

Bamboo Web Framework

Bamboo is a web framework for building scalable and maintainable applications in Elixir.

It provides a set of tools and conventions that make it easy to develop robust web applications. In this tutorial, we will explore the history, features, and examples of Bamboo.

History of Bamboo​

Bamboo was created by Paul Schoenfelder and released in 2016. It was inspired by other web frameworks like Ruby on Rails and Phoenix, and aims to provide a similar developer experience and productivity in Elixir.

Features of Bamboo​

1. Routing​

Bamboo provides a powerful routing system that allows you to define routes and map them to controller actions. Here's an example of how to define a route in Bamboo:

defmodule MyApp.Router do
  use Bamboo.Router

  route get: "/hello", to: MyApp.HelloController, action: :index
end

In this example, we define a route that maps a GET request to "/hello" to the index action of the MyApp.HelloController. When a request is made to this route, Bamboo will call the index function in the controller.

2. Controllers​

Controllers in Bamboo are responsible for handling requests and generating responses. They can be used to define actions that correspond to different routes. Here's an example of a controller in Bamboo:

defmodule MyApp.HelloController do
  use Bamboo.Controller

  def index(conn, _params) do
    text(conn, "Hello, Bamboo!")
  end
end

In this example, the index action simply returns the text "Hello, Bamboo!" as the response.

3. Views​

Views in Bamboo are responsible for rendering HTML templates and generating responses. They can be used to separate the presentation logic from the controller. Here's an example of a view in Bamboo:

defmodule MyApp.HelloView do
  use Bamboo.View

  def render("index.html", assigns) do
    ~s"""
    <html>
      <head>
        <title>Hello</title>
      </head>
      <body>
        <h1>Hello, <%= @name %></h1>
      </body>
    </html>
    """
  end
end

In this example, the view defines a render function that takes a template name and assigns as arguments. It returns an HTML string that will be sent as the response.

4. Templates​

Bamboo supports various template engines for rendering dynamic content. Some popular template engines supported by Bamboo include EEx, Haml, and Liquid. Here's an example of using EEx templates in Bamboo:

defmodule MyApp.HelloView do
  use Bamboo.View, engine: Bamboo.Engine.EEx

  def render("index.html", assigns) do
    ~E"""
    <html>
      <head>
        <title>Hello</title>
      </head>
      <body>
        <h1>Hello, <%= @name %></h1>
      </body>
    </html>
    """
  end
end

In this example, we use the EEx template engine to render the HTML template. The @name variable will be replaced with the actual value during rendering.

5. Middleware​

Bamboo supports middleware, which allows you to modify the request and response before they reach the controller. Middleware functions can be used to add authentication, logging, or any other custom logic. Here's an example of a middleware in Bamboo:

defmodule MyApp.LoggerMiddleware do
  def call(conn, _opts) do
    IO.puts("Request: #{inspect(conn)}")
    conn
  end
end

In this example, the call function logs the request before passing it to the next middleware or controller.

6. Plug Integration​

Bamboo is built on top of the Plug library, which is a specification and a set of convenience functions for building web applications in Elixir. Bamboo integrates seamlessly with Plug, allowing you to use Plug middleware and adapters with Bamboo applications.

Examples​

Now let's see some examples of how Bamboo can be used in practice.

Example 1: Hello World​

Let's start with a simple "Hello World" example using Bamboo.

defmodule MyApp.Router do
  use Bamboo.Router

  route get: "/hello", to: MyApp.HelloController, action: :index
end

defmodule MyApp.HelloController do
  use Bamboo.Controller

  def index(conn, _params) do
    text(conn, "Hello, Bamboo!")
  end
end

In this example, we define a route that maps a GET request to "/hello" to the index action of the MyApp.HelloController. The index action simply returns the text "Hello, Bamboo!" as the response.

Example 2: Dynamic Content​

Let's extend the previous example to render dynamic content using templates.

defmodule MyApp.HelloController do
  use Bamboo.Controller

  def index(conn, _params) do
    render(conn, "index.html", name: "Bamboo")
  end
end

defmodule MyApp.HelloView do
  use Bamboo.View, engine: Bamboo.Engine.EEx

  def render("index.html", assigns) do
    ~E"""
    <html>
      <head>
        <title>Hello</title>
      </head>
      <body>
        <h1>Hello, <%= @name %></h1>
      </body>
    </html>
    """
  end
end

In this example, the index action of the MyApp.HelloController now calls the render function and passes the template name and assigns as arguments. The template uses the @name variable to render the dynamic content.

Conclusion​

In this tutorial, we explored the Bamboo Elixir Framework, its history, features, and provided several examples to showcase its usage. Bamboo offers a powerful and flexible way to build web applications in Elixir, with features like routing, controllers, views, templates, middleware, and Plug integration. It simplifies the development process and allows for scalable and maintainable applications.

To learn more about Bamboo, you can visit the official website: https://github.com/thoughtbot/bamboo