rail by rail @coderoad - Tumblr Blog

App Academy Works!

I’ve been MIA from this blog for some time now because of a whirlwind of new developments have kept me extremely busy. However, I’ve heard from many people that they reviewed my blog and it was a factor in their decision to attend App Academy. I decided to provide everyone an update with details of how things went from the final week of App Academy to the present day.

FINAL PROJECTS AND PORTFOLIO

The final weeks of App Academy involved creating a final project and polishing up a few portfolio pieces so you can demonstrate to employers what you have built. For me this meant almost 40 days of continuous pushes to github! It was extremely hard work but also a lot of fun to put everything we learned to good use. Here’s the fruits my labor:

PINLY. Pinly is a pinterest clone that I developed using Rails (backend) and Backbone on the client side. It’s a single page application which allows users to view, search, and upload visual bookmarks. It has tons of features including push notifications, drag and drop image uploads, comments, likes, and infinite scrolling.

SUPER TETRIS. A clone of the classic Tetris arcade game. The game does extensive manipulation of the HTML5 canvas element and the game logic is entirely built in JavaScript. Again, I implemented a bunch of features that take this clone above the typical fare you find on the internet: persistent highscore table using ajax calls to the database, particle explosions, bitmap fonts, sound effects, and an awesome retro design.

TRELLINO. A clone of the popular task management tool, Trello. Try logging in with the guest account and dragging and dropping the cards and lists around!

PORTFOLIO. My portfolio page with information about my background, skills, and final projects (many of which I described above).

These are only a subset of the projects I worked on but I think they serve to show how far I’ve come from when I first started this process in December of 2014. At that time, the extent of my knowledge was limited to simple command line ruby apps. Things have certainly changed!

I think all the hard work was worth it because... I LANDED A JOB.

I have been gainfully employed with an awesome web and mobile application development agency called substantial. Everyone is incredibly cool at this company; they’re passionate about making great products and they really value employee happiness. Interestingly, none of the projects I’ve worked on to date have used the tech stack that I learned so deeply at App Academy (Rails + Backbone). So far, I’ve worked with Node, React, CoffeeScript, Angular. Soon, I’ll be developing a native Android application using Java. As it turns out, none of this matters. The fundamentals you learn at App Academy carry over to whatever platform you develop on. The rest is just syntax (which you can always google or read about!). Anyway, thanks for reading! If you are interested in joining App Academy, feel free to shoot me an e-mail (arora dot nick at gmail dot com) and I’d be happy to answer any questions! Furthermore, if you don’t mind helping a guy out, please use my referral link when you sign up.

#app academy

Backbone / Backbreaking Labor

We've been worked to the bone here at App Academy. Assessment tomorrow then final projects begin. Unfortunately this means, once again, I won't have time to do a proper blog post. However, in lieu of that, I've uploaded an animated gif of my Trello Clone. Enjoy.

Status Update

My posts have been growing increasingly terse as the level of busyness around here has increased. To give a brief status update, we are knee-deep in developing a clone of Trello using Backbone layered on top of Rails. Furthermore, I spent a significant part of this weekend planning the database schema and wire-framing the various views for our final project. More information to come!

#app academy

RSS and Zombies

We continued our exploration of Backbone in class by building an RSS feeder from the ground up. Interestingly, this project utilized composite views which required careful attention to how we handled the "#remove" method. While normally calling remove on a view object in Backbone would sufficient to silence its listeners, if a view contains other views, they may live on as "zombie" views. As zombies, their listeners will continue to be triggered despite their view being removed from the page! The best way to prevent this situation from becoming an issue is to iterate over each subview and remove it manually.

#app academy #backbone #composite views

Week 7 Day 3

Today we built a simple CRUD application in backbone from the ground up:

In Rails: Routes, Models, Controllers (rendering JSON)

In BackBone: Models, Collections, Views, Templates, and Routes.

Along the way we also implemented event handlers, Backbone collection/model listeners, call backs, composite views, and elegant view swaps.

#app academy #backbone #rails

Backbone on Rails: Part II

As mentioned earlier this is a continuation of a multi-part series where I describe integrating Backbone and Rails to create a single-page CRUD application. You should probably start with part 1, if you just joined.

Where we left off last time, we were in the process of configuring rails to work with Backbone. There a few final steps in that regard:

Step 2: Install and Require the Necessary Libraries

Inside of vendor/assets/javascripts, you'll want to download and install three libraries: backbone.js, underscore.js, and jquery.serializeJSON.

