Full-Stack React, TypeScript, and Node

O livro tem uma boa didática, eu estou gostando.

Great help for my current project with my cooperate client. Definitely recommend and I found out he also has youtube channel under his name which helps me to understand better.

Got this book a week prior to Christmas and having never build an API in my life and giving up on writing React Code since the old class style way just killed me I really hoped to be able to follow along using this book.And - a month and a half later, I am impressed. I now can confidently write Fullstack Code, and more importantly: write good Fullstack Code.I am personally a more fast-paced, hands-on learner so the writing style & speed suited me well. If you like things explained in extreme detail before applying it to the real world, this book is not for you. It explains a concept briefly and applies it immediately, helping me actually visualize what's being said.Even though it is fast-paced, the author does not forget to tell you about best practices, like how to handle State and Context vs Redux, etc. He also tells you about how things were in the past and how they are now, which makes me appreciate the technology and understand its purpose.However, one does feel like the second half of the book is being rushed. I would have loved to learn more about Redis as a database and not just a simple session storage, the hands-on chat app in the end was easy to build, but the explainations are nowhere near as comprehensive as the first half, although various new technologies were introduced, like TypeORM, Postgres, Redis and smaller libraries like bcrypt.jsAnother thing that's not so cools is that a lot of the code was outdated, mostly React Router, and co. But where it got quite annoying is the apollo code. With apollo v3 coming out a lot has changed and it took a good while to refactor. But in the end, I think it's not the authors fault, but I would have loved to see the code updated on Github..All in all, this is the dream book for pragmatic people, written in simple english, and lots of love and passion.9/10 would recommend to a friend!

As a professional software developer with react I would say that the book is very good written. The examples are not optimised as production ready but this is not the goal of the book. I really recommend this book if you want to start your journey as full stack engineer.

This is a decent book. Given how few current React 17 TypeScript books are on the market, my short review is that it's pretty good overall, but not great (it's better for junior devs than for pros). That's the TL;DR review. Read on for more...This is actually 2 different books in one. The first 10 chapters offer an intro and overview of the various tools/techs described on the cover (TypeScript, React 17, Node, etc.). The writing is clear, the example code is simple and clear, and the author, Choi, methodically builds from the basics to more advanced concepts from ch. 1-10.This half of the book is certainly better for beginners than pros (For example, Choi writes a whole chapter on ES6 features that are already widespread to anyone working in React/JS as of 2022). That said, I wouldn't suggest anyone use this book as their 1st intro to any of the tech involved (i.e. learn TS, React, Node, etc. elsewhere first, if you _really_ want to _learn_ them) - because like most "full-stack" books, there's just too much to cover and not enough time to really learn anything in depth. If you already have a sense of these various technologies, but don't know them WELL, this book is perfect for you (pros will find the 1st half slow and basic, though).Unfortunately, the 2nd half of the book is where things start to break down. Chapters 1-10 are a variety of different topics and small one-off example tutorials. After that, chapters 11-17 all focus on building a single full-stack application based on the things you learned in 1-10, plus a slew of new things: Redis, TypeORM/Postgres, Apollo, Nginx.The ambition is respectable, but the book just moves way too fast (without enough depth) and cuts way too many corners to really pull it off. If you're a pro, this half of the book may be just your speed - but beginners will probably end up a bit overwhelmed, if not totally lost.Here are my main complaints:1) My BIGGEST complaint is that in the 2nd half, the majority of the actual _code_ isn't printed in the book. The author takes a lazy shortcut that always drives me crazy (when any book does it) – "Go to the Github repo and copy the code into a new file named SomeComponent.tsx, then make this edit..."While the 1st half included all the example code right in the book (often including unnecessary things like Create-react-app boilerplate, etc.), the 2nd half forces you to clone the repo, then often just describes what's in that code by line number or class name, etc., rather than actually including it in the book. This is just lazy, and I hate it when authors take this shortcut. Boo.2) Throughout the _entire_ book, there's a sloppy layout issue where almost every code sample that _is_ included is off by a slot in the page layout. Let me explain: Over and over again, there'll be a block of example code, then the paragraph _after_ that code describes the code you just read. It's clear this is a mistake by the way it's written (which always refers to the code as if it's coming up next, but you actually just read it). This is just a glaringly horrendous flaw, and the tech editor should be sacked for letting this go to print (all the editors, really). It may seem minor, but it's a constant distraction that adds confusion.Those could both be seen as stylistic nitpicks (pet peeves), and maybe they are. Here are my 3 main complaints about the actual content:3) Throughout the book, but _especially_ in the 2nd half, the actual TypeScript is not what I'd call "best practices" level code. It _is_ TypeScript, but often it turns out to be the lowest level of actual TS necessary to meet that standard. Rather than make extensive use of actual TS features, many times Choi does things that actually bypass the compiler (extensive use of the <any> type is the most obvious example). He generally applies the minimal amount of actual Type logic throughout his code as possible, beyond what React and the other libraries strictly require. Again, I'd advise you read other books to learn TypeScript itself before reading this.4) As a matter of development approach AND teaching approach, I think the order in which he builds his example app is totally backwards in the 2nd half. The app he builds is a simple Chat Forum (think Reddit-lite). It's actually a pretty decent app for a learning project, and his finished product is better than what I've read/built in a lot of other similar books (above complaints notwithstanding). BUT - as far as teaching goes (and the approach to building a real-world app), he starts with the React client, then builds backwards to the API, then the Node app, then finally the data model. And because he uses TypeORM, the data model itself is never even actually well thought out or explained as a core component of the whole project. Yes, he shows you how to implement data object classes via the ORM, but he barely does anything to explain the foundational logic of why those decisions on tables/columns/constraints/etc. were made.Totally missing in this book is any kind of discussion about the domain layer / business logic. He never really explores what the data model looks like (no UML / relationship diagrams, etc.). To _me_ that's just backwards - it's putting the cart before the horse. To build a _real_ app, you should start with the data models and business logic (user stories, behavior-driven, etc.), and build up from there. Building from the React client inwards is like choosing a car's leather seats and dashboard before you build the engine/drivetrain/chassis) . Obviously the UI is important, but if you build a real app this way you're pretty much gonna fail every time. It's just not a good way to teach building an app - which I'd let slide if Choi didn't promise up-front to teach the reader a production-ready way to do things.5) While the final chapter does a better job than many books of walking the reader through getting their app deployed to the cloud (AWS in this case), it's still way too fast, and actually teaches a few bad habits. Worse, he actually has the reader install EVERYTHING (Redis, Postgres, Apollo, Nginx, and Node) all on a SINGLE small Ubuntu VM (using multiple ports, obvi). It's nice that he makes an effort to include a proxy layer, but why bother if you're just gonna do it the most toy-like way possible? He should have _at_least_ offered an overview of deploying a multi-EC2 architecture (if not containers), with some diagrams and links to more architectural resources for further learning.6) One last complaint - while Choi does include a full chapter on testing in the 1st half, he doesn't even write a single test case (or even mention testing) at any point in the 2nd half of the book. This is, again, a lazy oversight and a missed opportunity (TDD, anyone?)....Oh, yeah, and nothing on CI/CD either. Doh.Final word: This actually isn't a bad book - it's decent (as full-stack books go). Given how few React TypeScript books there are on the market (in late 2022), if you need to learn this stuff, I say buy it. I'm just here to tell you where the weakness are, so you won't be disappointed when you run into them. ...Hopefully Choi will clean these all up and do better in the 2nd edition.