vocab.md

Important Words we've learned:

W1D1

Stack: the different technologies and languages to a working web application. Different companies have different "stacks".

The Cloud: the cloud is essentially a someone elses computer that holds other 'virtual' computers within it.

Version Control: a way of keeping track of changes in code across time or developers.

Git: a type of version control that allows us to track changes and go back to previous versions.

GitHub: an online cloud-based software to host git repos.

Front End: the things the user sees - e.g. html, css, javascript

Back End: the code that talks to the database and runs the web server, in our case ruby, sinatra & active record.

Database: the technology that holds our data to be dynamically displayed on the page by our app.

Heroku: a cloud based service that we can use to host web apps.

IDE: Integrated Development Environment, a one stop shop for updating code, running your webserver and interacting with the commandline.

Cloud9: our cloud-based IDE of choice for this course.

Slack: a chat program popular with tech companies

Ruby: A programming language popular with web development

Algorithm: A list of instructions

Data Type: a form of data used by a programming language such as Strings, integer, float, boolean, hash and array

Variable: something you store data in

Method: something you store code it

Hash: a data type that contains other data

Array: a list of data

Fizzbuzz: A programming challenge that got so popular of an interview question people started memorizing it!

W2D2

• Ruby: a programming language - the one we will be using to program our finstagram in!
• Integers: A data type in Ruby. Refers to whole numbers e.g. -1, 0, 343, 1828281, -123
• Floats: A data type in Ruby. Refers to numbers with decimal points e.g. -1.9912, 0.001, 3.934
• Booleans: A data type in Ruby. Can only be true or false.
• Strings: A data type in Ruby. The way to store and work with text e.g. “Hi i’m a string”, ‘I\’m also a string’
• Operators: The way to do math in programming.
• Concatination: Joining strings together.
• Variables: How we temporarily store information (not in the database... or at least maybe not yet) so that we can store information for use later in our code.
• Snake Case: The way that we name variables in Ruby. Developers are strict about following standards (aka conventions) like this so that it's easier to read each others code.
• String Interpolation: A way to include the result of your variable right into your strin g! E.g. "Hello, #{first_name} welcome to my fancy customized sentence!".
• ____:
• Control Flow: The way that we help the computer do if/else logic to make decisions about what to do in a given situation. This is also sometimes call "conditional logic".
• Methods: The way to store a set of code that we can reuse at another point in time in our code so that we don't have to repeat ourselves as often. Ruby has a LOT of built in methods that you can use so you don't have to write a bunch of complicated code to do fancy things. In other languages these are sometimes call functions.
• Argument: The fancy name for a variable that we use within a method as a placeholder.
• Returning: The name for the end result of what a method "spits out" at the end when it finishes evaluating. Ruby is a bit different than other languages in that the last line of code that runs in a method is the result that the method returns.
• Hash: A fancy way to hold data in Ruby so that you can return it later. They are stored in "key value pairs", where the key (that you as a developer can predict) will be on the left, and the value (that may be entered by the user) is stored on the right. This lets us access data from our app in an easy way. Think of it like super organization for your data.
• Array: A list of things - it could be a list of strings, a list of numbers, a list of hashes or even a list of lists (an array of arrays)! You access this by referring it's position in the list, which in programming will ALWAYS start at 0.

W3D1

• ERB: Embedded Ruby - the way we connect our ruby code to our html to display templates.
• <%= yield %>: A special variable that will load in an erb file with "subcontent" into our base html page.
• Instance variable: A way to let a variable's data be "seen" by the erb template by adding an @ symbol in front of the variable name.
• Alligator tags: the symbols we wrap our ruby code in within our html so it knows where the html stops and the ruby starts (and vice versa!). For ruby logic, it looks like this: <% rubycode %>, and for an individual piece of data we want to show on the page we use <%= data %>
• DRY: Don't repeat yourself! One of the many reminders to ourselves not to re-type things if we don't have to, because we are lazy efficient.
• View: The shorthand term for our ERB file. It means "the thing the user views".
• Actions: Our list of things to "do" when a certain view is accessed, located in our actions.rb file and broken up into different get '/something' do ... some code ... end blocks
• Iterators: What we call a method that loops over a set of data in some way so we can DO something with it in our 'do block'

W4D1

• Object Orientated Programming (OOP): A style of programming which abstract budles of codes in things called 'objects'. The 'object' defines a particular set of behaviours and properties. It is commonly used in programming video games. Ruby is an OOP language!
• Class: One of the main building blocks to an OOP language. A class can be thought of as a blueprint. You use a class to create Objects just like you would use a blueprint or schematic to build a house or similar.
• Instance/Instantiation : An instance can be thought of as single Object derived from a class. Instantiation is the verb we use to describe that process.

 #in raw ruby instantiation looks like this:
  house = House.new
 #House would be the class, calling the .new method would be the instantiation,
 #and house would then be the 'instance' or 'object' of the House class

• Object: In ruby an Object is generally an instance of a Class (although not always) which contains its own methods and properties. Methods and Properties can generally be grabbed by dot notation ie

  my_object.some_method
  my_object.some_property

• Inheritance: This can be a complicated subject, but overall inheritance is the description of the relationships that are possible between classes. In ruby a common inheritance pattern is to extend a class. This essentially allows a 'child' class to inherit special powers from a 'parent' class.

#the syntax looks like this
class child_class < parent_class

• Instance Methods: We've heard of this term a few times while programming in the Sinatra Framework. This is actually something that is apart of Raw Ruby. An instance method are the methods that are written inside a class and can only be accessed on the instance of a class, not the class itself. (the opposite is called "class/static methods" google it)

  class House
    #some code here...
    #not necessary to show for this example
    #adding in an instance method
    def build
      "house built that is #{@width} wide and #{@height} tall!"
    end
  end
  
  #to use we first "instantiate" the class
  my_house = House.new(50, 100)
  #my_house is now considered an "instance" of House (its also now an Object)
  #we can now call instance methods from the house Object my_house
  my_house.build => "house built that is 50 wide and 100 tall"

#making an instance method is just like making any regular method but inside a class block

• Active Record Relationship: the two main relationships that we will use is "has_many" and "belongs_to". The lovely thing about AR is that it's pretty sensical what these two relationships mean. The main points are:
  • has_many and belongs_to describe the relationship between two models and respectively their sql database relationship
  • adding has_many and belongs_to provides special methods to our models which makes querying and performing CRUD much much easier!!