Learn Elm, Npm and Xstream

You can’t be everywhere at once. Neither can node packages. But with a utility called npx — included in npm v5.2 and later — you can interact and run with node modules even if they’re not downloaded locally. The same is true for gists and remote branches of GitHub. As long as npm installed, your work can be wherever you are.

This course from Elijah Manor unlocks the power of the npx utility. Over 17 minutes, we will examine the npx package runner and look through various scenarios where the tool is helpful when running node packages from the command line. You’ll learn to use npm to:

- test out various versions of a package
- run packages without globally installing
- run code directly from GitHub
- make working with packages much easier

npm is the package manager for JavaScript. Find, share, and reuse packages of code from hundreds of thousands of developers — and assemble them in powerful new ways.

Execute npm Package Binaries with the npx Package Runner

elm-ui is a novel iteration on declarative styling where you can use Elm types and functions to define your UI in a declarative way. The novel part is that it does not require you to know CSS to be used, you can start building layouts right away!

You'll learn how to:
- use a declarative mindset for building UIs
- position elements on the screen
- create layouts with rows and columns
- build a form with elm-ui

Elm is a programming language that provides a clean functional syntax for writing HTML web applications. It promises zero runtime exceptions, fast rendering, time-travel debugging, and much more.

Declarative UIs without CSS with elm-ui

npm is like a giant library of code building blocks. There are tons of these “blocks”, aka “packages” that we can compose together to build cool things. We can use packages by other developers, but we can also write and publish our own. 

In this course we will learn how to create, publish, and update our own packages. We will create a JavaScript utility module to filter out sensitive words from a string, including tests and development file watching. We will then cover publishing and updating our package. This same approach can be used to create and publish other types of packages too like components (React, Angular, Web Components etc.) and command line interfaces.

Publish JavaScript packages on npm

In this course we will introduce the topic of using npm scripts as a build tool. We will start simple and then continue to build a small website as we introduce new topics. By the end of the course, you'll know how to get started and what tools and techniques are needed for you to create your own set of build scripts.

How to Use npm Scripts as Your Build Tool

Elm is a beginner friendly functional reactive programming language for building web applications. It contains a small but powerful set of language constructs, such as, static types, algebraic data types, immutability, and pure functions. Elm provides and requires the use of a specific architecture that’s well suited for sensible application construction. Elm’s type system and architecture may feel constraining at first, but they ultimately provide the programmer with some neat benefits including comprehensible code, and a much improved refactoring experience.

In this course you will learn the basic fundamentals of Elm so that you can start building applications today.

Start Using Elm to Build Web Applications

The ability to pull in just about anything your project needs from npm is amazing, but it can also lead to bundle bloat if you aren't selective about what libraries you pull into your library. In this lesson, we'll take a look at bundlephobia.com, a tool that provides insights about a library's size. With bundlephobia, you can make informed decisions about what libraries you pull into your project and avoid unnecessary bundle bloat.

https://bundlephobia.com/

Make informed decisions about 3rd party npm libraries with bundlephobia

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

With Node.js installed, bootstrapping a react app is as simple as executing `create-react-app` with `npx`. No further downloads necessary.

Bootstrap a react app using create-react-app

Leaflet is the leading open-source JavaScript library for mobile-friendly interactive maps. Weighing just about 38 KB of JS, it has all the mapping features most developers ever need.

leaflet