Backbone.js provides the framework that we are integrating. Underscore was written by the creator of backbone, and the two were designed to be used in unison. Underscore is a utility library which adds many features which make working with JavaScript feel more like ruby (particularly with regard to array manipulation!). In addition, it contains a template feature which we will be using as we progress. Finally, the Serialize JSON library is relatively unknown but it will help us work with forms later on.

The final step is to update app/assets/javascripts/application.js to ensure that these files are integrated into our final application. The final lines of your file should look something like this:

//= require jquery //= require jquery_ujs //= require jquery.serializeJSON //= require underscore //= require backbone //= require marked //= require myAppName // references file we created in the last blogpost

Let's be a little forward, thinking and require a few JS files we haven't written yet – but soon will – while we are here. Add these to the bottom of the list:

//= require_tree ./models //= require_tree ./collections //= require_tree ../templates //= require_tree ./views //= require_tree ./routers

Step 3: Setting up Models and Collections

Okay. Now its time to get down to business. Backbone's Model has similarities to the Model in Rails. Both act as an Object/Relational Mapping (ORM) layer; in other words, they provide an object-oriented approach to interacting with the database.

Like in rails, table columns map to attributes in Backbone's Model class. Furthermore, just like in Rails, instances of the Model class map to rows in the database.

To create and save an instance of a post in Rails, you might write:

new_post = Post.new new_post.title = “Hello World!” new_post.body = “My First Post!” new_post.save!

In Backbone, the same functionality would be written like so:

newPost = new App.Models.Post(); newPost.set({ title: “Hello World!”, body: “My First Post!” }); newPost.save({}, { success: function(){ /* ... */ } });

There are some clear parallels here.

However, unlike Rails, the Model class itself does not map to the table as a whole. In Rails, you could use a class method like Post.allto retrieve an array of all rows in the database. No such luxury here. In Backbone, a separate class, known as a Collection, maps to the table as a whole.

There are additional complications, none of which make interacting with the database any easier. Collections are just not as “smart” as the class-methods baked into the Models in Rails. They have no awareness of “associations” and they have trouble parsing nested attributes (which they will receive from rails in JSON format). Consequently, you have to write this functionality yourself.

Finally, and most importantly, it is important to remember that Backbone's ORM layer (both models and collections) are asynchroneous, unlike Rails which is synchronous. This means that that by default, Backbone collections and models will not be populated with data from the database. You must use the fetch method to fill them with the relevant data. Furthermore, even after you call the fetch method, you won't have immediate access to your data – despite the fact that your code will continue to execute. For this reason, you'll have to set callbacks to handle the data once it is populated.

Keeping the above in mind, let's take a look at how we might set up our Models and Collections in Backbone:

./models/postModel.js

