Udemy
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
Development
Web Development Data Science Mobile Development Programming Languages Game Development Database Design & Development Software Testing Software Engineering Development Tools No-Code Development
Business
Entrepreneurship Communications Management Sales Business Strategy Operations Project Management Business Law Business Analytics & Intelligence Human Resources Industry E-Commerce Media Real Estate Other Business
Finance & Accounting
Accounting & Bookkeeping Compliance Cryptocurrency & Blockchain Economics Finance Finance Cert & Exam Prep Financial Modeling & Analysis Investing & Trading Money Management Tools Taxes Other Finance & Accounting
IT & Software
IT Certification Network & Security Hardware Operating Systems Other IT & Software
Office Productivity
Microsoft Apple Google SAP Oracle Other Office Productivity
Personal Development
Personal Transformation Personal Productivity Leadership Career Development Parenting & Relationships Happiness Esoteric Practices Religion & Spirituality Personal Brand Building Creativity Influence Self Esteem & Confidence Stress Management Memory & Study Skills Motivation Other Personal Development
Design
Web Design Graphic Design & Illustration Design Tools User Experience Design Game Design Design Thinking 3D & Animation Fashion Design Architectural Design Interior Design Other Design
Marketing
Digital Marketing Search Engine Optimization Social Media Marketing Branding Marketing Fundamentals Marketing Analytics & Automation Public Relations Advertising Video & Mobile Marketing Content Marketing Growth Hacking Affiliate Marketing Product Marketing Other Marketing
Lifestyle
Arts & Crafts Beauty & Makeup Esoteric Practices Food & Beverage Gaming Home Improvement Pet Care & Training Travel Other Lifestyle
Photography & Video
Digital Photography Photography Portrait Photography Photography Tools Commercial Photography Video Design Other Photography & Video
Health & Fitness
Fitness General Health Sports Nutrition Yoga Mental Health Dieting Self Defense Safety & First Aid Dance Meditation Other Health & Fitness
Music
Instruments Music Production Music Fundamentals Vocal Music Techniques Music Software Other Music
Teaching & Academics
Engineering Humanities Math Science Online Education Social Science Language Teacher Training Test Prep Other Teaching & Academics
AWS Certification Microsoft Certification AWS Certified Solutions Architect - Associate AWS Certified Cloud Practitioner CompTIA A+ Cisco CCNA Amazon AWS CompTIA Security+ AWS Certified Developer - Associate
Graphic Design Photoshop Adobe Illustrator Drawing Digital Painting InDesign Character Design Canva Figure Drawing
Life Coach Training Neuro-Linguistic Programming Personal Development Mindfulness Meditation Personal Transformation Life Purpose Emotional Intelligence Neuroscience
Web Development JavaScript React CSS Angular PHP WordPress Node.Js Python
Google Flutter Android Development iOS Development Swift React Native Dart Programming Language Mobile Development Kotlin SwiftUI
Digital Marketing Google Ads (Adwords) Social Media Marketing Google Ads (AdWords) Certification Marketing Strategy Internet Marketing YouTube Marketing Email Marketing Google Analytics
SQL Microsoft Power BI Tableau Business Analysis Business Intelligence MySQL Data Modeling Data Analysis Big Data
Business Fundamentals Entrepreneurship Fundamentals Business Strategy Online Business Business Plan Startup Blogging Freelancing Home Business
Unity Game Development Fundamentals Unreal Engine C# 3D Game Development C++ 2D Game Development Unreal Engine Blueprints Blender
30-Day Money-Back Guarantee
Development Web Development GraphQL

GraphQL for beginners with JavaScript

A practical guide that teaches you GraphQL with JavaScript. Optimally paced, No-nonsense. Learn quickly!
Highest Rated
Rating: 4.8 out of 54.8 (307 ratings)
2,192 students
Created by James Moore
Last updated 9/2018
English
English [Auto], Italian [Auto], 
30-Day Money-Back Guarantee

What you'll learn

  • What GraphQL is & why you should strongly consider using it instead of REST apis
  • How GraphQL eliminates many of the problems REST api's experience
  • How GraphQL Avoids Overfetching Data
  • How GraphQL Avoids Underfetching Data
  • How you can avoid many concurrent REST/HTTP requests by using GraphQL
  • What the N+1 Problem is, and how to avoid it with GraphQL
  • How a GraphQL API is easier to learn, because of it's Discoverability features
  • How to build GraphQL API's from scratch using JavaScript
  • How to consume a GraphQL API in your applications
  • How GraphQL provides the best possible performance for applications
  • How GraphQL makes teams more Agile
  • How GraphQL helps you to avoid Duplicate Server-side code

Course content

