Explore
For Enterprise
Join for Free
Log In

Arts and Humanities
Business
Computer Science
Data Science
Information Technology
Health
Math and Logic
Personal Development
Physical Science and Engineering
Social Sciences
Language Learning
Degrees
Certificates

Explore all of Coursera

Browse
Search
For Enterprise
Log In
Join for Free

Scope

Loading...

Ruby on Rails: An Introduction

Johns Hopkins University

4.5 (1,682 ratings) | 64K Students Enrolled

Course 1 of 6 in the Ruby on Rails Web Development Specialization

Did you ever want to build a web application? Perhaps you even started down that path in a language like Java or C#, when you realized that there was so much “climbing the mountain” that you had to do? Maybe you have heard about web services being all the rage, but thought they were too complicated to integrate into your web application. Or maybe you wondered how deploying web applications to the cloud works, but there was too much to set up just to get going. In this course, we will explore how to build web applications with the Ruby on Rails web application framework, which is geared towards rapid prototyping. Yes, that means building quickly! At the conclusion of this course, you will be able to build a meaningful web application and deploy it to the “cloud” using a Heroku PaaS (Platform as a Service). Best of all, it will almost feel effortless… Really! “But wait”, you will say, “there is no way that we can build a useful application if there is no database involved. You need the data for an application to be useful.” Great point! But what if… instead of getting the data from the database, we get it from the internet by tapping into one of the web services out there that readily provides data needed by our application? “Ok, but that’s probably very complicated”, you will say. Take this course and you will be pleasantly surprised at just how easy it is!

Skills You'll Learn

Ruby (Programming Language), Ruby On Rails, Heroku

Reviews

4.5 (1,682 ratings)

5 stars
1,165 ratings
4 stars
344 ratings
3 stars
86 ratings
2 stars
39 ratings
1 star
48 ratings

JJ

Nov 17, 2016

This course was a great way to review RoR. The lectures are well organized and the assignments are fun. The professor is there to answer questions and is quick to reply. Great experience!!

KK

Dec 27, 2016

Thanks to Kalman Hazins and JHU for the wonderful introduction. The course provides for a hands on introduction to the MVC framework along with the Ruby programming and Rails deployment.

From the lesson

Introduction to Ruby

In this module, we will explore the different areas of the Ruby programming language.<p>We will start with the basics and continue with more advanced topics, such as arrays and hashes. We will also spend time exploring object oriented programming in Ruby, and finish the module by demonstrating how to perform unit testing.</p>

Class Inheritance8:44

Access Control7:07

Taught By

Kalman Hazins
Adjunct Professor, Graduate Computer Science

Transcript

[MUSIC]

Hi and welcome to lecture 13.

In this lecture, we'll talk about scope.

Scope of variable, scope of constants, scope of blocks.

So the way scope works is as follows.

Methods and classes begin new scope for variables, which means that the outer

scope variables do not get carried over to the inner scope.

And you could always use local_variables method to see which variables are in and

which variables are not in the current scope.

So for example, we have a v1 variable defined outside of

the class and let's define it to a value "outside".

If you try to use this variable inside the my_method method and

you try to print it out, you'll get an exception thrown.

Because my_method has no idea about this variable called v1,

you could of course, define a new variable called v1 inside the method.

And then when you print it out, you get the value of inside and you could also

print what local_variables are available inside this method, which is your scope.

And you will see that v1 is available inside the scope,

which is this v1 over here.

Now you, could of course, print v1 outside of the class and

you will get the "outside", because that's the same scope.

And if you print local variables at this point, you'll get v1.

And you'll also get object, which is this variable,

which was defined a few lines ago.

So that's how variable is work.

Now constants are basically any reference that begins with uppercase,

including classes, modules or any other constants.

And the constant scope rules are different than variable scope rules.

The inner scope constants can see constants defined in the outer scope and

they can also override our outer constants.

Although outside of that inner scope, the value remains unchanged for constants.

So let's see an example.

Let's say, we have a value of PI,

which starts with an uppercase, wherever is all that matters.

And you define that it is 3.14 and then you wanna use that all

the way inside the class Test2, inside the method what_is_pi.

That's fine, because it's a constant.

You wouldn't be able to do it with a variable.

So in this case, you got an exception thrown, but