App.Models.Post = Backbone.Model.extend({ urlRoot: "/posts", // tells Backbone where to find // our Rails controller // posts have many comments. We must write // this association ourself comments: function () { // memoize comments collection this._comments = this._comments || new App.Collections.PostComments([], { post: this }); return this._comments; }, // our app will have trouble parsing the nested comment // attribute that we built in the prior blog post. Here, we // sort that out. parse: function (payload) { if (payload.comments) { // store and delete this.comments().set(payload.comments, { parse: true }); delete payload.comments; } return payload; } });

./models/commentModel.js

App.Models.Comment = Backbone.Model.extend({ urlRoot: "/comments", // url for rails controller });

./collections/postCollections.js

App.Collections.Posts = Backbone.Collection.extend({ model: App.Models.Post, url: "/posts" // url of index });

./collections/postCommentsCollections.js

App.Collections.PostComments = Backbone.Collection.extend({ model: App.Models.Comment, url: function () { // comments has a nested index route return this.post.url() + "/comments"; }, initialize: function (models, options) { // set the associated post this.post = options.post; } });

Thanks for reading. Next time we'll discuss Views!

#app academy #backbone #rails

Backbone on Rails: Part I

This is part one of a multi-part series where I'll discuss combining two powerful frameworks: Backbone.js and Ruby on Rails! Let's start with the basics: what exactly is Backbone and why would would we want to combine it with rails?

Unlike Ruby on Rails, Backbone is not a server side framework. Backbone, by contrast, is a client side framework, meaning all of the heavy lifting is done in the web-browser! There are several benefits to using a client-side framework:

Speed! With rails, every new page/template requires that you make an HTTP request to the server. The entire page refreshes, and the user sees new content. With backbone, you can quickly and easily issue AJAX requests which process in the background. Parts of the page (or even the entire page) can be updated without the user every experiencing a lag or delay in performance. The ultimate result is you get the feel of a desktop application – on a website. This is huge!

JavaScript (which is the primary means we create fast, interactive applications that run in the browser) can quickly become disorganized and lengthy. You don't want to end up in callback hell. Backbone, by contrast, provides a clean MVC architecture. You can separate your data/logic from presentation and Backbone's associated “underscore” library to further DRY up code.

Backbone simplifies event handling. Backbone uses what's called “declarative” event handling so that you can avoid writing spaghetti bind calls. You can declare which callbacks need to be associated with what specific events. Furthermore, Backbone allows you to listen for changes to the model – and update views automatically. Pretty cool!

We can augment the power of Backbone by using Rails on the backend, to handle interactions with the database. Our ultimate goal is the power and ease of use of Rails' ActiveRecord combined with the speed and responsiveness of Backbone. Let's get on it with it!

Step 1: Reorganize Rails

In order to get Backbone to play with Rails, we'll need to make adjustments to our existing Rails app. Let's start by reorganizing our routes. We'll want to add an important option to config/routes.rb – we'll want to set the default value of the attribute :format to :json.

Remember, Backbone will now be handling what the user sees. We no longer want Rails to utilize its “views” in the traditional sense. Here's what your routes file might look like:

root to: 'static_pages#root' resources( :posts, defaults: {format: :json}, only: [:create, :destroy, :index, :show, :update] ) do resources(:comments, only: :index) end resources( :comments, defaults: {format: :json}, only: [:create, :destroy] )

JSON is how backbone and Rails will communicate so it makes sense that the default output of index,create, update, patch, etc. requests is in JSON.

However, rather than simply using the built in render json functionality that comes with Rails, it is often beneficial to specify precisely how you would like to format the data that Backbone will be working with.

This is easily accomplished using the jBuilder gem (developed by the creators of rails). Using this library, you can continue to tell your controller to render 'show'or render 'index'; Rails will know to seek out .json.jbuilder templates which live in your views directory. The jBuilder documentation does a great job explaining its usage.

Here's typical usage, you might find for a 'show' page which renders a single Model instance in JSON

json.extract!(@post, :id, :title, :body)

For the index page, which renders an array of Model instances, you can use jBuilder's #array! method:

json.array!(@posts) do |post| json.extract!(post, :id, :title, :body) end

Finally, if you'd like to nest associated model instances into your JSON output, you would simply add a second line. For example, for a post with many comments:

json.extract!(@post, :id, :title, :body) json.comments do json.array!(@post.comments) do |comment| json.extract!(comment, :id, :body, :post_id) end end

Next, create a new JavaScript file in app/assets/javascripts -- myAppName.js We'll use this javaScript file to create a JS namespace and to hold the various MVC objects we'll be using as we dive deeper into Backbone. All of our code moving forward will live under the App global variable.

window.App = { Collections: {}, Models: {}, Routers: {}, Views: {} }

We'll explore each of the above four items in detail in the next few upcoming posts. Thanks for reading – 'til next time.

#app academy #javascript #backbone #rails

AJAX Adventures

Sometimes you don't expect a redirect. For example, if you are browsing your twitter and you decide to follow Kim Kardashian's twitter feed, you don't really expect the page to redirect you anywhere. You just expect the “Follow” button to change in some way (replaced with “Unfollow” for instance) and her feed to be added to your list shortly thereafter.

The way we can achieve this is through HTTP requests made in the background, also known as a AJAX Request. Although AJAX functionality is provided by most major browsers, each implements it in a different way. Fortunately, jQuery unifies this process and gives a single API that we can work with.

The $.ajax method in particular will allow us to do almost anything we need to do.

One common pattern is to provide the .ajax method an object as an argument which contains some vital information for the AJAX request to be performed appropriately.

In particular, the request will need information such as:

URL: The url to visit (formatted as a string)

DataType: The format we would like AJAX to communicate in (typically 'json')

Type: What type of HTTP request we are making ('GET', 'POST', etc.). By default #ajax assumes you are making a get request.

Callbacks (success and error): Tell the AJAX request what to do in the event that the request is successful or in the event that it fails.

There are many more attributes you can add as well. Here is what a typical AJAX request may look like:

$.ajax( '/data/people.json', { type: 'GET', dataType: 'json', success: function( resp ) { console.log( resp.people ); }, error: function( req, status, err ) { console.log( 'something went wrong', status, err ); } });

Thanks for reading!

#app academy #ajax #jquery

DIY jQuery Plugins

Previously, I discussed how jQuery makes the process of interacting and updating DOM elements on a website incredibly easy and intuitive (as well as some of its other benefits). However, more commonly, jQuery is associated with many of the nifty tooltips, light-boxes, carousels, and widgets you see populating modern websites. These widgets can greatly enhance user experience.

Many widgets are built by creative developers and (often) are free to use and download. However, if you'd prefer to write your own widgets using the jQuery user interface, there is nothing stopping you!

Today's blog post will cover a few steps associated with building custom jQuery plugins.

Let's assume we want to build a jQuery plugin that colors text green. The API should look like this:

Let's begin writing the associated JavaScript:

Step 1: Wrap Your Code in an IIFE

Because we are using jQuery's $ namespace, we'lll have to change our standard IIFE to work with jQuery. The code below works:

(function($){ // awesome code })(jQuery);

Step 2: Take responsibility for Iterating over Passed in Elements

jQuery is funny in that it is all about implicit iterations. You never need to explicitly tell a jQuery method to iterate over all the items it finds. It just does it -- unless you are building a plugin. As the creator of the method, it is your job to handle the iteration that everyone else takes for granted. Have your API method use jQuery's #each method to iterate over all DOM elements passed in:

$.fn.greenify = function(){ return this.each(function(){ new $.Greenify(this); //html element }); }

This code may seem funny at first. We iterate over each element passed in then we create an instance of a Greenify object with the argument this. The first thing you must understand is that this inside of jQuery's #each method refers to an unwrapped html element. Secondly, we are creating an instance of a Greenify object because, by convention, this is how plugins handle the work associated with manipulating the DOM.

Step 3: Create your Class and Wrap your Input

Now we are ready to do the work of the plugin itself. We start by creating an empty class which accepts our unwrapped html element.

$.Greenify = function(el){ /* ... */ };

As noted above, the element we pass in is not a jQuery object. jQuery's #each method does not return jQuery objects. If we want to manipulate it with ease, we'll want to transform it first:

$.Greenify = function(el){ this.$el = $(el); };

Step 4: Do the Work

Finally, we can begin manipulating our element in anyway we see fit. Today's example is ridiculously simple. However, you can create animated slideshows, fancy transitions, creative popups, interactions with mouseovers and clicks at this stage. The sky is the limit. We set out to change the color's text to green:

$.Greenify = function(el){ this.$el = $(el); this.$el.css('color', 'green'); };

That's all there is to it! Check out this link learn more about what's possible with jQuery plugins (and to inspire yourself). Thanks for reading.

#app academy #jquery #plugins

Four Awesome Uses of jQuery

Selecting DOM Elements

User jQuery to pull an array of all elements which match your chosen CSS selector.

$(".my-class")

To select elements which have more than one CSS selector, simply chain them without adding a space -- like so:

$(".my-class.my-other-class")

To select elements with either one CSS selector or another use a comma!

$(".my-class, .my-other-class")

Create New HTML Elements

You can use jQuery to create elements then append it parts of your existing HTML. jQuery's advanced features let you add classes, customize css, etc. prior to appending:

$newEl = $("<div>Who Let the Dogs Out?</div>"); $newEl.addClass('terrible-song'); $newEl.css('background-color', 'blue'); $('body').append($newEl);

Wrap Native DOM Elements

You can wrap native DOM elements in $() in order to transform the element into a jQuery object. This means you get a multitude of methods at your disposal which allow you to manipulate the HTML with ease.

Ready Style

By wrapping your inline JavaScript in an anonymous function which itself is wrapped in jQuery ($()), you can force your browser to only run the script once all of the DOM elements are loaded. Here's the syntax:

Thanks for reading.

#app academy #jquery #javascript

More JavaScript Fun

Busy day today! So much to code and read! Also an assessment coming up. To make up for my short post, here's an animated gif showing a very very basic asteroids clone we made in class. I plan to make significant upgrades to this thing:

If you'd like to play it in it's current form, check out: http://nickarora.com/projects/asteroids/

#app academy #javascript

Don't by IFFY about IIFEs

There have been quite a few developments in the JavaScript world in recent years: script loaders, frameworks, coffee-script, etc. However, before diving head-first into this brave new world, it is important to start by nailing down some of the most practical, beneficial modern practices.

In particular: Take steps to avoid polluting the Global Namespace

If you open up your JavaScript source file and it starts with the keyword var, then (unfortunately) you're probably doing it wrong. When you write code like this, you are shoving all of your methods, variables, and objects directly into the global namespace -- accessible to all and potentially creating conflicts with other JavaScript applications. We need to find a way to shield our applications from this situation.

Enter Immediately Invoked Function Expressions:

(function(){ // your fancy-pants code })();

IIFEs look strange at first but are simple to understand. We have an anonymous function, wrapped in parenthesis, that's being called. We are basically creating a nameless function, transforming it into an expression, and immediately invoking it.

So why take this step? In JavaScript the only way to limit scope is by creating a function. All variables created inside of that beast will be shielded from the Global Namespace.

Great! But one big problem: we need a way for the browser or other JavaScript files to access our application's API. We've done such a good job shielding our methods, the application has no point of contact with the outside world.

We can fix this by assigning part of our application to the window object:

(function(){ if (typeof MyAppName === "undefined") { window.MyAppName = {}; } var MyObject = MyAppName.MyObject = function () { // awesome code } // . . . })();

In essence, we declare the functions, methods, objects, and variables that we want accessible under our custom window object. You can, in fact, have multiple window objects, and group assignment to these objects based on their functionality. Each window object is typically referred to as a namespace.

Finally, I note that there are easier ways to accomplish the above -- however my hope was only to convey the basic idea. I hope this helps. Thanks for reading.

#app academy #namespace #iife

Closures and Callbacks!

Today I'd like two snippets of interrelated code and discuss them. We were asked to recreate the functionality of two ubiquitous ruby functions using JavaScript: .each and .map.

Take a look at the snippets below:

Array.prototype.myEach = function( func ) { for(var i = 0; i < this.length; i++){ func(this[i]); } };

Array.prototype.myMap = function( func ) { var result = []; this.myEach( function(el){ result.push(func(el)); }); return result; };

The code functions as you would expect, however viewing the code through ruby colored-glasses it may be difficult to dissect what exactly is going on. Why does myEach not have a return value? Why does myMap pass an anonymous function? How does myEach get access to the result array?

Let's break it down:

myEach is a simple function which takes a different function as an argument. my Each iterates through each element of the array and runs the passed in function once per element. There is no return value -- it just does the work then takes a vacation.

myMap starts by defining a local variable result. result is an empty array that will hold the results of myMap's activities.

myMap's goal is to function much like the .map method functions in ruby. It will iterate over each element in the array, manipulate the element, and store the manipulated element in a new array -- for eventual return.

Our desire here is to use myEach to take care of iterating over each element and calling our desired element. Our problem is that myEach doesn't SAVE the results of its efforts. How do we get around this?

The answer: closures. A closure is a function that has access to variables that it does not define and have not been passed to it.

Here, the anonymous function we pass to myEach is defined within myMap. Consequently, it has access to variables defined in myMap's scope -- specifically the result variable! (through a closure)

Therefore, we can use the anonymous function to instruct myEach to not only run the desired function on each element in the array -- but to push the calculations into result while it's at it.

Here's the resulting code and en example of the output:

var timesTwo = function(n) { return (n * 2); } newArr = [1,2,3].myMap(timesTwo); // newArr = [2,4,6]

Thanks for reading! I hope this helps.

#app academy closures callbacks javascript

JavaScript Objects

JavaScript is an extremely flexible object-oriented language that has evolved over time. Functionality from the past lives side by side with new functionality that is being added on a daily basis.

Part of that flexibility means you get options. Below I discuss two ways that you can define and instantiate an object in JavaScript!

1. Using Constructor Functions

The most common method for constructing object is through a combination of a function and the keyword new. Below is a simple example:

var Cat = function(name, color){ this.name = name; this.color = color; // methods can be added to the object here // however it is not recommended -- see below! this.meow = function() { console.log("meow!"); }; };

Once the object has been defined, you can call a constructor function to instantiate each Cat.

var cat1 = new Cat('Garfield', 'orange'); cat1.meow(); // logs "meow!" to the console

As mentioned above, the function meow can be defined within our definition of Cat. However, this is not the recommended approach. Instead, it is almost always preferable to add the object's methods to the object's prototype instead.

Each cat-instance doesn't need its own methods saved in memory. Instead, methods can be stored to the Cat object's prototype -- in a single location which is accessible to all instances of cat. Wherever possible use this inexpensive approach instead:

Cat.prototype.meow = function() { console.log("meow!"); };

2. Using Object Literals

Using object literals, you can skip the class definition and constructor function entirely and skip directly to creating an instance of your desired object. The below code instantiates code identical to the above quickly and effortlessly:

var cat1 = { name: "Garfield", color: "Orange", meow: function(){ console.log("meow!"); } };

This may be a desirable approach where you only need a single instance of the object -- singletons!

Thanks for reading! Be sure to practice safe JavaScript!

#app academy #javascript #objects #constructor function #singleton #object literal

Everything you need to know about html_safe

When using embedded erb tags to display content on your rails website, there will be occasions where you’ll want to wrap instance variables in html code. Rails uses the SafeBuffer object to help deal with this code and some of the potential pitfalls. Let’s walk through how SafeBuffer and #html_safe work.

By default, all strings embedded into erb tags will be “escaped” — in other words, the html tags in the string will be replaced with harmless characters. For example:

<%= '<br />' %>

Would appear as follows in the resulting html document:

<br /&gt

You can modify this behavior by calling the #html_safe method on the string. In essence, #html_safe tells the browser that you’ve vetted the string and approve of its contents.

<%= 'br />'.html_safe %>

Results in the following html:

<br />

Let’s see how this actually plays out in real life. A common area where we want to use an erb tag to display html is through a view helper method. In our view, we have the following line of code:

<%= greet_user(@user.username) %>

Which calls the following method:

def greet_user(username) "Greetings, <strong>#{username}</strong>!" end

Unfortunately, this code will not do what the code’s author likely expects. As explained above, all strings embedded in ERB tags are escaped in entirety by default. The resulting HTML would look like this:

Greetings, <strong>SweetBaby123</strong>!

Oops! That’s certainly not what we want. What if we modified our view helper method as follows:

def greet_user(username) "Greetings, <strong>#{username}</strong>!".html_safe end

if the username was SweetBaby123, the resulting HTML code would look like this:

Greetings, <strong>SweetBaby123</strong>!

That looks much better! BUT WAIT. Before you bust out the champaign on a job well done, you should be aware that the above view helper method has a major security pitfall!

If the user was malicious, he could potentially change his username to something dangerous — like an evil JS script! Because #html_safe was called in whole on the string, the malicious script would make it into a user’s browser with no push back from rails:

Greetings, <strong><script>EVIL_JAVA_SCRIPT</script></strong>!

This is not good!

So how do we solve the issue? When defining your view helpers, selectively use html_safe on the areas you KNOW are safe. Allow Ruby to automatically escape unverified content. See below for the right way to handle it:

def greet_user(username) html = "Greetings, <strong>".html_safe html << username html << "</strong>!".html_safe html end

With the above example, even if someone inserts a malicious script as their username, the code will be escaped and it will have no effect:

Greetings, <strong><script>EVIL_JAVA_SCRIPT</script></strong>!

I hope this helps! Stay Safe!

#app academy #html_safe #erb

Rails, magic, and metaprogramming

In an ongoing attempt to understand even the deepest recesses of Rails, we are now building a RailsLite, a clone of the Ruby on Rails framework.

The application requires that we create a WEBrick server to handle HTTP requests. In addition, the application renders responses, issues redirect requests, parses nested hashes submitted through query strings, recreates the "params" hash, parses information submitted through the body of a request, handles cookies, and associates routes with appropriate controllers/actions.

Projects of this nature are important because they help eradicate the notion of "magic" in programming. Often well developed frameworks appear to perform tasks as if by magic -- you stick input in a black box and you get a desired result. Today, we effectively tore the lid off the black box. Good riddance!

#app academy #rails #ruby on rails #metaprogramming

Another Day at A/a

Today at App Academy we used rails to build a "Goals" app. The App is designed for users to create public and private goals. Users can mark them complete and share their goals with other users (who can leave comments or click "like"). We used a layered, features approach to building the various components of the app: 1) Sessions and User Authentication 2) CRUD functionality for creating, updating, deleting, and completing goals 3) Using polymorphic associations to allow users to leave comments on either the user's page or each goal's show page and, finally, 4) "cheers" functionality which mimics the "like" feature in face-book.

It was an excellent project which reinforced many of the fundamentals of Rails we've been learning for the past few weeks. Tomorrow, we face a stringent assessment of our Rails knowledge; Accordingly, I'll have to keep this post short so I have time to review!

Before I go, I'd like to share a personal project I developed in JavaScript: Maze Solver. The underlying algorithm uses a depth-first recursion to generate each maze. A separate class is responsible for using a breadth-first search to find the shortest solution. Thanks for reading!

#app academy #rails #CRUD #polymorphic associations #javascript #depth first search #breadth first search

Trending Blogs

Recently Viewed Blogs

rail by rail