Assignment 3 R Programming Coursera Certificate

Programming assignments require you to write and run a computer program to solve a problem.

Some programming assignments count toward your final course grade, while others are just for practice.

Sections of a programming assignment

Programming assignments include both assignment instructions and assignment parts.

Assignment instructions:

  • Explain the assignment.
  • May include a link to a downloadable starter package that includes starter code, detailed guidelines, and other resources.

Assignment parts:

  • Are similar to individual questions within a quiz.
  • Are each a single coding task.
  • Are each worth a certain number of points toward the overall assignment score.
  • Can be completed and submitted all at once, or one at a time.

Programming assignment grades

Programming assignments are graded automatically.

Some are graded using a built-in grading algorithm that compares your program's output to a value specified by your instructor. Others are graded using a custom grading algorithm created by your instructor.

If a programming assignment uses built-in grading:

  • Your code will run locally on your computer, and the output will be sent to Coursera's servers.
  • Your grade will be based on comparison against numeric or regular expression grading logic.
  • You'll get your grade a few seconds after submitting.

If a programming assignment uses custom grading:

  • Your code will be run on Coursera's servers.
  • Your grade will be based on custom logic provided by your instructor.
  • You'll get your grade within an hour of submitting.
  • You'll need to refresh the page to see your grade.

Submit a programming assignment

To submit a programming assignment:

  1. Open the assignment page for the assignment you want to submit.
  2. Read the assignment instructions and download any starter files.
  3. Finish the coding tasks in your local coding environment. Check the starter files and instructions when you need to.
  4. If the assignment uses script submission, submit your assignment by running the submission script in your local coding environment and entering the submission token.
  5. If the assignment uses web submission, upload your files using the instructions on your screen.

Test a programming assignment

Some programming assignments let you test them before you submit them to get feedback on whether they run. You won't get grades or feedback from the instructor until you submit the assignment.

Edit or resubmit a programming assignment

You can resubmit a programming assignment if you don't pass on the first attempt or want to improve your score. You might have to wait a certain amount of time between attempts.

To resubmit a programming assignment, follow the same steps for submitting one. If your assignment uses script submission, you'll need to select the Generate new token option on the assignment page and use the new submission token.

Was this article helpful?

Coding standards in R are really important becasue they help you, make your code

readable and allow you and other people to understand what's going on in your code.

Now, of course, just like it is with any

other, style whether it comes, when you, you know, whether

it's your clothing or whatever it is, it's difficult

to get everyone to agree on one set of ideas.

But I think there are a couple of very basic, kind

of minimal standards that are important when you're coding in R.

Alright, so I'm just going to talk a little bit about some of

the coding standards, that I think are important to, when you're writing

R code, and I think will help make your code more readable

and more usable by others if that's what you're trying to, to achieve.

So, the first principle that I think is very

important in pretty much any programming language, not just

R, is that you should always write your code

using a text editor and save as a text file.

Okay, so, a text

file is a kind of basic standard.

It usually doesn't have any sort of formatting or any

sort of, kind of special, appearance, it's just text, right?

And usually, typically, typically it's going to be

ASCII text, but if you're, on, in places

outside the US or the UK using non-English

languages there may be other standard text formats.

But the basic idea is that a text format, can be read by pretty much any

basic editing program.

These days, you know, when you're writing something there's a

lot different of tools that you can use to write.

If you're writing a book, or or a webpage or something like that, there's

all kinds of different tools that you can use to write, to write those things.

But you're, when you're writing code, you should always try to

use a text editor, because that's like kind of like the, the

kind of least common denominator, and it makes it so that

everyone will be able to access your code and improve upon it.

The second principle is, which is very

important for readability, is to indent your code.

So indenting is something that's often hotly debated in lots of mailing lists

and other types of discussion groups in

terms of how much indenting is appropriate.

Now I'm not going to talk about that although I do have some recommendations.

But I think the most important thing

is that you understand why indenting is important.

So indenting is the idea that different blocks of code

should be spaced over to the right a little bit more

than other blocks of code so you can see kind of how the

control flow how the flow of the program goes based on the indenting alone.

So coupled with indenting, is the third principle which I think

is very simple which is, limit the width of your code.

So you have indenting it's possible to kind of

indent off to the right forever so you need

to limit on the right hand side how wide

your code is going to be and usually this is

kind of determined by the number of columns of text.

And so one possibility is you limit your text to about 80 columns of

text and then and so that your, the width of your code never exceeds that.

So, let's take a look for, at a quick example here.

So here you can see I've got R Studio open, here

with a simple code file with some R code in it.

And, first of all, let me just mention that

the editor in R Studio is a text editor.

So it

will always save the R files that you write as text format files.

So, so we've already got that kind of handled.

But you can see the indenting scheme here is equal to one space.

So every indent is one space.

And you can see that all the code is

kind of mashed together here on the left hand side.

It's difficult to tell kind of where the if blocks are.

Where the else blocks are.

Where does the function kind of end and begin?