8 sections • 57 lectures • 5h 34m total length

  • Preview05:24
  • The Problems with REST
    Preview09:47
  • Preview06:29
  • The Graph in GraphQL
    05:25
  • What is GraphQL?
    04:57

  • First GraphQL Query
    05:51
  • Discoverability
    07:42

  • First GraphQL Server - Part 1
    05:09
  • First GraphQL Server - Part 2
    10:31

  • GraphQL Data types Introduction
    04:34
  • Scalar Types
    05:27
  • Object Types
    04:45
  • Query Parameters
    07:54
  • Variables
    06:02
  • Interfaces
    04:57
  • Aliases & Fragments
    10:09
  • Union Types
    06:51
  • Directives
    03:55
  • Mutations and Input Types
    05:07
  • Errors
    03:11
  • GraphQL without GraphiQL
    10:49

  • Server Planning
    02:01
  • Review Starter Project
    04:48
  • Installing PostgreSQL
    01:20
  • Installing PostgreSQL on Windows
    03:54
  • Installing PostgreSQL on Linux
    02:31
  • Installing PostgreSQL on Mac
    01:59

  • Introduction To SQL
    12:40
  • Create / Setup App Database
    08:30

  • Create a GraphQL HTTP Server
    06:33
  • Add GraphQL 'Books' Field
    07:28
  • Query Books from the Database
    05:09
  • Challenge Review - Adding 'subtitle' & 'ratingCount' Fields
    03:21
  • Add ImageUrl field to book type
    06:43
  • Add authors field to book type
    07:33
  • Optimize with the Dataloader - Part 1
    10:41
  • Optimize with the Dataloader - Part 2
    09:55
  • Add GraphQL 'reviews' Field
    03:06
  • Add 'book' field to Review Type
    14:45
  • Challenge Review - Add 'book' field to Review type
    03:42
  • Sorting Queries
    07:20
  • Create Home Page Query
    03:01
  • Use the Home Page Query in HackerBook Review App
    11:15
  • Create Book Detail Page Query
    03:44
  • Add 'book' field to Review Type
    05:34
  • Add Query to Book Page in HackerBook Review App
    05:31
  • Query 'book' for Book Review Page in HackerBook Review App
    03:17
  • Create Book Review Mutation
    06:57
  • Use the Book Review Mutation in HackerBook Review App
    03:32
  • Add 'searchBook' field to query Google Book API
    05:48
  • Use 'searchBook' field in HackerBook Review App
    03:07
  • Add 'createBook' mutation
    05:26
  • Use 'createBook' mutation in HackerBook Review App
    02:18
  • Add a Global 'search' field
    09:33
  • Miscellaneous & Cleanup
    01:44
  • GraphQL / Versionless
    03:40

  • Final Thoughts
    01:11

Requirements

  • Familiar with Modern JavaScript
  • A desire to learn Awesome cutting edge technology

Description

"Why should I learn GraphQL?"

Obviously, you should use the right tool for the job, right? ... but often, what was the “right” tool, becomes the inferior tool, and frequently you don't even notice...

The most popular way of talking to servers today, is using REST. REST offers a nice, easy to understand way of interacting with other servers, but think about this: Rest was introduced about 2 decades ago… That’s a long time in our world!

Let me ask you a question: how much has software development changed in 2 decades? Heck, how much has software development changed in 2 years? A LOT!

So, I think it’s fair to ask the question:

Do REST api’s still make sense, considering how we write software today?

To answer this question, let’s look at some of the problems with REST API’s:

Problem -> Many Concurrent Requests

Most non-trivial applications, make many concurrent REST api calls, before the app can even render a view… Why is this a problem? It might not be a problem, if the app has an excellent network connection (like our dev machines do), but it can be a horrible problem, on mobile devices with weak connections.

When mobile devices make many concurrent network requests, the response is often very slow, and the app might seem unresponsive... and it may not work at all. This can result in a dismal user experience.

So, how much should you care about mobile devices?

Well, the majority of web traffic, comes from mobile devices, which often have poor network connections… and the next Billion internet users, will primarily be smart phone users... are you thinking about them?

"Does GraphQL suffer from this problem?"

Nope, GraphQL allows you to avoid this connection heavy behavior, by combining all your data queries, into a single server request, which greatly improves real and perceived performance.

Problem -> Multiple round trips to the server (Under-fetching Data & N+1 Problem)

Sometimes, apps needs to fetch some initial data from the server, then the app might need to make subsequent requests, based on the initially returned data. In other words, your app might need to make multiple round trips requests to the server... This results in a slow app, and it can be a real server performance killer.

"Does GraphQL suffer from this problem?"

Nope, with GraphQL, you avoid this type of “chatty” communication, because GraphQL allows you to perform rich/deep queries, that fetch exactly what you need, in one round trip, and you’ll avoid the N+1 problem, that can kill your servers performance.

Problem -> Over-fetching Data

Often, REST apis give you more data, then you need. For example, imagine you're fetching some information about a book, but you only need the books title and description, there's a good chance a REST api gives you all 50+ properties of the book... You're over-fetching data and you end up taxing your servers and clients, dealing with unnecessary data/bandwidth, which results in degraded application performance.

"Does GraphQL suffer from this problem?"

Nope, with GraphQL, you won’t fetch data that you don’t need, instead you create explicit queries, asking for exactly what you need, and the graphQL server provides just what’s needed... Nothing more, and nothing less.

Problem -> Discoverability & Documentation

