Learn Elm, React-storybook and Xstream

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

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

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

Storybook is a UI component development environment for React, Vue, and Angular. With that, you can develop UI components without running your app.

Here I show how best to configure a React Storybook to use [Typescript](/q/typescript) (with TSX). This lets you write your reusable components with maximal type safety. Please see the provided code for the full source.

Configure React Storybook for use with Typescript

[Storybook](https://storybook.js.org/) is a framework that allows you to develop components in isolation. It is ideal for a variety of use cases, most commonly when you're building some shared component toolkit. As such, Nx comes with a dedicated package `@nrwl/storybook` that adds a series of useful code generators to add storybook to an existing React library, but also to automatically generate stories and more.

Use Storybook to Develop React Components in Nx

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](https://nx.dev) combines a lot of the best tools on the market, integrates them, and provides tooling to provide the best possible developer experience. One such pair is [Cypress](https://www.cypress.io/) and [Storybook](https://storybook.js.org/). Storybook allows developing components in isolation, which is also a great basis for testing components, which is where Cypress shines.
In this lesson, we're exploring some of the `@nrwl/storybook` code generation utilities that allow you to not only configure Storybook for a React application but automatically also set up a Cypress test configuration for it along with some spec files generated from the Storybook stories.

Use Cypress and Storybook to test your React Components in Isolation

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.

Customize My First Checkbox Icon with elm-ui

Up until this point, the 4 cards displayed in our dashboard each repeat the same information, so in this lesson, we will be splitting the state into different parts, showing an algebraic mindset and thinking how best represent the state of our app with our custom types. 

We'll start by modeling the selected options in state as a List of a Menu and String. The next step is to actually update the internal state of our menus. We will update `OptionPicked` to receive a string and when it does receive an option, it will filter for just the selected option and append that to state. Finally we will display the options in the `viewCard` component that will filter for the menu that is being selected and in the case of an option selected display that option as a string.

Split the Business Logic of Elm view Functions By Modeling the State

Since every time we interact with one of the dropdowns the information is shared between the 4 of them, the time as now arrives to give each individual dropdown its own state. We will also add subscriptions to listen to when the user clicks outside each dropdown!

To do this, we'll need to extend our state model to include each instance of our `viewCard`. To determine which dropdown that was clicked we will create a `getDropdownState` function that pattern matches the correct card instance. During this process, you'll see how the Elm compiler guides us through adding this functionality with detailed error messages.

You'll see how adding a subscription to close open dropdowns is convenient as `Dropdown` gives us an `onOutsideClick` function that receives the model and dropdown message.

Give Multiple Dropdowns Their Own Individual State with elm-ui-dropdown

We will make all the necessary changes to keep track within our model of the device and orientation that the user is using, and change our UI according with that information, adding responsiveness and multiple columns (at last!) to our dashboard.

To do this, we'll need to modify our app state to track the device height and width (which we expose from JavaScript). Then we can use the `classifyDevice` function to pattern match the devices we want to handle, in our case, `Desktop` and everything else (as mobile). We will add a `Browser.Events` subscription that sends a ResizedApp message to our model that defines what device we are on.

Manually Control Responsiveness with Elm classifyDevice

Now that our beautiful dashboard is complete, is time to produce a production ready build with create-elm-app, one of the biggest benefits of using it. You'll notice that it is running on production mode because the Elm Debugger won't show up anymore.

Create a Production Optimised Build with create-elm-app

Welcome to the elm-ui course! We are going to be building a complex dashboard completely from scratch with elm-ui, with a mobile-first approach and in the final lessons of the course we will make it fully responsive! I hope you enjoy the course and that you choose elm-ui for your next project!

Topics

Instructors

Content Type