AUTHOR

Katharina

A resume that you created on a **Vue.js Resume Builder**, a Vue.js Resume Builder that **YOU** created! Now **THAT’s** the good stuff. That’s that stuff that distinguishes **YOU** from the flock of **“Word” and “PDF”**.

### 5 Reason for Creating your Resume Builder in Vue

1. Vue.js is very **performant**: It works with a virtual DOM, a lightweight representation of the actual DOM. It allows Vue to optimize updates and significantly improves performance.

2. With its component-based development, Vue helps **structure code**, which makes maintaining it easier.

3. Vue.js simplifies the **rendering of content** immensely: When your data changes, the connected part of the DOM automatically re-renders.

4. Vue is a **progressive framework**: That means you can introduce Vue into an existing project. You don't have to rewrite everything, instead, you can only use Vue for a specific page or section of your project.

5. It is **open-source**, and you can be sure that it will be continued due to its popularity.

### Overcoming Challenges in Vue and Developing a Resume Builder

If you are already familar with CSS, HTML, and JavaScript, with the gentlest learning curve, Vue is your doorway into a fully-fledged front-end or even a full-stack web developer.

Mastering Vue can present a learning curve for absolute beginners unfamiliar with CSS, HTML, and JavaSrcript, this is due to its extensive features and concepts like data properties, methods, computed properties, custom events, and lifecycle hooks. While Vue offers excellent [documentation](https://vuejs.org/guide/introduction.html), it can be challenging for developers to get a deeper understanding without a structured learning path.

The best way to familarize yourself with a new framework is to work on a portfolio project, and this course is exactly that. You won't find anything about creating a portfolio project in any offical documentation. This course also provides a **structured learning path**, breaking down complex concepts into manageable lessons.

Our aim is to ensure that you progressively build your understanding of Vue, starting from the basics and advancing to more complex topics. And thus, this course is tailored for Vue.js beginners, leveraging the Options API in Vue 3 for its **beginner-friendly** approach.

We emphasize practical application as the most effective way to become familiar with the material, ensuring you apply newly introduced concepts from the course's very first lesson. Instead of practicing on simple to-do list apps, you have the opportunity to create a substantial portfolio project that you can showcase to friends, potential employers, and even use for yourself to create a Developer Resume.

### Course Content Overview
Course Overview:
Total Modules: **5**
Total Lessons: **14**
Total Video Runtime: **1 hour, 30 minutes**

Enhance your Portfolio with a Kickass Vue 3 Resume Builder

“**Word” or “PDF” resume pfft!** You’re better than that and you know it. In this course, you will create a **customizable developer resume from scratch in Vue.js** with features and tools to make meaningful changes in the content and the design of your developer resume.

This course will also teach you all the fundamental concepts of Vue, with code-along video lessons, detailed explanations, and hands-on exercises. By the end of the course, you'll have a deep **understanding of Vue**, a **stylish developer resume**, and a **portfolio project** that demonstrates your Vue knowledge.

Interactive Vue.js Resume Builder

Creating a highly configurable and customizable Resume Bilder in Vue

Setting up Vue projects with the Single File Components architecture

Component reactivity and dynamic data rendering with Vue directives

Computed properties and component methods

Communication between components via props and custom events

Conditional styling through class and inline style bindings

Enter your name and email address below, then click the **"Send my free chapter"** button to get started

300+ page PDF

EPub

newline Access with Replits

All Code Samples

Discord Community Access

One-time price of $69

( the primaryDescriptionMarkdown is long - several lines, include images, as long as you want )

In this course we <headline of what we do>. <why this technology is good> but <here's how learning it is problem>. 

In <the length of these lessons> we cover <three salient points about what we cover. Your BEST points>. Its <however long it is> and comes with <these bonus features, and reasons to buy. code, etc.>

It's taught by <author name> who <credibility, reason you should listen to them>. <social proof, if you have it yet>

<then you can list other supporting stuff you want to add, anything you want here>

-------
Example:
-------

We created a free course to create your first GraphQL server (from scratch) using Node and TypeScript. TypeScript and GraphQL are a powerful combo, but there's a lot of confusing edges if you're getting it setup the first time.

In this course we cover the basics of getting TypeScript setup with Node, how GraphQL works, and how to set up a GraphQL server using Apollo server. It's two hours long, it comes with complete code examples, and we walk through the code step-by-step.

It's taught by my friend, Shopify-engineer Hassan Djirdeh and he's integrated what he's learned using GraphQL in production as an engineer at Shopify. We've already had over 1,300 students enroll and it's been getting great reviews so far.

// ... and so on

In this course we <headline of what we do>. <why this technology is good> but <here's how learning it is problem>. 

( the summary is short - one or two lines )

Advanced JavaScript Unleashed

Travis Waith-Mair

Learn the Best Practices and Design Patterns behind every CSS layout. Know exactly what you *should* and *shouldn't* do at all times. And develop the intuition to **break every layout into its simplest building blocks** and the ability to **recreate it with both CSS Grid and Flexbox**.

### Why CSS Feels Hard and Frustrating

CSS is different than any other programming language. That's because it's not a programming language itself.

And that's why **CSS can feel painful, stressing, and overwhelming**. 

A common misconception is that with enough practice and experience, it will somehow just "click" eventually, but it doesn't work that way. 

This is what happens when you try to build a layout without first learning, understanding, and implementing the fundamentals. 

And this is when **CSS feels like throwing mud at the wall and hoping something sticks**. 

This is when editing a layout feels like defusing a bomb where one wrong move will turn everything to dust.

Flexbox and Grid definitely make things easier, and so does Bootstrap and TailwindCSS. **But these alone are not enough to help you feel confident in your abilities to build complex, responsive CSS layouts**.

It's like thinking you're a great painter because you have a canvas and a brush.

**These are just *tools***. But to paint a masterpiece, you need to know the fundamentals of painting.

And to build a picture-perfect layout that will last, **you *need* to learn the fundamental CSS Design Patterns**.



### How *Mastering CSS Layouts* Helps:

*Mastering CSS Layouts* teaches you the 7 fundamental Design Patterns that are used to build every layout in existence in the most simple and sturdy way that's easy to make responsive. 

You'll not only be able to recognize them, but also know *exactly* **how to use them in real-life scenarios like complex landing pages, SaaS interfaces, and more**.

You can finally **feel confident in your ability to build any layout there is from scratch** or edit an existing layout without breaking anything. 

Because you'll **know what you should and shouldn't do when building your layout**. 

Thanks to the best practices and foundational building blocks that are used to build all complex and responsive layouts.

These Design Patterns work with both Flexbox and CSS Grid so **you can use whichever you want** whenever it's time to build or edit a layout. 

And when you see a layout that seems harder to implement, you'll know **how to stack patterns on top of each other to achieve the exact result you want** every single time.  

### Course Content Overview

Course Overview:
Total Modules: **5**
Total Lessons: **24**
Total Video Runtime: **1 hour, 27 minutes**

Unlock the Secrets of CSS Layouts with Practical Expertise in Design Patterns

Become confident in building any CSS layout by learning the fundamental CSS Design Patterns and Best Practices that are responsible for all the CSS layouts in the world. 


Make CSS easy and intuitive by identifying those building blocks in seconds in every layout and learn how to code each of them using CSS Grid or Flexbox. By the end of this course, CSS will finally "click". 


Everything will make sense and you'll know how to build from scratch or edit  both simple and complex layouts.

Mastering CSS Layout

Build a responsive landing page using modern CSS layout patterns.

Implement modern CSS layout patterns with CSS Flexbox and Grid.

Optimally accommodate different grid layouts for cards with CSS Grid.

Drop cards to their own columns upon screen size changes with CSS Flexbox.

**How to make CSS make sense** by understanding the fundamental building blocks of web pages

How to **build *any* layout you want** and keep it sturdy and unbreakable

How to **instantly recognize common problems** in web layouts

What are **the 7 Design Patterns that help you solve every layout problem** you're going to ever face

How to **detect what design patterns were used and where** in each layout

How to implement these Design Patterns **in both CSS Grid *and* Flexbox**

**What you should and shouldn't do** when building your layouts

**When to use CSS Grid** and when to opt for Flexbox instead (and why)

How to **become confident in your CSS layout skills**

Akinwale Folorunsho Habibullah

**Pain Free Mocking with Jest** teaches you how to effectively and painlessly test JavaScript applications with Jest. You'll start by learning how to write unit and integration tests as well as the 'How', 'What', and 'When' of Mocks, Stubs, and Spies. Then we'll move to more advanced technique and strategies you'll be using for the rest of your career, including how to have a hollistic approach to testing and how to automatically add your tests in the development lifecycle.

### The Issue With Unit Testing & Mocks

Writing unit tests has always been equal parts important and confusing. 

While writing your first unit test is simple and easy, the learning curve becomes very steep very quickly once you have to test actual real-life scenarios. 

Because suddenly, you have to know how to **mock a database call** or **spy an HTTP request** or **stub a 3rd party API with a security token**. When you have to test real-life scenarios like that, things become much more complex than they initially seemed.

With every test case being different from the next one, and with Mocks not being used anywhere else in coding except for testing, it's hard to find quality information online. Every answer is different from the next one and is aimed for an ultra-specific scenario that won't necessarily apply to any other case, including yours. 

Instead of making things clear, this confuses things even further. 

### How "Pain Free Mocking with Jest" Helps:

"Pain Free Mocking with Jest" is designed to make testing painless by helping you understand once and for all the 'How', 'What', and 'When' of Mocks, Spies, and Stubs using the Jest testing framework.

You will learn how to write simple and complex test cases, utilize Jest's mocking capabilities, and gain hands-on experience with real-world testing scenarios that involve Databases, HTTP requests, and 3rd Party APIs. 

By the end of the course, you'll feel confident using Mocks, Spies and Stubs in any scenario you may need them. You'll have all the knowledge and tools you need to create complete test suites and confidently test JavaScript applications *with* mocking *without* headaches.

### Course Content Overview

Course Overview:
Total Modules: **6**
Total Lessons: **37**
Total Video Runtime: **2 hours, 28 minutes**

### Summary:
- Build and test a Node.js REST API application with authentication features like 'Sign Up' and 'Sign In'. 
- Learn how to test everything from simple functions all the way to Controllers that interract with 3rd party web services.
- Learn the 'What', 'How', and 'When' of Mocks, Spies, and Stubs.
- Learn to see your application code in testable units. 
- Write integration tests for HTTP endpoints, controllers, middleware functions, and 3rd party integrations.
- Create Git hooks to run unit tests before each commit 
- Build a CI pipeline using Github Actions to automate running integration tests on each git push to Github.

Learn to confidently test JavaScript applications and mock dependencies using Jest, the pain-free way. 

Understand how to painlessly use Mocks, Spies, and Stubs to test any part of your application, without worrying about Databases, APIs and Security Tokens. 

After finishing this course (which only takes a single afternoon), you'll feel confident in your testing skills because you'll have all the knowledge and tools you need to effectively and painlessly test even complex applications in the real world without headaches.

Pain Free Mocking with Jest

Test authentication logic and generate code coverage report with Jest.

Adapt an Express.js application for unit/integration testing with Jest.

Run tests against a containerized database instance with Testcontainers.

Test Mongoose models with Jest and Mockingoose.

How to write unit and integration tests with Jest

How to test functions that interact with Controllers, APIs, and Databases (without relying on their responses)

How to test code in isolation with Mocks, Spies, and Stubs using Mockingoose

How to write integration tests for HTTP endpoints and database connections

Advanced mocking and integration testing techniques like the 3A pattern, network manipulation, and more

How to become a test strategist with the Agile Testing Quadrant, create CI test pipelines, and add tests to the development lifecycle

deji adesoga

### How The Course Works:

- The "Build a Modern Web Application using Angular Signals" course is a comprehensive online program spanning five modules. Discover how to effectively utilize Signals to manage the entire state of an Angular application, integrate the newly built-in control flows, employ deferrable views, navigate components using lazy loaded routes, and implement Standalone components.
- Remote Access: Take advantage of the course from any location, allowing you the flexibility to engage with the materials at your convenience.
- Self-Paced Learning: Tailor your learning experience to your schedule, enabling you to progress through the course content at your own pace.
- Community Engagement: Collaborate and learn alongside a diverse community of fellow students, fostering an environment of shared knowledge and support.
- Structured Learning: Experience a well-organized curriculum designed to provide a cohesive and comprehensive understanding of Angular Signals in a logical progression.

### Understanding the Challenges

Learning Angular 17 can present various hurdles and frustrations for those new to the technology. As individuals navigate their journey into this advanced framework, they commonly encounter several challenges:

- Complexity Barrier: The intricate architecture and extensive feature set of Angular 17 can overwhelm newcomers, posing a significant learning curve.
- State Management Complexity: Managing the state of an Angular application efficiently, especially with the nuances of Signals, can prove challenging for learners.
- Integration Puzzles: Integrating and harnessing newly built-in control flows, deferrable views, Standalone components, and lazy loaded routes can be intricate and perplexing.
- Navigational Complexity: Understanding the intricacies of lazy loaded routes and effective navigation between components can pose obstacles to a smooth learning experience.

Navigating through these complexities without guidance can hinder the progress of aspiring developers aiming to master Angular 17.


### Advantages of Learning Angular 17 in 2023

- Enhanced Performance: In 2023, Angular 17 offers optimized performance enhancements, enabling you to craft high-performing web applications capable of meeting modern user expectations.
- Cutting-Edge Features: Stay ahead in the web development landscape by mastering the latest built-in control flows, deferrable views, and other advanced functionalities unique to Angular 17.
- Industry Relevance: With Angular continuing to be a sought-after framework in the industry, mastering Angular 17 ensures you remain competitive and relevant in the job market.
- Improved Developer Experience: Angular 17 introduces refinements and enhancements that streamline the development process, providing a more efficient and enjoyable experience for developers.
- Scalability and Maintainability: Learning Angular 17 equips you with the knowledge to build scalable and maintainable applications, crucial factors in modern software development.

### Why Learn Angular 17 in 2023

Angular 17 stands at the forefront of web development frameworks in the current year, offering you several compelling reasons to dive into its intricacies:
Embrace the evolution of web development by mastering Angular 17 in 2023. This advanced version presents you with enhanced performance capabilities, cutting-edge features, and improved developer experiences. Remaining proficient in Angular ensures your relevance in a competitive industry, equipping you with the skills necessary to build scalable, high-performing applications that meet the demands of modern users.

### Course Content Overview

Course Overview:
Total Modules: **5**
Total Lessons: **12**
Total Video Runtime: **1 hour, 41 minutes**

### Summary:
This course is structured into five comprehensive modules, guiding you through the intricacies of Angular 17 Signals. From laying the groundwork with introductory concepts to diving deep into handling HTTP requests, sharing data between components, and culminating with a thorough review in the conclusion module, each section builds upon the last, empowering you to master Angular 17 Signals effectively.

Learn how to surgically manage state and optimize UI rendering with Angular Signals. This course introduces students to the world of Angular Signals, from reactive primitives to seamless interoperability between observables and signals. By the end of this course, you'll have learned how to build a highly performant, lightweight Angular application that features deferrable views, lazy loaded routes, and a PayPal-powered checkout flow. Additionally, you'll have learned the techniques needed to modernize older Angular applications so that they're able to fully leverage the power of Angular Signals.

Demystifying Reactivity with Angular Signals

Fetch data from a REST API making use of Signals.

Make use signals to add functionalities to the shopping cart

Checkout selected items from the cart using the available Signal APIs

How to manage state in an Angular application by making use of Signals

The importance of using Signals to enhance change detection

How to integrate a robust lazy loading approach, by making use of deferrable views and lazy loaded routes

Difference between using RxJS and Signals when working with data and asynchronous operations

How to structure an Angular application using Standalone components

How to work with the newly built-in control flows

Fernando Doglio

NextJS

# Complex State Management in Next.js 13+ with Server and Client Components
_Sharing and managing state between server and client components is not trivial_, especially with the limited 
information available online. This course will take you through all the basics you need to answer the question:

> How do I share state between server and client components in Next.js?

## Module 1: Intro & Getting Started
_Begin your journey by understanding the essentials of Next.js 13+ and state management._

- **Overview**: Get an introduction to the core principles and concepts of Next.js 13+. Familiarize yourself with the course structure, the instructor's background, and the tools you'll be using.
- **Goals**: Set clear expectations about what the course will cover, including fundamental problems related to state sharing between server and client components.

## Module 2: State
_Understanding the heart of React applications: state._

- **General Concept of State**: Dive into what state really means in the context of web applications. Explore how state affects the design and functionality of your app.
- **Local vs Global State**: Master the differences and applications of both local and global state to make informed decisions in your coding practice.
- **Management Techniques**: Get to grips with various strategies and tools for managing application state, including popular third-party libraries.

## Module 3: Client Components
_Dissect Client Components and unravel their role within Next.js._

- **Component Structure**: Break down the anatomy of client components, learning how to create them and understanding their role within the application.
- **Capabilities and Limitations**: Examine what client components can do, understanding their scope and limits, and what is reserved for server components.
- **Proper Utilization**: Develop a keen sense for the appropriate use of client components, paying special attention to interactivity and dynamism. Wrap up with a quiz to reaffirm your knowledge on client components.

## Module 4: Server Components
_Unveil the capabilities and edge of using Server Components in Next.js._

- **Understanding Server Components**: Define what server components entail and their architecture, emphasizing state-related functions and limitations.
- **Contrasting with SSR**: Compare server components to traditional server-side rendering and understand when and why server components offer an advantage.
- **Best Practices**: Learn to discern when it's most appropriate to use server components, and explore the "server-land" where certain server-side actions take place. A checkpoint with a pop quiz will round up the module, cementing your understanding of server components.

## Module 5: Page Architecture
_Review and refine the structures that make up your Next.js applications._

- **Maximizing Performance and Simplicity**: Explore the design patterns that allow you to make the most of Next.js features, leading to optimized performance and simplicity in your project structure.
- **Practical Application**: This module revisits the concept of page architecture, providing more complex and practical examples of how to partition components for scalability and maintainability.

## Module 6: Sharing State between Client and Server Components
_Integrating the dual realms of Next.js, bringing together server and client component state management._

- **Identifying the Problem**: Delve into the nuances of managing and sharing state in server components, identifying when it differs from client-side state management.
- **Cross-Component Communication**: Learn how to efficiently pass state and props between server and client components.
- **Working with Cookies and HTTP Requests**: Gain hands-on experience with cookies as a mechanism for shared state, and leveraging HTTP requests to sync state across the server-client divide.

_By the end of this course, participants will acquire a comprehensive understanding of managing state within Next.js 13+ applications, effectively using both the server and client components to build robust, scalable, and maintainable web applications._

Learn the Best Practice and Architectural Patterns Behind React Server Components and Client Side Components

Learn how server components work in Next.js and how you can use them to share state between 
the client and server. 
Learn the best way to architect pages by combining server and client components and improve the overall performance and UX of your apps.

Next.js Complex State Management Patterns with RSC

Build a task manager with React Server Components in Next.js.

Manage state between client and server components in Next.js.

Decipher React Server-Side Rendering and React Server Components.

How to combine server and client components to improve page loading times

How to use props to share state from server to client components

How to take advantage of hydrated state to share state between client and server components

Eric Burel

The **Blazing Fast Next.js with React Server Components** course equips you with the skills needed to master Next.js Static Rendering, coupled with Server Actions but also client-side and dynamic rendering. From foundational concepts to practical implementation, you'll gain a deep understanding of how to leverage Next.js for optimal performance and dynamic content delivery.

## **Blazing Fast Next.js with React Server Components**

### Build a Content Application with Dynamic Data - Newline Commerce

Welcome to the "Blazing Fast Next.js with React Server Components - Design patterns to accelerate Next.js Apps with Static Rendering and Server Actions" course. Throughout this program, we will guide you through the intricacies of Next.js, focusing on Server Actions and static rendering techniques. In this informative journey, we will collaboratively construct a content application named Newline Commerce.

Join us as we explore the foundations of Next.js, implementing dynamic data and server-side actions to bring Newline Commerce to life. This course is your gateway to mastering the art of server actions and static rendering in the context of real-world web development.

### How The Course Works

- The Blazing Fast Next.js with React Server Components course is a 6-module online program where you will delve into Next.js powerful patterns such as Server Actions, Static Rendering, Client-Server Relaying or Partial Prerendering. Learn to deliver fresh content to your end users with optimal performances and cost efficiency.
- Remote: Take the course from anywhere, allowing you to participate from the comfort of your preferred location.
- Self-paced: Tailor the course to fit your schedule. With a self-paced structure, you have the flexibility to learn at your own pace, ensuring a stress-free educational experience.
- Community: Engage with other students in a collaborative learning environment. Share insights, discuss challenges, and expand your understanding within a supportive community.
- Structured: Experience a cohesive and organized learning journey. The course is structured to guide you through each module in a logical and progressive fashion, ensuring a comprehensive understanding of Next.js Server Actions and Static Rendering.

### The Challenge

Navigating the realm of Next.js can be a daunting endeavor for many aspiring developers. As you embark on your journey to master this powerful framework, you may encounter several challenges:

- **Complexity Overload:** Next.js, with its robust capabilities, can overwhelm newcomers. Understanding the intricate balance between Next.js server-centric features and data update requirements requires a structured approach.
- **Dynamic Content Dilemma:** Implementing dynamic content in web applications often poses a challenge, especially when it comes to delivering fresh data efficiently to end users.
- **Performance Concerns:** Ensuring optimal performance while maintaining cost efficiency is difficult. Achieving this balance with Next.js demands a nuanced understanding of its patterns and practices.
- **Lack of Cohesive Learning Resources:** Piecing together information from various sources can be time-consuming and confusing. A structured learning path is essential for a comprehensive understanding of Next.js.

### The Frustration

Newcomers often find themselves frustrated by the lack of clarity and guidance in mastering Next.js. The complexity of static rendering aside from trivial use cases can be a significant roadblock, leading to confusion and hindered progress.

### How This Course Helps

The "Blazing Fast Next.js with React Server Components" course is designed to address these challenges head-on. Through a carefully crafted curriculum, you will gain a clear understanding of Next.js, overcome common hurdles, and confidently apply static rendering with revalidation in your web development projects.


### Unlock the Potential of Next.js in 2024

In the dynamic landscape of web development, staying ahead is key. Here's why learning Next.js in 2024 is advantageous for you:

1. **Enhanced Performance:**
Next.js continues to evolve, offering enhanced performance features that cater to the growing demand for faster, more efficient web applications.
2. **Industry Relevance:**
As of 2024, Next.js maintains its position as a leading framework, backed by a vibrant community and widespread adoption in the industry. Learning it now ensures you align with current development trends.
3. **Scalability for Modern Applications:**
In an era where scalability is paramount, Next.js provides the tools to build scalable applications that adapt to the demands of modern web development.
4. **SEO Optimization:**
Next.js server-side rendering capabilities contribute to improved SEO performance, a crucial factor for ensuring your web applications are discoverable and accessible.
5. **Developer-Friendly Ecosystem:**
With an ever-expanding ecosystem and a focus on developer experience, learning Next.js in 2024 means immersing yourself in a framework designed to streamline your development workflow.

Equip yourself with the skills to thrive in the current web development landscape. Learning Next.js in 2024 positions you at the forefront of technology, offering a competitive edge in your professional journey.

Design patterns to accelerate Next.js Apps with Static Rendering and Server Actions

Learn how to build blazingly fast websites with Next.js. Static rendering is often underrated: it’s very fast, very cheap, but hard to use in advanced scenarios. This course introduces students to personalization with static rendering by using React Server Components, the latest paradigm shift in React. By the end of this course, you'll have learned advanced Next.js concepts like server actions, static revalidation, client-server relaying, or partial prerendering, and you'll know when and how to apply different server rendering strategies in large, production-grade Next.js applications. This course mixes recent advanced concepts like Server Action and static rendering in a way that students won’t find in the documentation. Not only will this apply to any content application but also it will apply to dashboards or multi-tenant SaaS.

Blazing Fast Next.js with React Server Components

Fetch and cache data from a database inside a React Server Component.

Handle form submissions using Next.js Server Actions.

Perform client-side data fetching in Next.js with SWR.

Why the performance of a content application matters and how it's related to different rendering strategies

How to statically fetch data on a server with React Server Components (RSC)

How to update static pages with fresh content via data revalidation in Server Actions

How to perform relaying with SWR, a React Hooks library for data fetching

How to mix dynamic and static rendering via Partial Prerendering (PPR), an experimental feature introduced in Next.js 14

Connor Rothschild

In the [Better Data Visualizations with Svelte](/courses/better-data-visualizations-with-svelte) course, not only will
you learn to enhance beeswarm plots with filters and peripheral elements, but you will also learn how to:

- **Build a Scatterplot with a Tooltip**
- **Build a Rotating Globe Visualization**
- **Build an Interactive Scrollytelling Scatterplot**

If you enjoyed the free course, then check out the [Better Data Visualizations with Svelte](/courses/better-data-visualizations-with-svelte) course below!

svelte

In this free, one hour course, we will learn how to create a dynamic, physics-based beeswarm plot with Svelte and D3. Beeswarm plots offer an elegant and dynamic way to display distributions, outliers, and patterns within our datasets. Whether you're a seasoned developer or a curious beginner, this course will guide you step-by-step through the process of creating a stunning and interactive beeswarm plot that will captivate your audience.

We will start by scaffolding a new Svelte project. Then, we will cover the fundamentals of `d3-force` and the underlying force simulation that arranges nodes, which are represented as circles, in a physics-based, D3 force layout. This approach will automatically position nodes in clusters via a chosen categorical variable and prevent node collisions/overlap. Svelte will handle the rendering of these nodes to the DOM.  

As we progress through the course, we will come across common problems that developers encounter when integrating Svelte with D3's `d3-force` module, and we will learn how to address them using Svelte's reactivity system. Finally, we will dynamically color and size the nodes in the beeswarm plot based on specific dimensions of our dataset.

This course aims to be an introductory guide to creating a dynamic, physics-based beeswarm plot with Svelte and D3 from scratch. By the end of the course, you will know how to bring your beeswarm plots to life with Svelte's declarative syntax and D3's data manipulation and mathematical capabilities.

Learn how to create a dynamic, physics-based beeswarm plot with Svelte and D3. This free course contains three lessons that cover everything from the basics of d3-force for positioning circles in a beeswarm plot (via a force layout) to dynamically styling and sizing circles in a beeswarm plot. By the end of the course, you will have built a simple beeswarm plot that visually summarizes a distribution of data.

Building a Beeswarm Chart with Svelte and D3

Build a dynamic, physics-based beeswarm plot with Svelte and D3.

Explore the basics of D3 force simulations.

Perform updates via Svelte reactive blocks.

How to create a dynamic, physics-based beeswarm plot for the web

The importance of enforcing clear separation of concerns (Svelte for the DOM, D3 for mathematical calculations)

How to integrate Svelte and D3 to create interactive beeswarm plots

Differences between the imperative (pure D3) and declaractive (Svelte and D3) approaches to building modern data visualizations

What problems using Svelte in D3 data visualizations can solve

How to create a beeswarm plots that allow you to better understand the extent and distribution of your data

Costa Alexoglou

In this course, we will dive into the world of design systems. We will learn how they can help developers increase their productivity, create consistency across a company's products, and ultimately speed up the development process.

We will start by covering the fundamental concepts of design systems, then move on to the architecture of a monorepo codebase. We will set up shared configurations for TypeScript, ESLint, and Prettier, and create a foundation package for hosting and distributing design tokens and assets.

Next, we will create a React package with demo components that are styled using our design system's style tokens. We will also create a Storybook package and learn the best practices for developing and documenting components with TypeScript. We will focus on styling our components in two ways: using CSS-in-JS with styled-components and JavaScript design tokens, as well as Tailwind CSS classes.

Finally, we will learn how to create tests for our React components using React Testing Library and AXE, and manage releases using changesets and set up a CI pipeline with GitHub Actions.

This course aims to be a comprehensive guide, or a cookbook, to building a complete company design system from scratch. By the end of the course, you will have the knowledge and skills to create a practical and maintainable design system for any organization.

This course is a comprehensive guide to publishing your first component library and design assets using React, TypeScript, Storybook, Tailwind CSS, and Styled Dictionary. You’ll create a flexible, enterprise-grade design system library that your co-workers will actually enjoy.

Build a Complete Company Design System

Transform design tokens with Style Dictionary.

Manage an enterprise design system monorepo with Yarn workspaces.

How a simple monorepo works with Yarn workspaces

What design tokens are, and how to generate them with Styled-Dictionary

Automate testing for accessibility issues (Axe) and visual changes (Chromatic)

Develop and document our design system with Storybook

How to publish with Github Actions and Changesets

How to provide a Tailwind configuration for other teams

Web Form submitted

Attend a weekly, 2-3 hour live session and receive first-hand instruction from Connor

Over the course of 6 weeks, you will learn to build data visualizations with Svelte and D3 alongside other cohort students.
Each week's 2-3 hour session will be taught in a virtual livestream by Connor. 
During each live session, you will collaborate with fellow cohort students in group activities and exercises. 
Upon completion, you will receive a certificate from newline!

Receive First-Hand Instruction From Connor Rothschild

Join an Upcoming Cohort

The Better Data Visualizations with Svelte course is a comprehensive online program designed to help senior software engineers master the
art of building stunning visualizations that make complex information easy to understand. With **6 modules**, **36 lessons** an nearly 
**10 hours of video content**, this course provides a deep dive into the world of Svelte and D3 data visualizations. Here's  what
you can expect to learn with Better Data Visualizations with Svelte:

After completing Better Data Visualization with Svelte, students now possess the skills to build amazing data visualizations with Svelte and D3.

What the Students are Saying

How to add interactive tooltips to a Svelte globe configuration

How to add filters and hover effects to style svelte visualizations

Connor explains how setting the CSS property `pointer-events` to `none` allows users to hover over elements behind a tooltip in SVG data visualizations.

Hovering over elements behind a tooltip

Connor explains how to use Svelte's dimension bindings , `clientWith` and `clientHeight`, to handle responsiveness.

Making Svelte data visualizations responsive

Connor explains how to map data dimensions to values that can be visually represented with D3's linear scale

D3 linear scales in under a minute

Tell the stories hidden within your data with Svelte and D3.

36 Video Lessons on Svelte and D3

Interactive, Live Project Demos

Complete Project Source Code

### Overcoming Common Challenges When Learning to Build Data Visualizations with Svelte and D3

If you're new to building data visualizations with Svelte and D3, you may have encountered some common challenges that can make it difficult to get started or progress in your learning. Here are some of the problems and frustrations that you may have experienced:

- Lack of clarity on how to select, modify, and join data to create visualizations.
- Difficulty in understanding how to work with Svelte and D3 to create responsive and interactive charts.
- Limited access to code examples and real-world projects to learn from.
- A need for a structured learning experience that builds on the fundamentals of data visualization.
- No community to connect with and learn from other students and experts.

Learning how to build data visualizations with Svelte and D3 can be overwhelming, especially without a clear path or guidance.
This course aims to solve these common problems and challenges by providing a structured learning experience with code examples and real-world projects, access to a community of fellow students and experts, and a clear path to mastering the fundamentals of data visualization.

We hope that this course will help you overcome these challenges and provide you with the skills and confidence to build stunning data visualizations with Svelte and D3.

### 5 Advantages of Learning Data Visualizations with Svelte and D3 in Today's Environment

If you're considering learning data visualizations with Svelte and D3, there are many advantages to doing so in 2023. Here are five reasons why you should consider learning these skills today:

1. **Data is more important than ever**: With the growing importance of data in today's world, there is a greater need for professionals who can effectively communicate insights through visualizations. Learning how to build data visualizations with Svelte and D3 can help you stand out in a crowded job market and make you a valuable asset to any team.
2. **Svelte and D3 are popular and in-demand**: Svelte and D3 are widely used in industry and have become increasingly popular in recent years. By learning these technologies, you'll be gaining skills that are relevant, in-demand, and can help you advance in your career.
3. **The power of declarative programming**: Svelte and D3 are declarative frameworks, meaning that you can focus on what you want to achieve rather than how to achieve it. This makes it easier to create complex visualizations with less code, which can save you time and reduce the likelihood of errors.
4. **Responsive and interactive visualizations**: With Svelte and D3, you can create visualizations that are both responsive and interactive, meaning that they can adapt to different screen sizes and allow users to interact with the data. This can make your visualizations more engaging and effective at communicating insights.
5. **Community and resources**: The Svelte and D3 communities are active and supportive, providing a wealth of resources and opportunities to learn from others. By learning these technologies, you'll be joining a community of like-minded professionals who can help you grow and develop your skills.

By learning how to build data visualizations with Svelte and D3 in 2023, you'll be gaining skills that are relevant, in-demand, and can help you advance in your career. With the power of declarative programming, responsive and interactive visualizations, and a supportive community, you'll be well-equipped to create stunning data visualizations that communicate insights effectively.

Build Powerful, Performant and Interactive Data Visualizations

Learn how to declaratively build responsive, interactive data visualizations with Svelte and D3.
This course contains dozens of lessons, each complete with live coding examples for students to study and build upon. 
By the end of the course, you'll have finished four production-ready, professional data visualizations, and you'll have learned many industry best practices.

Better Data Visualizations with Svelte

Build a rotating globe visualization with Svelte and D3.

Build a responsive, interactive scatterplot with Svelte and D3.

How to create the best data visualizations on the web

The importance of declarative chart construction

How to integrate Svelte and D3 to make more intuitive data visualizations

Differences between 'old-school' and modern approaches to data visualization

What problems a framework-driven approach to visualization can solve

How to create charts that wow your audience

Maksim Ivanov

Fullstack React with TypeScript Masterclass

Steve Belovarich

There are several books about Web Components, but none go into how to integrate Web Components in a typical enterprise web development workflow. This book is designed to help you learn Web Components and integrate it into your work.

In this book, we cover the basics of Web Components, how to code complex user interfaces with custom elements in Storybook, how to test and maintain UI libraries built with custom elements, and how to build web applications entirely with Web Components and browser specifications. It comes with complete code examples. We walk through the entire process step-by-step.

It's taught by Stephen Belovarich, a software engineer and web developer. Stephen has provided what he's learned about UI libraries and web applications while working at Ubiquiti Networks, Norton, Nike, NBC Universal, and Workday, that can benefit other developers, students, and anyone making a website.

The Complete Guide to Building UI Libraries with Web Components

In this book, we will learn Web Components through the lens of a JavaScript developer.

Fullstack Web Components

The basics of working with and manipulating Web Components

The best practices for maintaining a UI library made of custom elements

How to create a micro-library for Web Components with TypeScript Decorators

What problems Web Components can solve in everyday development

How to build web applications entirely from Web Components and JavaScript

Spencer Miskoviak

node.js

In this course, we'll start with the fundamentals of abstract syntax trees (ASTs) and learn the basic mental models. This general AST knowledge can be translated to almost any tool that works with ASTs.

## Why this course?

Understanding and using ASTs unlocks the ability to make sweeping changes in a safe and reliable way in any size codebase.

## Course topics

Throughout this course, we'll have converted source code into ASTs, traversed, mutated, and generated ASTs. With these concepts we'll then explore several practical applications including things like code audits (static analysis), code transformations (codemods), and linting.

### Module 1

We'll learn the fundamentals of abstract syntax trees. 

- What is an AST?
- How to explore an AST
- Examples of JavaScript tools that work with ASTs

### Module 2

We'll learn how to work with ASTs.

- How to turn code into an AST
- How to programmatically navigate any AST 
- How to leverage TypeScript to prevent runtime errors

### Module 3

We'll learn how to statically analyze, or "audit" code to understand the state of the codebase using abstract syntax trees.

- An introduction to an example codebase and refactor
- Understanding the state of the current codebase
- When to use an AST-based tool versus doing something manually

### Module 4

We'll learn how to transform, or "codemod" code from one state to another using abstract syntax trees.

- How to make changes to an AST
- How to change ASTs with [jscodeshift](https://github.com/facebook/jscodeshift)
- How to test a code transform

### Module 5

We'll learn how to write rules, or "lint" code using abstract syntax trees.

- How to create rules for code
- How to create custom rules with [ESLint](https://eslint.org)
- How to test a rule

In this course, you'll learn the fundamentals of abstract syntax trees, what they are, how they work, and dive into several practical use cases of abstract syntax trees to maintain a JavaScript codebase.

Practical Abstract Syntax Trees

JavaScript tools that work with abstract syntax trees

How to parse, traverse, and generate abstract syntax trees

Practical skill set for maintaining large JavaScript codebases

Welcome to Learnify! Learnify is an e-learning application like Udemy where you will find all commonly used features of an e-learning application. I have seen a lot of tutorials on how to create an e-commerce application or blogging application, but I did not find anyone teaching how to build an e-learning application. In this course, you will learn how to create, sell and play courses.

We will be using dotnet framework to build our server. Dotnet framework is an open-source developer platform on which you can create a broad range of applications, especially Enterprise level applications. Our frontend is built on the most popular frontend framework, React. For type safety, we will also be using Typescript. In a big application like this, we need state management for which we will be using Redux toolkit.

In this course, we will focus on almost every aspect of an e-learning application. We will start by discussing and designing properties of a course and setting up an API to fetch them from the database.

We will then take the response and display our courses on the homepage. We will also work on a navigation bar where we will have an option to log in, search for a course, and look at our cart items count. We will also work on filtering, sorting, and pagination features. The homepage will look like this.

![Showing the homepage](./images/homepage.png)

After we have all the information about the course, we will create our description page which will have some more information about the course such as learnings, requirements, description, number of students, level, language etc. This is how our description page will look like.

![Showing the description page](./images/description-page.png)

We are going to use Redux toolkit quite extensively in our course. We will be storing course details, and user's details including the courses in their cart. When a user clicks on the cart icon, they'll be redirected to the basket page which will look something like this.

![Showing the basket page](./images/basket-page.png)

For user registration and login, we will use Identity framework which will take care of all the requirements, such as verifying the email or storing user credentials in the database. We will then work on our frontend to take user's credentials. This is how our login page will look like.

![Showing the login page](./images/login-page.png)

Since we are building a real-world application, we need to take care of payments as well. We will use Stripe to accept payments. We just need to provide Card details and click on Make Payment. Once the payment is successful, user will be able to see purchased courses on their profile.

![Showing the payment flow](./images/flow.mp4)

Once a user has purchased a course, we want them to be able to see it as well. We will start by seeding some sample course data which will be displayed to the users. Later on, we will design our backend to accept course sections and lectures from our client. For video player, we are going to use YouTube's embedded player. This is how the video player will look like.

![Showing the course view page](./images/video-player.png)

Finally, we will see how a user can become an instructor and create a course of their own. We will create one page for basic course details and another one for creating sections and lectures. We will give an option to publish course as well. After the course is published, it will be available to all the customers to purchase.

![Showing the Course Page for details](./images/course-page-1.png)
![Showing the Course Page for Sections and Lectures](./images/course-page-2.png)

I would highly recommend this course for developers who want to become fullstack developers. You will learn how to create a fullstack application from scratch and how to break down and manage frontend and backend work.

In this course, you will learn how to build an e-learning application like Udemy using React and Asp .Net.

The newline Guide to Fullstack ASP.NET Core and React

How to set up React project using Typescript

How to create one to many relationship and many to many in ASP .NET

Using AutoMapper to shape data in Asp .Net

Setting up axios to make API calls in React

How to centralize state in React using Redux toolkit

How to use Identity Framework in Asp .Net

How to deploy Asp .Net projects to Heroku

Mikael Vesavuori

react

storybook

Among developers and architects, "continuous integration and delivery/deployment" (CI/CD for short) has increasingly become the norm for almost two decades. And while frontend development has gone through the framework revolution, going from design to code with the speed expected of CI/CD is still a pain. But it doesn't need to be!

This 10-module course is taught by Mikael Vesavuori, an architect and developer who has helped companies like Polestar redefine their technology and design processes, tooling and ways of working.

In the course, we will create a full component-based React-driven application with Figmagic, underpinned by Storybook, good documentation, and with CI and automated testing.

We will bring the dev-designer collaboration to its current state-of-the-art with a DevOps-inspired life cycle, which could be called “continuous design” (after continuous integration/deployment or CI/CD).

While there is a pre-defined, specific toolset that we’ll use, the end goal of the course is to teach you a wider perspective of what it means to work end-to-end with design systems. Nearly all individual tools are exchangeable: we’re more interested in the capabilities enabling our desired way-of-working than the specific tools chosen to get there.

This course is a comprehensive guide to building a React component library based on a well-architectured design system. You’ll create a full component-based React-driven application with Figmagic, underpinned by Storybook, good documentation, and with CI and automated testing. Learn senior-level system architecture skills for frontend React code; skills you can apply broadly in working on any frontend application.

The newline Guide to React Component Design Systems with Figmagic

How to set up a continuous design pipeline from code to CI/CD, using some of the best services out there

What Figma, Figmagic, and design tokens are and how they enable you to be more productive

How design tokens can function as a contract between designers and developers, setting up powerful new ways of working

The history of design/code tooling and how to argue for process and tooling change

Understand the value of documentation, using Storybook and Figma to document your work

Aleksandra Sikora

next.js

### The newline Guide to Full Stack Comments with Hasura and React

Build and implement a comprehensive commenting system for your website using Hasura and React.  We’ll use the commenting feature to teach technology concepts like Hasura with appropriate authorization, optimistic updates for a more responsive UI, pagination, and publication of library in NPM.

### Why this course

Many developers would like to add a comments section to their website or blog for users to post comments or hold discussions. While it's possible to use existing hosted solutions such as Disqus or Facebook Comments, they often charge a fee and impose their UI leaving little to no control for modifications or customization. 

Another option is to build your own from scratch — which is what we'll do in this course. We’ll use Hasura, which generates GraphQL API from a database so that the backend part is as easy and the least time-consuming as possible. Along the way, we’re going to learn about databases, GraphQL, building UI components with React and TypeScript, and more.
By the end of this course, you’ll have a commenting system added to a website we’ve called, Why comments?, with all comments stored by Hasura. We'll also publish the fetching and adding comments logic as a library to NPM.

This course focuses on building a commenting widget, however, the skills you’ll acquire will allow you to build any fullstack widget you can think up for your application.  You’ll be able to contribute to fullstack React, GraphQL, and Hasura projects at work, in open source, or your own projects. You'll discover that this stack not only eliminates the need for having large teams of backend developers, but it lets your projects move faster.

### Your Instructors

Hi, I'm Aleksandra, and I'm your instructor for this course. I’m the former tech lead of Hasura console and lead maintainer of Bliz.js. This course combines my knowledge in a few areas such as TypeScript, React, Hasura, GraphQL, and general application development.

Build and implement a comprehensive commenting system for your website using Hasura and React.  We’ll use the commenting feature to teach technology concepts like Hasura with appropriate authorization, optimistic updates for a more responsive UI, pagination, and publication of library in NPM.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Explore newline courses

Masterclasses

Tutorials

Fullstack React with TypeScript