you could do it with a constant without a problem.

Now if you had a constant called MyConstant and

then you override the value Outer Constant here.

And MyConstant = Inner Constant prints Inner Constant, but

outside that constant is still known as Outer Constant.

So point is you could use it, but once you define it as a new value,

that value becomes the new value of a constant.

But when you go back out to the outer scope, you're back to the original value.

Now the change in the value of a constant is kinda weird,

because the whole point of it is that it should be a constant.

So for example, the value of PI will probably be the same value and

you probably don't wanna be changing it, but

I'm just pointing out the way it actually works.

So if for whatever reason you see some behavior and you're not sure why it's

happening, the first thing you should check is, are you name your variables

correctly of the lower case while your naming them with upper case.

In which case, it's a constant, which means it has this behavior.

Now we move on to scope of blocks.

Blocks are not like methods.

So the variables in the blocks actually inherit the outer scope and

this is beyond this lecture, but a block actually is a closure.

If you remember, it was the context in which it was defined and

uses that context whenever it is called,

but just to show you an example specifically for a scope portion.

Let's say, you have a class called BankAccount,

which maybe has an id and an amount that you are putting into the bank.

That you're instantiating your bank account with and

then you have an array of three different BankAccounts.

Maybe in the amount of 200, 100 and -100 and

then you wanna add up the amount in all those three accounts.

So you have a block here and you have a total_sum variable,

which starts out as zero, then total_sum get values added or subtracted from it.

And at the end, you print out the total_sum variable.

So if this would be a method, total_sum would be a totally different variable and

you wouldn't be able to do this.

But because it's a block, the scope for the total_sum is the same.

It gets inherited here from the outside and you're able to keep

adding to the total_sum variable and print it out at the end.

So the variable actually is affected.

Now having said that, that is a default behavior.

But even though blocks share the outer scope,

a variable that's created inside the block is only available to a block.

The parameters to the block are always local to a block

even if they have the same name as the variables in the outer scope.

And finally, you can explicitly declare block-local variables

after a semicolon in the block parameter list and let's see an example for

all three of these on the next slide.

So you have an array or a bunch of values.

You have a current number, which is 10,

but current number is also a name of a parameter to the block.

Because of that, when you loop them through the array of 5, 4, 1.

The current number is 5, 4, 1, which gets printed out here and

the current number is still 10 on the outside.

So because the parameter to a block is current number,

it is actually not accessible inside a block.

Because you named it the same, so

the scope does not go inside the block.

Also the some_var variable, which you happen to create inside

the block is not accessible outside of the block.

So even though it is usual for variables outside of the block, go into the block.

The scope is inherited inside the block, it doesn't work the other way around.

The variables declare inside the block, actually do not propagate outside and

the final example is we have this variable called adjustment.

Adjustment = 5 and we're doing something on adjustment inside,

we setting the adjustment to 10.

Based on what we just said, the value of adjustment should be affected.

And when it's outside, it should be 10.

Because it got changed inside the block, but

we can declare after semicolon that we want certain variables

to be local even though they have the same name as the outside variables.

So happens to be this one, this variable is called adjustment and

we're using a variable called adjustment inside the block.

So this basically is saying, treat this adjustment variable as a local variable

not as a variable that gets inherited from outside of block.

In summary, methods and classes start a new scope for variables.

Constants maintain scope.

So, a constant coming from outside of a method or a class

will retain the scope and you're able to access a constant

even though it was defined outside of a class and outside of a method.

Blocks usually inherit the outer scope, but

we talked about ways how you could override that if you want.

Next, we'll talk about Access Control for methods.

Explore our Catalog

Join for free and get personalized recommendations, updates and offers.

Coursera provides universal access to the world’s best education, partnering with top universities and organizations to offer courses online.

© 2019 Coursera Inc. All rights reserved.

Download on the App Store

Get it on Google Play

Coursera
About
Leadership
Careers
Catalog
Certificates
MasterTrack™ Certificates
Degrees
For Enterprise
For Government

Community
Learners
Partners
Developers
Beta Testers
Translators

Connect
Blog
Facebook
LinkedIn
Twitter
Instagram
YouTube
Tech Blog

More
Terms
Privacy
Help
Accessibility
Press
Contact
Directory
Affiliates