Learn Ember, Linux and Tachyons

Ember is a javascript framework that provides a rich set of tools for building modern web applications. Unlike many frameworks, Ember comes with opinions and a way of doing things so you aren't left with a ton of decisions to make about problems that have already been solved very well. Ember was designed from the start to deliver a productive and comfortable experience for you, the developer.

In this course you will learn what you need to know to get started building your own Ember we applications. From the absolute essentials like creating a new project with the Ember-CLI tools, templating, routing, and reusable components.



A JavaScript framework for creating ambitious web applications.

ember

Ember 2 Fundamentals

Components in Ember are great for reusing code throughout our application. We’ll see how each instance of an Ember component has isolated state and we can over ride as well as set default values.

In this lesson, we will learn how to make a simple, reusable component within an Ember application.

Create Simple Components in Ember

In this lesson, we learn how to create nested routes and templates in an Ember.js application, in addition to how to create nested routes and isolated templates.

Creating nested routes in Ember.js

In this lesson, we will learn how templates work within Ember and how to use HTMLBars. This lesson will cover the connection between controllers and templates and how to use actions within templates as well.

Ember Templating with HTMLBars

In this lesson, we will learn how to install Ember Inspector and use it to see the state of our application and debug it.

The Ember Inspector can be installed from the [Chrome Web Store](https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi). We will see how the inspector gives us access to information such as the routes available to us, the components used in a particular view, and data that is exposed to us etc.


Debug Ember Applications using Ember Inspector

In Ember.js, functions that are executed through user interaction with your application are called actions, which can be defined at the route, controller, or component level. In this tutorial, we look at a simple example of defining actions on the controller and hooking it up to our template in order to update properties on the controller.

Add user interaction to Ember.js apps using actions

We will learn how to install Ember-CLI and use it to create a new Ember project. We will also learn how to run the Ember project.

Create an Ember Project with the Ember-CLI

Vue (pronounced /vjuː/, like view) is a progressive framework for building user interfaces. Unlike other monolithic frameworks, Vue is designed from the ground up to be incrementally adoptable. The core library is focused on the view layer only, and is very easy to pick up and integrate with other libraries or existing projects. On the other hand, Vue is also perfectly capable of powering sophisticated Single-Page Applications when used in combination with modern tooling and supporting libraries.

You can easily add CSS libraries to Nuxt using `yarn` or `npm` to install them, then simply adding them to the `nuxt.config.js` so they're included in each page. Then all the classes will be available for use in all of your templates. This lesson walks your through installing a library then adding it to your `nuxt.config.js`.

Add CSS Libraries to Nuxt

In this lesson, we show how to specify a model for an Ember Route so its data can be displayed. 

Define Models for Routes in Ember

In this lesson we will create an `updateContent` method that sets the value of our `content` property to the current epoch timestamp. We need to call `toString()` on the `Date.now()` method in order to make TypeScript happy.

```
updateContent() {
  this.content = Date.now().toString()
}
```

We create a constructor that takes the options parameter, call `super(options)` and call into our `this.updateContent()` method.

```
constructor(options) {
  super(options)
  this.updateContent()
}
```

When we refresh our page we can see that the value of `content` is set to the epoch timestamp. 

To make the content really dynamic we use `setInterval()` to call into `updateContent` each second: `setInterval(() => this.updateContent(), 1000)`.

When we save our file we see that our content does not get updated anymore and when we check the console we see that we get an error telling us that: The 'content' property on the my-component component was changed after it had been rendered. The error also informs us that we should Use the @tracked decorator to mark this as a tracked property.

We add the @tracked decorator to our property, we import tracked from @glimmer/component and we refresh the page. We verify that `content` gets updated each second.

We change our `updateContent` to add our the timestamp to the array. When we use `this.items.push(this.content)` to achieve this we see that the list does not get updated. This is because the `@tracked` decorator only tracks the re-assignment of properties.

The way to get this working is by re-assigning our `items` array inside `updateContent`. We assign a new array, de-structure the current items array and add the new content.

```
this.items = [...this.items, this.content]
```



Use dynamic data in a GlimmerJS component

In this lesson, we will learn how to define routes within an Ember application and how to use them to navigate around your application. This lesson will cover the basics of routes and how we can use nested routes to display multiple templates at the same time. We can also cover redirect routes and manually forcing transitions through actions.

Define Routes in Ember 2.0 using Ember-CLI

In this lesson we will use the ember cli to generate a new component. Running `ember g glimmer-component my-component` generates the template and component class. We change the content of our component and add it to the main template in order to show it on the page.

Create a new GlimmerJS component

In this lesson we will add a variable called `content` to our component class, initialize it as a string and display the variable in our class using the double curly braces syntax, which is the handlebars expression for expressions, `{ {content }}`. 

After this we create a new class variable called `items`, initialize it as an array with strings. To display this list in our template we add a `<ul></ul>` and inside this unordered list we use the handlebars `each` helper to display the list items.

And inside our each statement we will print a `<li>` tag and render `{{ item}}` inside it.

```
<ul>
  {{#each items key="@index" as |item| }}
    <li>{{item}}</li> 
  {{/each}}
</ul>
```



Use template variables in a GlimmerJS component

Closure actions are useful for extending application code such as modifying a property on a controller while also sending up information from a component.
In this lesson, we learn how to use closure actions with Ember.js components. 

Use Closure Actions with Ember Components