While there are a few options for building maps, [Leaflet](https://leafletjs.com/) is the most popular. Lucky for us, Leaflet is also available as a ReactJS component library with [React Leaflet](https://react-leaflet.js.org/). We'll use both Leaflet and React Leaflet to build a map in our React app.

To get started, we need to install:

[Leaflet (npmjs.com)](https://www.npmjs.com/package/leaflet) and [React Leaflet (npmjs.com)](https://www.npmjs.com/package/react-leaflet)

**[Click here for exercise instructions](https://github.com/colbyfayock/launchtime-workshop/tree/master/lessons/02%20-%20Adding%20Your%20First%20React%20Leaflet%20Map%20to%20a%20New%20React%20Application#1-installing-our-dependencies)**


Install Leaflet and react-leaflet with NPM in a JavaScript Project

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

Nx has been design to work especially well in large monorepos. One particularity (compare to other monorepo solutions) is that Nx follows the principle of having one single version of a package in the entire workspace. That said, you'll have one version of React, one version of Angular etc.. This helps to keep things consistent, facilitates code sharing as well as easier migrations.
In this lesson we're looking into adding the [material-ui](https://material-ui.com/) package to our React app.

Install and use external npm packages in an Nx Workspace

Node.js is a platform built on Chrome's JavaScript runtime for easily building fast, scalable network applications. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.

node

Tests are really important in the software development cycle. But how we can test if our API - or even a page - will support the web traffic and requests our users will create by accessing them?

In this video, you will learn how to create HTTP load and benchmarking tests in Node.js using the autocannon package. With that, we can make sure our API is not consuming too much memory, CPU, or any other resource that can cause slow responses.

Create Load Tests in Node.js Using Autocannon

We are going to go ahead and install globally create-elm-app (because it has the best DX so far) and show how would you typically start any production-ready Elm app, and also add elm-ui as a dependency and show the first elements with elm-ui.

Bootstrap an elm-ui Application with create-elm-app

To showcase the power of elm-ui, in this lesson we will show how incredibly easy it is to center an element both horizontally and vertically on a screen with elm-ui, since this is a typical problem while doing regular CSS.

Center an elm-ui Element Horizontally and Vertically

In this lesson we will start to get to know the row and column functions in elm-ui to help us layout our application. We will choose the mobile first approach in which we will display everything in one column, show how to handle two columns and explain that later when we do responsible we will be able to play a bit more with this. Since the concept of margin does not exist in elm-ui, in this lesson we learn how to solve it by using spacing and we will talk about padding in a future lesson.

Model a Layout with row, column and spacing with elm-ui

We will use the pink box element that we had from previous lessons while implementing our fancy dashboard and we will turn it into our Card "component", the piece of UI that we are going to repeat and that will have its own state later on the course. 

To do this, we'll first manipulate the background color and text color, then change the height and width of the card. We will want to change the title for each of the cards and to do so we will accept a title argument that will be passed down to our text element within the card to be displayed.

Use View Functions to Create Reusable Pieces of UI in Elm

Since we mentioned in a previous lesson that there is no concept of "margin" in elm-ui, we are goint to learn how to se `padding`, `paddingXY` and `paddingEach` to compensate for that, and a little trick defining a value edges that is going to be pretty useful.

Use padding, paddingXY and paddingEach with elm-ui

We will style the heading of `viewCards` to look more like a real heading. If you inspect the console right now, you'll find that the `el` element we are using for our text corresponds to a div in HTML. 

We will go further away than using only text to display our content and introduce the modules `Element.Font` and `Element.Region` to fix the headlines and other text of our dashboard, adding an additional "breakdown" heading that is going to serve as a divider between sections.

Style Text with elm-ui Headlines, Typographies, and Fonts

In this lesson, we will explain when you would need to reach for the `text` function, why it is different from `textColumn` and `paragraph` and when to use each one as they serve different purposes for displaying text in the UI. Basically, `el` and `text` elements **do not wrap text by default**, so we need to use `paragraph` when we want text to overflow and still be visible to read. We will add a new "subtitle" section below our Breakdown subheading

Choose between text, textColumn and paragraph with elm-ui

Now that we have our cards more or less looking good lets add a button and style it as well so that it serves as a starting point for our dropdown component, this lesson will also help us to learn how to use the `Element.Input` module from elm-ui.

Work with elm-ui Input Components

Since there is no select or dropdown component backed in into elm-ui, we will be adding another dependency to our project called `PaackEng/elm-ui-dropdown` and adding to it additional styles and settings so that it looks and behaves exactly as we want to.

To make this works, we need to make a few changes:
- We need to add a `dropdownState : Dropdown.State String` to our `Model`
- Add a couple of extra variants to our `Msg` type: `OptionPicked (Maybe String)`, to be dispatched by our dropdown whenever we click on any option, and `DropdownMsg (Dropdown.Msg String)` to update the internal state of the dropdown from the outside.
- Construct our hardcoded list of options of type `List String`.
- Define a `dropdownConfig : Dropdown.Config String Msg` that is going to contain all our customisation of our dropdown.
- Use `Dropdown.view` to display our custom dropdown wherever we need it.

Customize My Own Dropdown with elm-ui-dropdown

Now that our dropdown is almost finished lets just drop some shadow in the options selector to make it more visually clear that its over any other element in our page. This is an attribute that we can control the `offset`, `size`, `blur`, and `color`.

We will want to do this to our `viewCard` as well. We will also make the `viewCard` function more flexible by adding additional `Html` attributes from the outside to make each card have a different **height.** That way any time you want to override default attributes, you can pass in a new style.

Add elm-ui Border.shadow to Highlight Any Element

This is the only lesson in which we will fallback to CSS to give our dropdown's scrollbar a fancier look because this is very browser dependent and there is no way (yet) to do this with elm-ui.

Topics

Instructors

Content Type