Name: Video #1 - Active Record Design - An Overview
Uploaded: 2016-04-29T16:33:08.977Z
Duration: 4 min 9 s

University of New Mexico

Web Application Development: Basic Concepts

110 ratings

This is the first course in a Coursera Specialization track involving Web Application Architectures. This course will give you the basic background, terminology and fundamental concepts that you need to understand in order to build modern full stack web applications. A full stack web developer is familiar with each "layer" of the software technologies involved in a web application, including data modeling and database technologies, the web server environment and middleware components, network protocols, the user interface and basic visual design and user interaction concepts. In this course we will learn by doing. We will start by learning the major components of web application architectures, along with the fundamental design patterns and philosophies that are used to organize them. You will build and continually refine a fully functional full-stack web application as we progress through the modules in this course. Along the way you will be exposed to agile software development practices, numerous tools that software engineers are expected to know how to use, and a modern web application development framework. This course is also available in Spanish. To join the Spanish version, visit this page: https://www.coursera.org/learn/apliweb.

From the lesson

Module #3 - Managing Data

A successful web application provides information t o users that is (1) useful, and also (2) easy to access and understand. This information is often collected from users, as well as from other information sources, and must be stored in a manner that allows it to be manipulated by the web application. The typical app roach is to store this data in a relational database. In this module you will learn some basic concepts associated with modeling the data in a web application, including h ow to specify the relationships between various data entities. We will also investigate ho w to hook a web application up to a back- end data store, along with good design techniques t hat will make it easier to use the data in your web applications by maintaining consistency th roughout the entire web stack.

Active Record Design Pattern - An Overview0:38

Video #1 - Active Record Design - An Overview4:09

Video #2 - Active Record in Rails8:55

Video #3 - Database Migrations6:44

Video #4 - Blog - Iteration 24:31

Meet the Instructors

Greg Heileman
Professor and Associate Provost
Electrical and Computer Engineering
Manel Martínez-Ramón
Professor
Electrical and Computer Engineering

[MUSIC]

Let's take a look at where the Active Record design pattern fits within

the canonical web application or architecture.

As I just mentioned, the Active Record design pattern is applied over these

three tiers in the canonical web application architecture.

By using the Active Record module in Rails,

you'll be able to access the Rails databases using standard Ruby code rather

than SQL queries that may vary slightly according to the database you're using.

I should also mention that it's easier to understand the Active Record design

pattern if you have some idea of how relational databases work.

So the previous lessons in this module should serve you well in that regard.

The Active Record design pattern was named by Martin Fowler in his 2003 book,

Patterns of Enterprise Application Architecture.

This is a common way of persisting data to backend databases in Ruby applications.

And it's so useful and powerful that it's baked right into the Rails framework.

So as I've mentioned,

it's used to access data that's stored in a relational database.

By using this design pattern, you can perform create,

read, update, and destroy operations on your data

without having to fight with the underlying database technology.

That is, it provides a useful abstraction that effectively shields the developer

from the intricacies associated with the data tier.

This abstraction facilitates the ability to swap out database technologies in your

application and to use different databases in different application environments.

Most applications today are built using some object-oriented language.

And it's often necessary to persist data to backend databases.

So there's a big problem here.

There's a fundamental mismatch between object-oriented programming languages and

relational databases.

Active Record solves this problem.

The magic associated with the Active Record design pattern is how it allows

object-oriented languages to work seamlessly

with relational database technologies.

It does this by creating what is known as an object-relational mapping,

which is a mapping between object-oriented language constructs and

relational database constructs.

The object-relational mapping provided by Active Record automatically converts

objects into constructs that can be stored in a database, and then converts them back

to object-oriented constructs when you retrieve them from the database.

This creates, in effect, what is known as a virtual object database that can be

used within the object-oriented programming language.

This is what Rails uses to create a virtual object database

within its web application architecture.

Here's how it's done.

Active Record uses the following object-relational mapping.

It maps classes from the object-oriented language to tables in

the relational database.

It maps objects of the given class to records within the table,

and that, in other words, these are the rows in a table.

And finally, it maps the attributes associated with a class to record values,

in other words, columns in a given database table.

The Active Record design pattern is provided in Ruby

in a module called ActiveRecord.

And using this module, you can establish a connection to many different databases.

You can create database tables.

You can specify associations between tables that correspond to

associations between Ruby classes.

You can establish the object-relational mapping between the Ruby object-oriented

language constructs and the database constructs.

And then you can perform CRUD operations using the Ruby ActiveRecord objects.

It's important to know that this design pattern is implemented as a Ruby module.

So it's available in Rails, and it's also commonly used in other web application

frameworks based on the Ruby programming language, such as Sinatra.