Learn Go, Lodash and Ngrx-store

Go is a server-side language, but today we can compile Go code to WebAssembly as well - making it possible for us to bring programs written in minimalistic Go code into the browser!

With this collection, we will learn how to compile and run Go WebAssembly programs in Node.js and the browser, and how our Go code can interop with JavaScript and manipulate the DOM. We will also talk about configuring our VS Code workspace and optimizing the Go WASM binary size.

Go is an open-source programming language that makes it easy to build simple, reliable, and efficient software.

WebAssembly with the Go Language

As your Angular application grows, it becomes more difficult to manage application state.

NgRx can help with that!

In this course, we will learn how to convert an Angular application from using stateful services into using NgRx.

We will accomplish this by adding a new feature, including building a reducer and actions. We'll also touch on using selectors to query our state, managing collections with NgRx entity, async operations, and hiding implementation details with the facade pattern.

Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

angular

Reactive State Management in Angular with ngrx

This collection of lessons will cover a variety of topics that teach you how to work with slices and arrays in go. You'll learn how to declare them, create them using literal syntax, iterate over them, add to them, remove from them and other useful things.

Learn about slices and arrays in Go

Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. It is used frequently in the container ecosystem by projects such as Kubernetes (container orchestration), Docker (containers), and Cilium (BPF networking).

This playlist is a collection of videos that will start you off on your Golang journey.

Golang from Scratch

