vocab.md

Words we learned so far:

W1D1

• Web App: A website that has a server behind it and has some data that is going to live somewhere in a database between times you visit.
• The Cloud: the cloud is essentially a computer that holds other 'virtual' computers within it. This is possible because computer processing power is powerful enough that we are able to split up a processor into several 'smaller virtual processors'.
• 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, rails & 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.
• Open Source: a type of technology where anyone can view or request a change to the software.
• 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.
• Boilerplate: a basic set up to work with for any particular web app framework (e.g. Sinatra).
• Stack: the different technologies and languages to a working web application. Different companies have different "stacks".

W1D2

• Semantic: Semantic means meaning... to eleborate, it provides 'context' behind the text and content that you decide to stuff into an html page. In order for a browser to 'see' a page like we do, they require the meaning behind the content so that they some particular text is a header for example.
• Element: An element is a complete HTML tag. This could be something like <p>I'm a paragraph</p> or a self-closing tag such as <img src="..." >
• Nesting: When you stuff HTML elements inside of other elements, that's called nesting. This is a common practice and in some occasions it's required such as in <ul> tags and <form> tags. Make sure to indent your code as you nest to make debugging.
• Cloud 9: Cloud 9 is your IDE (integrated developer environment). It's an online service that you will develop your finstagram apps on.
• IDE: an ide is your one stop shop for developing. it is generally an application that has everything you need from writing.

W2D1

• CSS: Cascading style sheets, or the style language of the web.
• Selector: the html element(s)/tag(s) that are being targeted and styled with the CSS language, elements can be selected by their tag name, class and or id as well as several other pseudo-selectors (<--more advanced css). IE:

  <h1 class="titles" id="main-title">Hello World</h1>
 /*selecting by tag name*/ 
 h1 {
   ...
  }
  /*selecting by class*/
  .titles {
   ...
  }
  /*selecting by id*/
  #main-title {
   ...
  }

• Property: the styling rules that can be applied to a selector. IE: border, background color, text color etc.
• Property Value: the different values that a CSS Property may have. IE:

  /*property: value*/
  background-color: red;
  background-color: blue;

• Box model: The way that css thinks about each element on the page. see this link for the perfect metaphor for the box model!
• Padding: The space within an element.
• Margin: The space betweeen an element and other things.
• Stylesheet: A collection of css that we can add to the head section of our page to apply the style rules within it.
• Class tag: A way of linking a style rule to a piece of html.
• Id tag: A unique way of linking a style rule to a piece of html. Useful to make sure that you aren't accidentally applying the same rule where you didn't intend to.

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'

W3D2

• Database: In a nutshell is a place where data can be stored persistently
• Persistance: In the database realm, persistance means data that will not be lost if the computer loses power. Think hard drive, that's a persistance storage mechanism
• Relational Database: A particular type of database that organizes data like an Excel Sheet: tables, columns and rows.
• Table: is a container for holding all data that describes a particular thing. In finstagram we have tables for users, posts, comments etc.
• Columns/Fields: All of the seperate properties that belong to a table to describe the things being stored in the table. For example in a users table we may have columns named name, username, email, password etc.
• Rows: each individual record inside a table. They are generally given some type of unique identifier like an auto-incrementing 'id' number
• ORM: a programmatic way of interacting with a database minus all of the SQL. ORM stands for Object Relational Mapper. It 'Models' a representation of a table in the database and provides a generally easy programming interface (with methods) to interact with to perform CRUD
• Active Record: is the ORM that we are using inside of our applications. It is a ORM built in Ruby which allows us to use Ruby code to interact with a SQL database
• Query: is an interaction with the database. We query the database to insert data, remove data, update data, and retrieve data
• Active Record Model: is functionally a Ruby Class that represents or models a particular table in the database. It inherits special powers from the ActiveRecord class to provide us with a huge set of methods that allow us to interact with the database.
• Class: This is something that's generally apart of all Object Orientated Languages. A Class is generally a blueprint of a 'thing'. It contains methods and properties that describe the thing. We could have a class House which may have properties like number_of_floors or square_footage as well as methods like def open_door or def turn_off_all_lights

W4D1

• Query: The word to describe how to retrieve specific data from a database.
• Associations: How we describe relationships between types of data in our database.
• Class: The object-oriented way to create objects that has access to methods and contain data.
• Inheritance: The way we allow our classes to have access to the methods of other Classes... without having to retype it all.
• Instance method: A method that lives within a class. Each "instance" of that class (aka an object) can "call" (use) that method without impacting the way other objects behave.
• Validations: How we check that the data being entered into the database for each class meets specific criteria, so that it's nice and clean and tidy in our database.

W5D2

• Session: A unique, secret identifier that allows the browser to know about a user in between pages as long as that user is logged in.
• Cookie: The browser's data that it stores about the user.
• Helpers: Sinatra's word for Ruby methods that any view can access (for security and confusion reasons we don't usually do that!)

W6D1

• Media Query: A way to target specific styling at different browser sizes
• Permissions: How we control which users are allowed to see which pages
• HTTP Codes: Numbers that correspond to different responses from the server