Functional css for humans.

Quickly build and design new UI without writing css.

tachyons

Tachyons provides extensions (-ns, -m, and -l) to many of its classes to help you design for responsive layouts. This lesson walks you through designing for mobile first then adding a design for desktop.

Design for Mobile First with Tachyons

Building responsive css layouts is critical in any modern website. Tachyons makes this easy by designing for mobile first then enabling you to switch directions and positions of elements when the site scales up to desktop sizes. This lesson walks you through using Tachyons with flexbox and leveraging the `flex-column` and `flex-row` classes to respond to mobile and desktop sizes.

Build Responsive CSS Layouts with Tachyons

[GlimmerJS](https://glimmerjs.com/) is a UI component library built by the Ember.js team. It is fast and lightweight and uses a combination of TypeScript and Handlebars to build the components.   

In this lesson we will use the Ember CLI to initialize a new GlimmerJS project.

We will start by installing Ember CLI globally by running `npm install -g ember-cli/ember-cli`.

Next we will use the `ember` command to create our new project by running `ember new egghead-glimmer -b @glimmer/blueprint` . 

When our project is created we `cd` into the project directory and start the development server. We will view the page in the browser and change the base template.

Initialize a project using Glimmer.js

Installing the AWS CLI on your local workstation may be one of the biggest boosts to productivity you can make if you use AWS often. Almost all AWS features are available via the CLI allowing you to script, schedule and automate many AWS related tasks.
In this lesson, I’ll show you how to setup and verify the AWS CLI.

Installing the AWS CLI on OS X and Linux

Vim is a highly configurable text editor built to make creating and changing any kind of text very efficient. It is included as "vi" with most UNIX systems and with Apple OS X.

Every programmer starting to work in a *nix environment eventually finds themselves in VIM, the default text editor. Often by mistake! Because VIM lacks the typical polished GUI of normal programs, it can be hard to discover the correct sequence of commands to even exit the program. Once you learn how to exit VIM, then the next task is to also learn how to make VIM do what you want -while- exiting!

In this lesson we cover 7 different ways of exiting VIM, whether you are in EX mode or Command (also known as Escape) mode, whether you are editing a single file or several at once.

Exit Vim

Flutter allows you to build beautiful native apps on iOS and Android from a single codebase.

flutter

We will setup our first command-line Dart application. We will use the apt-get package manager on Ubuntu to install the SDK and write our first program. This will prepare you to follow along in the next lessons.

Get the gist of commands → https://gist.github.com/creativebracket/b44ee73739f249be0d5f4b8676e8eca5

Set up your first Dart project on Linux

<p>Today Joel catches up with Iheanyi Ekechukwu. Iheanyi is a Product Engineer currently working at DigitalOcean. He previously worked at IBM on Watson. They also talk about Iheanyi's education, stack, and side projects</p><p>Iheanyi started out majoring in Computer Engineering, but switched to Computer Science after he figured out hardware just wasn't for him. He now lives and works in Brooklyn and spends most of his time coding (though he always brings his design skills to the table).</p><p>Iheanyi's design comes from a dual degree program at Notre Dame, the college where he graduated. He noticed a lot of subpar interfaces coming from pure programmers, and he was frustrated with that, so he took his school's opportunity to learn design and apply it to his work. Even if he isn't a designer, he uses his skills daily to communicate with designers and make whatever he works on that much better.</p><p>Iheanyi started using Ember back during college. He was frustrated by his school's class search interface, and he set out to improve it. Ember and Rails were like a match made in heaven for him, Ember having been authored by ex-Rails core team member, Yehuda Katz.</p><p>Joel discusses with Iheanyi what he's currently using in his work. They get into GO, and how Iheanyi has enjoyed working with a statically typed language when doing back-end work. Not having to worry about full test coverage when refactoring has been great!</p><p>Lastly, they talk about the various side projects Iheanyi has going. Such as Interface Lovers, a blog where top designers are interviewed and share their work music playlists. Also, Seeker, a job-board app that allows you to connect your strip account to it and have companies submit jobs.</p><hr /><h3>Transcript</h3><p><a href="https://egghead.simplecast.com/episodes/47aebd17/transcript">"Iheanyi Ekechukwu on education, programming, and managing side projects" Transcript</a></p><h3>Resources</h3><ul><li><a href="https://seeker.company">seeker</a></li><li><a href="https://interfacelovers.com/">Interface Lovers</a></li><li><a href="http://creative.black/">Creative Black</a></li><li><a href="https://www.ibmchefwatson.com/">Chef Watson</a></li></ul><h3>Iheanyi Ekechukwu</h3><ul><li><a href="https://iheanyi.com/">Website</a></li><li><a href="http://www.twoblacknerds.com/">Podcast</a></li><li><a href="https://twitter.com/kwuchu">Twitter</a></li><li><a href="https://github.com/iheanyi">Github</a></li><li><a href="https://egghead.io/instructors/iheanyi-ekechukwu">egghead.io</a></li></ul><h3>Joel Hooks:</h3><ul><li><a href="https://twitter.com/jhooks">Twitter</a></li><li><a href="https://joelhooks.com/">Website</a></li></ul>

Today Joel catches up with Iheanyi Ekechukwu. Iheanyi is a Product Engineer currently working at DigitalOcean. He previously worked at IBM on Watson. They also talk about Iheanyi's education, stack, and side projects

Topics

Instructors

Content Type