[Lodash](https://lodash.com/docs/) is a collection of utilities that have become a staple of modern web development. This collection will show you how to re-create its most common methods using simple JavaScript techniques available in any modern web browser. In addition to re-building tools like `_.merge`, `_.get` and `_.debounce` from scratch you will also learn how to replace them completely in some cases with modern syntax such as [optional chaining](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining), [nullish coalescing](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator) and [Object.fromEntries](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries).

This collection should interest the following groups:
- Those who want to better understand common JavaScript patterns
- Engineers who want to reduce their dependence on Lodash (for performance or other reasons)
- Candidates preparing for a technical job interview (where it is common to be asked how to implement some of these methods).

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Recreating Popular JavaScript Utility Methods from Lodash

***Note: RxJS imports have changed since the publication of this course. The concepts being taught on RxJS are still applicable.**

Angular has many built-in features for working closely with RxJS to help you build entirely reactive applications. This course will teach you how to use Angular with RxJS. We will learn how to use the ngrx/store library to manage state in a clean, reactive "Redux style."

This course assumes you've got a working knowledge of Angular and reactive programming with RxJS. If you don't, you might want to watch the following courses to get you up to speed! 
- [Get Started with Angular](https://egghead.io/courses/get-started-with-angular) 
- [Introduction to Reactive Programming with RxJS](
https://egghead.io/series/introduction-to-reactive-programming). 
- [Step by Step Async Programming with RxJS](https://egghead.io/series/step-by-step-async-javascript-with-rxjs) 
- [Getting Started With Redux](https://egghead.io/series/getting-started-with-redux), a course by Redux's, Dan Abramov.

We also have Intermediary Angular courses if you'd like to acquire more in-depth knowledge. 
- [Dependency Injection](https://egghead.io/courses/angular-2-dependency-injection-di-explained
- [Components, Directives](https://egghead.io/courses/building-angular-components)
- [Forms](https://egghead.io/courses/intro-to-angular-forms)
- [Router](https://egghead.io/courses/intro-to-angular-router)
- [Animating Web Apps](https://egghead.io/courses/animate-angular-web-applications)



Build Redux Style Applications with Angular, RxJS, and ngrx/store

We'll cover a small Golang program that prints a string to the terminal, showing how to set up an executable program, import a package, and build a binary.

Getting Started with Hello World in Go

Returning multiple values from a function is a common idiom in Go, most often used for returning values along with potential errors. We'll go over how to return multiple values from a function and use those values in our program.

Returning Multiple Values from a Function in Go

Functions are as useful in Go as many other programming languages. In this lesson we write a function that operates on numbers covering the func keyword, argument and return signatures, and writing the function body.

Writing a Function that Multiplies a Number by Two in Go

Golang has testing tools built into the standard go tool and the standard library. Here is how to write a unit test on a function so that you can run it with `go test`.

Writing a Unit Test in Go

iota is a constant generator that can be used to construct enums. It is effectively an infinite list that starts at 0 that can be used to produce a value for a set of constants.

iota, The Golang Constant Generator

Constants are expressions whose values are known at compile time, which means that we can generate errors for expressions using those constants at compile time as well, instead of runtime.

Golang Constants Basics

Golang includes the `go mod` command to initialize a new project. Sometimes that command fails even though it tries to be smart about where to get the name of your module from so we give an example of how to explicitly set the name of your go modules based project.

```shell
mkdir my-go-project
cd my-go-project
go mod init github.com/christopherbiscardi/my-go-project
```

Initializing a project using Go modules

Golang has no built-in function(s) to filter an array. This lesson will teach you two different ways to filter.

The first is to create a separate array and add the filtered elements to it. This works great, but doesn't use memory as efficiently as the second way.

The second way shows you how to filter by altering the original array in place without making another array to hold the filtered elements. But, it has a side-effect that I'll tell you about which may help you decide which approach you will use to filter your array. 

Filter an Array in Go

There are numerous ways that you can declare and create arrays and slices in Go. This lesson will show you several and I talk about the advantages and disadvantages of one over another. After watching, you will better understand all of the possible ways you can declare/create as well as the idiomatic way.

These include:

* var
* the built-in function *new*
* the built-in function *make*
* Array and Slice literals

While it is not the main intent of this lesson, I do touch on some of the differences between slices and arrays.

Checkout the code in my [github repo](https://github.com/JeffBNimble/GoLessons/tree/master/Array-Declare).

Declare Arrays and Slices in Go

There is a built-in append function that is used to append elements to a slice. We'll see in this lesson that the append function works only with slices, not arrays. There are also some nifty alternate uses of the the append function that make appending super easy.

Checkout the sample code in my [github repo](https://github.com/JeffBNimble/GoLessons/tree/master/Array-Add).

Append Elements to a Slice in Go

There are a couple of different ways to iterate over an array or slice in Go. The primary approach is to use range, which handles the iteration for you. However, you can also use a traditional for loop if you need to do something out of the ordinary, like iterating in reverse or skipping every other element.

Iterate over an Array or Slice in Go

Go has a special indexing syntax that forms the basis of removing one or more elements from a slice. I will teach you this syntax and show you its various forms.

Based upon that, I'll show you how to remove a single element from a slice. However, you may find this somewhat limiting. I also will show you a more typical example of removing elements from a slice as we iterate over it. This technique shows you how to remove multiple elements from a slice.

Remove Elements from a slice in Go

There are numerous ways to sort slices in Go.

The simplest way uses some basic built-in functions from Go's **sort** package to allow you to easily sort slices of primitives, that being **Strings**, **Ints** and **Float64s**. Using these sort functions, we don't have control over the sort order as the data will be sorted in ascending alphabetical (for strings) or ascending numerical (for Ints and Float64s) order.

In this lesson, we will take a quick look at the easiest way to sort slices of primitives. We will learn about using some of the handy built-in functions in Go's sort package, including:

* sort.Strings: Sorting a slice of strings
* sort.Ints: Sorting a slice of ints
* sort.Float64s: Sorting a slice of float64s

Sort Primitives (strings, ints, and floats) in Go 

There are numerous ways to sort slices in Go.

In this lesson, we will take a quick look at an easy way to sort a slice of structs or primitives. We will learn about using one of the handy built-in functions in Go's sort package called *sort.Slice*. This function takes a slice to sort as an argument and a *less function* or *less func* for short as the second argument. You will write this *less function* to sort the slice however you wish.

Go's sort.Slice function looks like this: *sort.Slice(someSlice, func(i, j int) bool)*. It's super-easy to write an anonymous *less function* to sort.

As you will see, it's easy to use this *less function* to do simple and even complex sorts of your structs with minimal effort.

Sort Slices of Structs using Go sort.Slice

*Go ^1.12, Node ^12.14.0*

Compiling Go programs to WebAssembly does not require Emscripten, and the process is pretty straight forward. In this lesson, we will learn how to compile a simple Go program to a WebAssembly binary, then execute it with Node.js.

Topics

Instructors

Content Type