Imagine you’re a new employee, and you’re trying to figure out what your companies existing REST api’s have to offer. This can be quite a challenge. If your lucky, people are maintaining documentation on the api, but more often, you’ll need to ask someone, and/or dig through the code, just to figure out what's available.

"Does GraphQL suffer from this problem?"

Nope, figuring out a GraphQL API is easy.

How’s this possible?

Many of the features in GraphQL, allow the creation of excellent developer tools such as GraphiQL and Insomnia. Tools like these greatly improve API discoverability, which you'll learn in this course.

With GraphQL, developers can quickly and easily figure out what the api offers, completely on their own.

Problems -> Slow Development

It sucks when you have to wait on other people, to complete your job. Countless times, I’ve been blocked on a task, waiting on a backend developer. This interruption really sucks, especially when I'm in a flow state.

"Does GraphQL suffer from this problem?"

Sometimes, but not nearly as frequently as REST. With GraphQL, often you can add new features, without having to touch the backend... this allows you to move faster and be more agile... How? because you're not stuck, waiting on someone else.

For example, if you’re adding a feature to an existing page, and you need some additional data... with GraphQL, you’ll often just modify your GraphQL query, to fetch the additional data, which usually takes a matter of minutes... With REST, you'll often need custom endpoints created, which slows you down.

Problem -> Custom endpoints & duplicate server-side code

Often, to get around the shortcomings of REST ( multiple round trips, N+1 problem, etc), developers create one off, custom endpoints, which breaks “REST” principles, but it's usually a reasonable compromise for performance… However the problem is, often you end up duplicating code on the server-side, when you’ve got multiple endpoints, that are just slightly different.

"Does GraphQL suffer from this problem?"

Nope, with GraphQL, your server-side code is reused, across vastly different queries by default. For example, if you’ve got some code that fetches information about a book, that same server-side code, will be used when your book queries are for: Purchasing, Selling, Planning, Distribution or any other purpose.

These are just a few of the problems REST api's have... GraphQL was created to solve these problems, and many more, which you'll learn in this course.


Who is this course for?

This course is for developers who are familiar with JavaScript, and are interested in understanding how GraphQL can improve your applications performance, and significantly improve the developer experience.


What Will I learn in this course?

You can think of GraphQL as 2 separate, but related parts:

  • A Query Language and

  • A Server Runtime to satisfy queries

In the first part of the course, we’ll focus on learning the Query Language, which includes topics such as: 

  • Scalar Types

  • Object Types

  • Query Parameters

  • Variables

  • Interfaces

  • Aliases

  • Fragments

  • Union Types

  • Directives

  • Input Types

  • Root types (query & mutation)

  • Error handling

  • Discoverability

  • Tooling / GraphiQL

  • ...

In the second part of the course, we’ll focus on building a GraphQL server, for the courses project app Hacker Book Review. 

We’ll build the server with Node.js and PostgreSQL, and we’ll use excellent and popular open source GraphQL libraries.


What are the pre-requisites for taking this course?

You should be familiar with Modern JavaScript.


What will we be building in this course?

In this course, we’ll be building the GraphQL server, needed for our project app... Then we'll be creating the GraphQL queries needed for the app, and then we'll connect the app with the GraphQL server.

Hacker Book Review - A book review app for hackers like us.


Why should I take this course from you?

My courses are different from most Instructors. I keep things as practical as possible, I try to provide good visuals and animations to help you learn as fast as possible. I put hundreds of hours into making these courses, so they are well thought out and to the point... and most importantly, I don't want to waste your time.


How much content is in this course?

This course has more than 50 videos and over 5 hours of focused content, additionally there are more than a dozen hands on exercises. 


How long will it take to complete this course?

That depends on you... If you're really ambitious, you could probably finish it in a weekend, but the pacing is up to you.


What's the result I'll get from taking this course?

By the end of this course, you'll have a good understanding of what GraphQL is, why you'd use GraphQL and you'll be able to create and use a GraphQL server.

Who this course is for:

  • Frontend and/or Backend JavaScript developers interested in learning how to Create and Use a GraphQL API

Featured review

Maxim Baev
Maxim Baev
7 courses
5 reviews
Rating: 5.0 out of 5a year ago
This is a good course with needed information. Thank you! It's a good choice in comparison with other if you want to listen to course about the Graph QL avoiding all related but unnecessary technologies.

Instructor

James Moore
Software Developer, Consultant & Trainer
James Moore
  • 4.5 Instructor Rating
  • 2,610 Reviews
  • 14,798 Students
  • 3 Courses

James discovered the joy of software development while submerged hundreds of feet deep in the pacific ocean. He liked it so much, he left his career as Navy Nuclear Submariner to learn everything he could about creating software. As a nuclear trained engineer, he figured out how to learn things quickly, which has helped in a career where the learning never stops. Currently he’s an independent software developer, consultant and trainer.

  • Udemy for Business
  • Teach on Udemy
  • Get the app
  • About us
  • Contact us
  • Careers
  • Blog
  • Help and Support
  • Affiliate
  • Impressum Kontakt
  • Terms
  • Privacy policy
  • Cookie settings
  • Sitemap
  • Featured courses
Udemy
© 2021 Udemy, Inc.