What we’ll learn today: Setting up your computer with the right tools is the first step to becoming a great developer. Setting goals will keep you on course and motivated as you go through this life changing experience.
What we’ll learn today: Whether you plan to work as a freelancer or in a dev shop or for a company, planning is key to building out your applications. We will learn about about tracking systems as we get started on our first app. We will also be expanding our knowledge of ruby basics and discovering tools that we can use when coding with HTML.
What we’ll learn today: Building an application is a step by step process. Keeping track of those steps is what version control is all about. Git is a widely used version control system that will aid you in this process. We will also discover how the ruby console can help you see what your code is outputting. Our HTML time will focus on page organization.
What we’ll learn today: Rails generators are powerful tools that help you build out your code and save you time as a developer. Our Ruby time will focus “strings” and how we can manipulate them to update and extrapolate data. We will also learn different ways to emphasize your data and information with HTML style tags.
What we’ll learn today: Rails is an MVC (Model-View-Controller) framework for Ruby. Once you understand how data flows you will have a greater ability of how to build a user-friendly application with CRUD (Create-Read-Update_Delete) functionality. We will also cover how Ruby works with numbers to do arithmetic and why a float would be important if you are working with percentages. Our HTML workshop will show you how to beautify your apps with images.
What we’ll learn today: Our focus will be on the Model (M of our MVC framework). The model represents data. Understanding how to create relationships with our models is vital to the process of requesting information from the database. Ruby methods are important building blocks that will be found throughout your applications. They are used to create functionality. Web developer tools allow you to quickly manipulate your CSS to see changes in real time.
What we’ll learn today: Authentication is the process that allows a user to register, login, and logout of an application. In Ruby we will focus on process and lambdas and how lambdas might be the better choice for capturing the data we want. For front end design we will discover how classes can help you reuse your code and the limits of ids.
What we’ll learn today: Controllers (the C of MVC framework) are essentially a ruby class that store a series of actions (methods) that need to be performed. Controllers manage our data by communicating with the routing engine of our app. (Controllers make sure there is Blog data in your blog page and not your about page). Our Ruby focus will be loops and how they easily apply the same code to multiple items. CSS (cascading style sheets) will introduce you to ways you can give your app a unique look and feel.
What we’ll learn today: Views (V of MVC) are what the user can actually see. We will discover some best practices for keeping our views DRY and how we can make them effective and dynamic. In Ruby we will discover how .map could be helpful when dealing with APIs. We will look at how using CSS animations can bring emphasis to a portion of a webpage.
What we’ll learn today: Byebug is a powerful tool to discover why your code is breaking. Debugging is a skill that employers are looking for when they hire developers. We will also cover some advanced CSS styling that will improve the user experience of your website/app.
What we’ll learn today: At it’s heart a ruby gem is just ruby code! Utilizing gems can help you build your applications more quickly and more efficiently. You can even build your own gem for code you will utilize in multiple applications. Understanding how to elegantly display tabular data will help you as you build user dashboards or display data such as inventories.
What we’ll learn today: Authorization is a way of granting permissions to different users in your application. You wouldn’t want customers to be able to update inventory values, or users to edit your blog content. The Petergate gem will help you integrate this authorization. In Ruby we will take a look at the Hash data structure and how the key value pairs make parsing data so much more flexible. We will also take a discover even more ways to present tabular data with HTML styling.
What we’ll learn today: Today we will being to implement styling into our project using the Bootstrap Framework. We can use a template as a jumping off point for our three layouts to get us started more quickly. In Ruby we will address Conditionals. Conditionals allow programs to make decisions based on varying data (eg: If the user is not logged in they can not leave comments on the blog). Our time with HTML will focus on forms. User friendly forms make for a better user experience.
What we’ll learn today: Images and Videos are dynamic and powerful ways to add content to your applications. Today we will discover the best practices for adding this media to your rails project. A will continue to cover the topic of OOP. Everything in Ruby is an object so a firm understanding of OOP is essential to a Ruby developer. We will take a look at the solutions to our google home page assignment and refine those skills for future use.
What we’ll learn today: As you become a more seasoned developer you will begin the use the lib directory (library) more and more. It is a place to store custom modules that can be used through the rest of your app. By placing these modules in the lib you will isolate them, which protects your application from buggy behavior. In Ruby we will take a look at regular expressions and how they can help us capture valid data. We will also discover the benefits of grep when searching through collections. We will rev up our css course work by cloning the Tesla home page.
What we’ll learn today: Rails 5 has given us an exciting new feature called Action Cable. It gives us the ability to use share live data in a much easier way than ever before. Understanding how to implement this powerful component will give your app serious street cred. In Ruby we will take a look at researching gems and introduce a lightweight alternative to Rails. Knowing how to build HTML emails, will give you the ability to create custom emails that can be sent from your app.
What we’ll learn today: Best practices and refactoring refine your code and make your applications run smoothly. Garnering data from APIs is an essential skill in today’s world of up to the minute news and information. We will begin building a social networking site that is fully responsive. It is crucial to understand responsive design when apps are being used across numerous devices with varying screen sizes.
What we’ll learn today: Local host is a great tool for development. Today you will learn how about Heroku and how to deploy your app live on the world wide web. In ruby will take a look at Big Data Analysis (the ability to crunch huge numbers of data efficiently to generate behavior-based decision making). We will spend more time developing our social network app and honing the skills the will give your web pages a polished and professional look and feel.
Workshop Build a Social Network Using the Bootstrap Framework
Writing or Screencast Assignment Due
What we’ll learn today: Angular is a popular front-end framework used by developers. The newest release, Angular 2, was written with the TypeScript programming language. Learning TypeScript is a prerequisite to learning how to build Rails/Angular2 Apps . We will start building a real world Rails app beginning with a planning session and exploring test driven development (failure that leads to success). In Ruby we will delve into algorithms and computer science. These concepts will give you the tools to start building more advanced programs.
What we’ll learn today: We will continue to develop on our real world app by incorporating BDD--Behavior Driven Development. BDD is a set of best practices for writing tests, and focuses on the behavior driving the code by incorporating user stories. (Ex: The user needs to be able to log in). In Ruby we will discuss algorithms and why choices for how we sort through large amounts of data are critical to app creation.
What we’ll learn today: Today we will begin setting up our rigs by installing typescript. We will focus on some front-end development for our app. We will also refactor some of our code which is key to developing a professional product. In Ruby we will take a look at an alternative to bubble sort and discover why quick sort is a better choice.
What we’ll learn today: We will continue our TypeScript setup by implementing a Microsoft plugin that will make using .ts files in sublime more intuitive. We will also write a quintessential “Hello World” app using TS. We will add the Factory Girl gem to our project so we can use factory data to test our code. We will work on CRUD functionality as well. In Ruby we will take a look at the merge sort algorithm and why the intuitive nature of this sorting method makes it popular even though it takes a bit longer than quick sort.
What we’ll learn today: We will look at TS variables and the subtle yet important differences between ‘var' and ‘let'. We will also explore DS data types and how the ‘any’ datatype will help with API’ data. Integrating GROWL notifications will add finesse to our app, especially when making the user aware of form validations. We will use a gem to add an administrative dashboard to our app. Dashboards are great tools for data visualization. Using the Ruby prime module can greatly reduce the amount of code you need to write when dealing with prime numbers.
What we’ll learn today: Our TS exercises will focus on Alias & Union types. These concepts are building blocks we will need to implement Angular 2. Customization of our admin dashboard will make the search feature usable and inhibit non admin users from gaining access. Our Ruby exercise will show how we can leverage this powerful language to calculate complex math problems in a single line of code.
What we’ll learn today: We will build out our TS knowledge to include compound conditionals and how they can help us write fewer lines of code. For our app project we will build out more functionality while practicing BDD. We will also add the pundit gem, which is a great interface for user permissions. In Ruby we will discover the humanize gem, which converts numbers to strings, using words!
What we’ll learn today: In TS we will learn the important difference between for in / for of loops — the subtle difference allows us to gather varied type of data. We will also look at basic TS functions, which are critical to understand before we go on to more in-depth topics. For our project we will implement more functionality with growl, refactor integration testing and build a view helper to show the stylized status of a table item. In Ruby we will look at the ‘date’ library. We will discover what tools to utilize to make working with dates more manageable.
What we’ll learn today: Today we will explore more syntax and structure in TS which will help us apply different types of arguments to our functions. In our project we will implement pundit permissions. We will also add better performance to our app with the Puma (web server) gem and work on styling our app for an improved user experience. We will do some fun math sequencing in Ruby by creating a fibonacci counter.
What we’ll learn today: We will continue to expand our TS foundations to be better prepared to understand ‘closures’ by examining immediately invoked functions and arguments. In our project will will leverage the Twilio API gem to implement an interface for sending SMS (text) messages, and learn how to protect our API credentials. In Ruby we will study an algorithm that will help us with permutations—which has to do with arranging sequences.
What we’ll learn today: We will examine closures and how they can encapsulate data & behavior in one object. Note: closures are used throughout Angular 2. In our project we will finish out the functionality for sending text messages. Our algorithm study today will be all about amicable numbers.
What we’ll learn today: Our TS time will introduce classes and inheritance. This should feel familiar to other OOP topics we have covered. We will add a new tab to the interface of our project for the Audit log. Challenge yourself to build a factorial digit sum with the knowlege you have accumulated.
What we’ll learn today: TS interfaces will be explored. Interfaces are the set of rules that an object has to follow. They are closely aligned with what we will be using when we start building Angular 2 apps. We will continue with our app by building out the audit log and reviewing concepts / tools we will use in future projects. In Ruby we will once again visit Fibonacci and work on another algorithm.
What we’ll learn today: Our TS time will bring together classes and interfaces to show us how to build functional programs. We will also explore namespacing and how it gives you the ability to nest items and organize code. In our app we will use the Kaminari gem to create pagination—a way to send the users from page to page to peruse large amounts of data We will also round out the dashboard homepage. In our Ruby portion we will look at the power of functional methods to make coding easier and more enjoyable.
What we’ll learn today: Today we will look at Asynchronous behavior, which allows for you to run multiple processes at the same time. We will also cover how to avoid issues with the ‘this’ construct in TypeScript and address scoping issues. In our project we will build out the functionality for the employee side of the app. We will also make the app more intuitive by using a callback called after_save. We will take a closer look at computer science and begin our algorithm workshop.
What we’ll learn today: We will take a deeper look at Asynchronous behavior in TS with higher order functions, which allow you to load various page elements while doing a database query. Our project would not be complete without the ability to send emails. We will deploy to Heroku and implement the Scheduler tool for running our automated tasks, such as sending weekly texts and daily emails. We will consider the importance of arrays to developing any program of significance.
What we’ll learn today: We will walk thru how promises work in TS, including the concepts of Pending, Resolve, and Reject. You could use promises when working with APIs. In our project we will round out the sms messaging including setting up the spark post email server. We will continue our algorithms workshop with more focus on arrays and how to add / remove items with the push / delete methods.
What we’ll learn today: In TS we will introduce decorators — a specialized function declaration we will use throughout Angular 2 apps. For our project we will do some planning to address issues that need to be addressed. We will also be making some updates- refactoring is an integral part of creating apps that work smoothly and contain code that is easily updateable. In our algorithm studies we will explore the differences between Queue and Stack data structures and why it is so critical to understand how they perform.
What we’ll learn today: We will explore class and method decorators as further preparation to work with Ang 2. In our project we will do more refactoring. We will make buttons responsive so that our app will work across devices, address the nav view for different users and fix bugs. In our Algorithm studies we will look at linked lists and how they allow for efficient shuffling of values. We will also explore the parent child structure elements in the Tree data structure.
What we’ll learn today: We will take a look at a real world implementation of a decorator in an Angular 2 app. We will look at two add-ons for your app. First is HoneyBadger, which will help you manage errors in deployment and more efficiently and quickly fix your apps. (This is a paid service you will likely want to use in the future). New Relic will ping your app and keep your site alive. For our algorithm workshop we will look at the operations used by the tree data structure. Understanding these concepts is key for the coding portion of your job interviews. We will also discuss tree data structure terminology, which is the basis to understanding how trees can be used.
What we’ll learn today: We will have an overview of Metaprogramming — the ability to open up classes and override existing methods to give your applications custom behavior. We will begin a new project using Rails and Angluar 2: The Freelancer Dashboard. This project will bring together three apps to make a unified architecture. We will explore the pieces that will bring this architecture together, and configure our systems to run the Angular 2 app. We will also look at the benefits of learning with the reverse note taking technique.
What we’ll learn today: Today we will begin generating our Angluar 2 app. We will take a look at a tool called Browser Sync and how it allows us to see what is happening in our app without having to refresh the page. We will also determine why the console in the web developer tools will be essential to solving errors in angular. We will get our first look at the best practice for creating Ang 2 routes and create our first view.
What we’ll learn today: Discovering the flexibility of using metaprogramming to create a custom class in Ruby will be our first task. As we start building our app it is important to remember to take things “One step at at time”. We will uncover some of the “angular secret sauce” and build out some important base components.
What we’ll learn today: We will continue to build out the Angular portion of our project taking a close look at ngModel and two-way data binding which allows for content to change on screen in real time. We will also implement validations for our forms to dynamically show users when there is an error.
What we’ll learn today: We will take a deeper and more practical look at metaprogramming by identifying ways we can open and customize the string class and why self is an important keyword in this process. We will continue to develop our app by discovering how to create a ‘show’ component that will look up a record based on the ID then create the functionality to do so. We will also begin to implement styling with ngBootstrap and look at how we can add css classes to dynamically show which page is active.
What we’ll learn today: Our first guide will take us to the ruby console where we can see how the find_by method uses metaprogramming to allow you to dynamically use database fields to source data. For our project, we will focus on styling. We will look at a new option in Bootstrap 4 called a card. This malleable display feature can help give your content context and focus. We will investigate global styling (will apply to the whole app) vs component styling (will apply to a single component) in angular. We will give our validations a more polished look.
What we’ll learn today: We will work on the angular portion of our project by adding a bit more styling to forms and lists. Angular has some awesome built in formatting options called pipes, one of which will display our currency/pricing without having to hard code items that can make your code messy and possibly lead to errors. We will begin the rails application of our project my creating the micro service for our documents by generating a Rails 5 API.
What we’ll learn today: We will look at an advanced Ruby concept: the metaprogramming construct of method_missing, which allows you to create code that writes code! For our project we will create a service for managing our API data. A service is a ‘layer’ that creates the needed separation between our component and the API. We will take a look an Observable. Observers are a part of asynchronous development that give you the ability to set up ‘streams' in your application. We will set up our angular 2 app to render the API data—this is a great tool to understand as professional developers are often called on to create connections to APIs.
What we’ll learn today: We will finish up our document component and begin work on the rails microservice for the proposal component by generating our api only app and scaffolding it out. We will use the proposal service so that our show page will populate with data from our API. We will also add the submit button to our proposal component and require the form to be valid for the button to work.
What we’ll learn today: For our metaprogramming guide we will review the drawback of using method_missing in correspondence to the respond_to? method and create a template that will allow us to use best practices and properly execute with method_missing. You will be challenged to think of the steps to creating new records in your Rails micro service via API posts requests. We will add the final feature of emailing your proposals from your site, and finish out the project.
What we’ll learn today: We will learn about the metaprogramming mechanism called define_method which you can use to keep your code DRY and create methods at runtime when you know the method names you want to use. You will begin work on your capstone project. We will also take a look at a guide to choosing which Web Server will be best to run your application.
What we’ll learn today: You will focus on development of your capstone project.
What we’ll learn today: You will continue work on your capstone project. We will have some review with a beginners guide to metaprogramming including the dangers of monkey patching and the appropriate use for this tool.
What we’ll learn today: You will spend your time building out your app.
What we’ll learn today: The focus will be your capstone project. We will explore JSON parsing. JSON is a universal data form designed to be used across all languages and frameworks. We will look at some real world examples and a great tool for capturing the API data we want.