Content Aligned Readings

A few of us on slack have noticed that previous cohorts have done prep broken down into days, each with its own required readings. In my acceptance email, I got a link to some required readings, but it would be helpful to know more precisely which readings would best help for each section/exercise. Thanks!

1 Like

Great curriculum feedback Ravi, thank you. I will have this incorporated into the curriculum tasks, but for now here is an initial schedule:

CodeAcademy Command Line Course - Do this after the Introduction section if you want more practice
Peter Cooper ch2-4 - Read these ruby review chapters before the RSPEC section
Chris Pine ch10 - Read before Blocks & Iterators section
CodeAcademy Ruby Course - Do this in the RSPEC section if you are having trouble working with Ruby on those problems.

This is taken directly from the previous course structure but as I look at it, these readings feel much more like supplemental material. Many students have said that they like Peter Cooper/Chris Pine’s way of explaining so feel free to read more. Students have also mentioned the CodeAcademy courses as being great for practice and review. That being said, completing every task in the alpha course online platform while taking notes to understand each topic is the most important way to prepare for your first day at AppAcademy.

Let me know if you have any questions. Thanks!

2 Likes

Great, thanks for the tips Kevin!

Hi Kevin,
I have finished most of the RSPEC exercises (I need to do some work on Factory Methods and hash options for functions still, but I finally skipped ahead since I couldn’t find relevant reading material that discussed this in sufficient detail). Any suggestions?

I’m now on to the curriculum and simple exercises that follow RSPEC. Almost none of this is new and useful (since I spent 3 weeks on the RSPEC exercises and teaching myself Ruby, and since I am coming in from doing the JumpStart Step 1 course previously.) It would have been great material to start with.

There are a few nuggets of awesome new wisdom in there, but it would be much better to move RSPEC 2-4 after all of the instructional material. Also, the Coding Smells video was pretty unwatchable at the beginning of the course, but now is very informative – you could put it right before the More RSPEC section with exercises 2-4. I know that the RSPEC 1-4 section is actually the entire TestFirst.org curriculum, but I think it will be much better to break it up for the rest of the folks joining our cohort. We will all benefit from everyone coming in well prepared, and exercises 2-4 are presented before the basic material that’s required to complete them.

Also, there are a couple of interesting Sanity Checks. Here’s one I found this morning:

The rest of our cohort will have less time than we did to figure out how or when to skip ahead or to get lost following instructions like looking for an Exercises folder or repeating a mandatory quiz about the delete method that contradicts the material.

Definitely needs a thorough read through with a red marker, but first thing I would do is re-order the curriculum, then grab the useful content from the old curriculum and start shoveling that in. I found some github pages from the old curriculum that mention Factory Methods, so I am planning to review all of that material before going back to finish up the heroku course.

We have an SF study group, and we’d be happy to come in and talk to you about the alpha course some time in the next week or two.

Thanks! Talk soon,
David

1 Like

Hi David,

I can’t thank you enough for the time and effort you put in to providing excellent feedback for the improvement to our new Alpha Course Curriculum. I look forward to working with the curriculum manager for this course and implementing all of these changes as soon as possible, including fixing the content errors.

As for the material you requested, factory methods can really just be though of as methods used to abstract away the creation of objects. For example, here is some code from the App Academy Online App:

class User
  def generate_user_courses
    UserCourse.create_from_user_enrolled_courses(enrolled_courses)
  end
end

class UserCourse
  def self.create_from_user_enrolled_courses(course_list)
    course_list.each do |course|
      UserCourse.create!(course: course, user: user)
    end
  end
end

This code describes a method on the User class and a method on UserCourse. When a user signs up we generate associated UserCourse objects which track information like how a user is doing on that course. The create_from_user_enrolled_courses method is an example of a Factory method and it helps make the code over on the User class much more clean!

The Factory method is really a derivative from a programming pattern called the Factory Pattern. This is outside the scope of App Academy’s course but here is some external reading. Basically imagine in our example if the Factory Method had to do much more than just iterate over a list of courses. The more complex that method gets, the more you may want to make a separate UserCourseFactory class.

For hash options I would just google around a take a look at popular stack overflow explanations if you find the concept confusing, it is a bit strange but very useful. Basically, pass a hash as an argument instead of separate arguments so that you don’t have to worry about things like order and you can implement some custom error handling.

def user(attributes = {})
  raise ArgumentError, 'You must provide a name' unless attributes[:name]
  raise ArgumentError, 'You must provide an email' unless attributes[:email]
  name = attributes[:name]
  email = attributes[:email]
  p "the user\'s name is #{name} and email is #{email}"
end

Please excuse the code smell of putting this all in one method but hopefully this basic example gets the brain thinking about hash options. You can imagine how many attributes a user might actually have and how worrying about how we pass those to the method like this would be a nightmare.

Let me know if you have any questions and thanks again for the great feedback. I will have someone reach out to find a time when we could chat with your study group about improving the curriculum.

1 Like

Thanks! I barely think I get it. I can now make a class wrapper around Fizzbuzz. If I do this, then I can make different instances of Fizzbuzz with different values that set off the Fizz and the Buzz substitutions.

Is that last thing the right way to make this accessible at the top level?

class Fizzbuzz

  def self.factory(options)
    self.new
    @m = options[:fizz]
    @o = options[:buzz]
  end

  def self.fizzbuzz(n)
    result = (1..n).to_a
    result.each_with_index do |num, idx|
      result[idx] = "fizz" if num % @m == 0
      result[idx] = "buzz" if num % @o == 0
      result[idx] = "fizzbuzz" if num % (@m * @o) == 0  # assigned last, overwrites
    end
    result
  end

  def fizzbuzz(n)
    n.fizzbuzz
  end

end

Fizzbuzz.factory(:fizz => 3, :buzz => 5)

def fizzbuzz(n)
  Fizzbuzz::fizzbuzz(n)
end

Hey David,

I have never really seen that double semi colon syntax used to make a class method available like that but seems reasonable to me. Usually we avoid global scope but I understand this is an example with the goal being to avoid having to write Fizzbuzz.fizzbuzz and just calling fizzbuzz whenever you want. Cool!

Hi David,

So glad I saw your post, as I am really confused about rspec 2 since I was never shown how to pass a block as an argument…do you think I can pick your minds on how to better navigate the alpha course material? I could not find a way to send you a direct message for some reason…my email is siuding0601@gmail.com fee free to send me a message if you can help. Thanks a lot!

Cherry