We want you to get the feel for typical Groxio content and the reasons we provide each type of content. Each Groxio module comes in four scheduled releases consisting of the central PDF, videos, and resource links. Later releases have projects as well. You can see part of the first release here.
The scientific teaching method we follow is the Dreyfus learning model. Books provide the metaphors experts need to build context, step-by-step instructions for beginners, and the exercises that intermediates need to learn.
The itinerary is a virtual guide. This optional list describes the highlights of each release to maximize your learning time.
Livebook is an interactive notebook in the spirit of the Jupyter notebook or the Julia Notebook. Built for data sciences alongside the Nx project, Livebook’s use cases have grown into education, project documentation, and more. Livebook has the potential to make revolutionary changes across the Elixir community.
Livebook uses Elixir’s distribution services and Phoenix LiveView to provide an interactive experience. Vendors like Fly.io are beginning to use Livebook to bring new developers to their cloud services platform.
Livebook is a project that’s been around for only a year. Jonatan Kłosko wrote his thesis on numerical data processing and evolutionary algorithms with Elixir’s Nx and José Valim noticed. Jonatan worked closely with José to create Livebook. With a growing community and the support of Elixir’s core team, Jonatan has built up Livebook from a new project to a robust tool in a very short time.
Groxio courses focus on concepts rather than features. This course will focus less on the programming APIs surrounding Livebook, though we’ll touch on them briefly.
Instead, we’ll look at use cases for Livebook. When you’re done, you’ll be able to:
Install a default Livebook locally, or on a cloud provider.
Build a protootype with Livebook using a Mix project, a local IEx session, or remote IEx node.
Install a Nerves project to work with custom hardware.
Use Livebook to install dependencies.
Use Livebook to work with graphs and charts.
Groxio language modules have two kinds of videos. Our overview videos set the history and context of a language, or wrap up the work we've done, and are free to support language ecosystems. Our coding instruction videos, mostly starting with the second release, are paid content, and each one offers a live coding project.
Every learning level benefits from pair programming. Our videos are professional, but do not scrub away every tiny mistake. That way, you can see how experienced programmers deal with errors and changes in code organization.
Livebook is a tool for dealing with both prose and code. Unlike a word processor, it can compile code and produce output. Unlike a code base, documents are structured as a document rather than modules for code. We'll walk through key scenarios enabled by this beautiful, new project.
Elixir's roots run deeply through Livebook. This short introduction to distributed Elixir walks you through how to find the key configuration elements as you're dealing with an embedded IEx session within a Livebook.
Subscriber content
This video walks you through how to get a Livebook session up on a single session on Fly.io, and then how you'd go about configuring a Livebook that's broken down into a distributed IEx session and Phoenix server.
Subscriber content
This video walks you through how to get a Nerves version of Livebook running. Frank Hunleth and Bruce Tate used this tool when collaborating on the book Building a Binary Clock with Elixir and Nerves.
Subscriber content
In this video, we use Livebook running on a Raspberry Pi Zero to interact with a Livebook to interact with a custom chip. Livebook makes experimenting with hardware easy because it eliminates friction in the feedback loop that comes with building and deploying hardware.
Subscriber content
In this video, we use the Kino component library with the CRC pattern to build simple animations. With Kino, an animation uses a function to continuously return visual components and also update a continuously changing accumulator. Kino takes care of the rest. We start with this toy animation, and over time will grow its capabilities.
Subscriber content
In this video, we use the Kino images to render simple SVG graphics. Since these are SVG graphics, the technique can render graphical data. We use Kino's basic library to provide a default image which Livebook knows how to render based on the Render protocol. Later, we'll build our own basic components that know how to render themselves in Livebook.
Subscriber content
In this video, we walk through the techniques Livebook uses to render various kinds of components. We build our own SVG canvas and first use the Render protocol's default form. Later, we walk through how this might work with an out-of-the-box tool with a custom rendering.
Subscriber content
Traditionally, Livebook users build documentation with inline code and external dependencies. Sometimes, it pays to use Livebook with Mix projects under development. This video walks you through how to configure and code Livebook projects within a structured external Mix project.
Subscriber content
Working with Livebook and Mix in a single project gives you some of the benefits of both projects. Livebook can document your prototype progress and shorten your cycle times by providing custom support for the compilation cycle. Mix lets you package your project for your customer as you go.
Subscriber content
Programming games is a great way to learn how to use Elixir because you can visualize how different Elixir and graphics constructs work. This episode will walk you through rendering our Snake game as we work within both Livebook and Mix.
Subscriber content
Games in functional languages work by separating the concepts of representation, event processing and rendering. In this video, we work with our Livebook and Elixir game by coding a function to move our snake as it moves across the board.
Subscriber content
Functional animation happens by connecting our game's functions and data model through a reducer function to produce a new frame in a regular periodic interval. In this video, we process events within an animate loop.
Subscriber content
In this video, we begin to wire our Snake game up to the keyboard. We then push the underlying Animate function to the breaking point.
Subscriber content
Animations are easy with Livebook but their input options are limited. In this video, we change the animations with OTP to sneak down to a lower level of abstraction and then create the right model for processing both the visual component and keyboard input via separate message channels.
Subscriber content
The combination of OTP and Livebook allows us to shift the implementation of the Serpent game to a form that can process visuals and keyboard inputs. We carve out an OTP boundary layer and integrate it to our functional core.
Subscriber content
With the design of the OTP server complete, we move forward on the Serpent game. We implement the random apple that lets the serpent grow. This video shows how the design allows us to focus game development on the core, now that we have a working foundation in place.
Subscriber content
Since Livebook has the responsibility for managing lifecycle on our page, we need a way to restart our supervisor when a cell reloads. As you might imagine, Livebook has supervision capibilities for just this scenario. In this video, we use Kino.start_child to restart a component.
Subscriber content
Each new chapter has a set of links, separated into three categories. The categories reflect different competency levels and resources that match that stage of learning, for each Groxio release.
These resources will get you on the path to learning with background information, tooling and exercises.
You decide how deep to go. These resources are exercises and projects to cement your learning.
These resources will help you put your new knowledge into context so you'll be better at your everyday job.
The Dreyfus model is originally instruction for pilots. A typical pilot course is based on reading material to understand context, and then flying a plane. Our videos and PDFs are important, but in the end, programmers need to program in order to learn. Our projects offer different levels of assistance, from "give me the answer" to "make this test pass".