And so the indenting scheme kind of makes the code not

very readable in this case.

So we can change the indenting in R Studio.

If we just go up to the Preferences menu here.

And go to Code Editing.

And let me just change it to four.

And you can see that the column, the margin column is set to

80 characters, so it will show you the margin when you've reached 80 characters.

And so I'm going to select all here with Cmd+A, and then Cmd+I to indent it.

So now you can see that the

indenting is a little bit nicer now.

You can see, kind of, where the function begins and ends, you can see where the

if blocks start and end, and the, kind

of, structure of the program is much more obvious.

So, I'm going to change this one more time though and my, because my personal

preference for indenting is to use eight spaces,

so I'm going to change this to eight.

Hit OK, and select all. Cmd+I.

And now you can see,

I prefer the eight spaces just because it

really makes the structure of the code very obvious.

And the spacing is nice and clear.

And it makes the code very readable in general.

So you can see that indenting is very important.

And the biggest problem you might have is, with the, with, with too little indenting.

If you don't indent at all or if you only use

a very small amount the code becomes kind of very mashed together.

So I recommend at least four

spaces for an indent and I'm pref, I

prefer, you know, eight spaces for an indent, just

because it makes the code much more readable

and spaces it out much nice, much more nicely.

One of the advantages of having something like an

eight space indent, is coupled with an 80 character margin

on the right hand side, is that it forces you

to think about your code in a slightly different way.

So for example, if you have eight space

indents, if you're going to have a for-loop, nested within

another for-loop within another for-loop, every time you nest another

for-loop, for example, you have to indent over eight spaces.

And by the time you get to maybe your fourth nested for-loop you're

pretty much hitting the right hand column at the 80 column margin, right?

And so the nice thing about the eight space

indent, coupled with the 80 column margin, is that it

prevents you from kind of writing very basic, making very

kind of fundamental, kind of mistakes with, with code readability.

So, for example, with an eight space indent and 80 column

margin, you might not be able to do feasibly more than

two nested for loops, and, but I think that's really the,

kind of, the boundary of what is readable in terms of code.

Typically except for some special cases, a three, you

know, a three nested or four nested four loop is

difficult to read, and it's probably better off, you

know, splitting off into separate functions or something like that.

So a good indenting policy not only

makes the code more readable, but it actually can force you

to think about writing your code in a slightly different way.

And so that's a really nice advantage of, of having a logical

indenting policy with, coupled with a, you know, a right-hand side restriction.


So the last thing I want to talk about is to limit the length of your functions.

Alright so, functions in R can, can theoretically go on for quite

a long time and of course just like in any other language but

just like in any other language I think that the, the logical thing

to do with a function is limit it to kind of one basic activity.

So for example, if you're function's named read the data.

Then your function should simply read the data, it should not read

the data, process it, fit a model, and then print some output, alright?

So you should, the logical kind of steps like

that, should, should probably be spit, split, into separate functions.

There are a couple of advantages to doing this.

First of all, it's nice to be able to

have a function written on a single page of code,

so you don't have to scroll endlessly to see,

you know, where all the code for this function goes.

If you could put all the function, the entire function on like one screen of the

editor, then you can look at the whole function and see what it does all at once.

Another advantage of splitting up your code into logical sections,

to logical functions, is that if you use functions like traceback,

or the profiler, or the debugger, these often tell you, you know,

where in the function call stack you are when a problem occurs.

And if you have multiple functions that are all logically divided

in to separate pieces then when a bug occurs and you know

that it occurs in a certain type of function or a certain

function then you know kind of where to go fix things, right?

So if you have, but if just have a single function that just goes

on forever and a bug occurs then the only thing that the debugger or

the traceback or the profiler can tell you

is that there's a problem in this one function.

But it, it doesn't, it, it's difficult to tell you where exactly the problem occurs.

So splitting up your functions has a secondary benefit, which

is that it can help you in debugging and profiling.

So limiting the size of your functions is

very useful for readability and for, kind of, debugging.

Of course, it's easy to go overboard and

having, you know, a hundred different three-line functions.

So that's not really what

you want to do.

So you just want to make it so that the, the separation of different functions

into, is logical, and that each function

kind of does, does one thing in particular.

So those are my basic guidelines for writing code in R.

There are, of course, many other things that you might be able to think about.

But then we start bordering into areas that

we might, we might kind of disagree on.

And so I'm not going to talk about too much more

in terms of coding standards, but the basic ideas are always

use a text editor, always indent your code, I'd say at least four spaces.

Limit on the right hand side how, how wide your code can be.

And and always limit the size of your functions, so that you

can, so that they're, kind of grouped into logical pieces of your program.

So with those four things, I think you'll,

your, your code will be much more readable.

It'll be readable to you, it'll be readable to others, and it'll make kind

of writing R code much more useful to everyone.

Categories: 1

0 Replies to “Assignment 3 R Programming Coursera Certificate”

Leave a comment

L'indirizzo email non verrà pubblicato. I campi obbligatori sono contrassegnati *