Today the panel and Sean Grove are talking about the future of programming with GraphQL. GraphQL is a new way of building APIs that is more product and frontend focused. All of the panelists agree that it is easy to get exactly what they need with ease when using GraphQL. There are also benefits for backend developers too, since GraphQL lets you see exactly what fields your clients are using. You can also reach out to specific clients who have accessed specific fields before. This is possible because every GraphQL server is introspectable by a computer, and Sean explains how it works. This introspectivity is the basis for an idea he has that allows users to generate realistic fake data before signing up so they know exactly how their application will work before committing, and gives some examples of how it can be used. They all agree that GraphQL is very well formatted and that it provides solutions to real world problems,  The conversation turns to the article How OneGraph Onboards Users Who are New to GraphQL. In particular, they discuss how the GraphiQL Explorer works versus OneGraph. GraphiQL Explorer is an extension that will look at your operations and generate a full React or Bash app from them. Sean talks about the different kinds of operations and how naming them can help you track their performance more easily. There is even a code generator that will flag unnamed queries to help you learn best practices, but won’t stop you from running your code. They talk about the benefits of using OneGraph, a single graphQL endpoint through which you can get all your data from other apps. By wrapping all the APIs in GraphQL, you get access to all the nice GraphQL tooling. They talk about how it works and some of the benefits it can have, such as helping you stay under rate limits. They talk about other interesting tools available for GraphQL and what the explosion of tools means for the GraphQL community. They talk more about how GraphQL fits into the React environment and what they think the future holds.  Panelists Thomas Aylott Charles Max Wood Guest Sean Grove Sponsors NxPlaybook.com - Use code ‘NXDEVCHAT’ for 50% off the official https://nx.dev/React Advanced Workspaces course!  Sentry | Use the code “devchat” for $100 credit Links GraphQLJS CodeShiftCombyHow OneGraph Onboards Users That Are New To GraphQLGrapiQL  Excel GraphiQL ExplorerBashOneGraphHasuraFramerSwift.ui  Picks Thomas Aylott FramerFamous Charles Max Wood Stop-motion animation Christmas movies (like Rudolph the Red-Nosed Reindeer) A Christmas Story Sean Grove Moon HighwayDraftbit SuperMario Land 2 ExplorationSpecial Guest: Sean Grove. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

In this week’s episode of React Round Up the panel works their way through a blog post outlining best practices for React. The first is “keeping components small and function-specific”. The panel discusses the pros of using this best practice and how it relates to the single responsibility principle. This best practice also helps with the next, “reusability is important”. The panel considers this second best practice and points out some of its flaws. It recommends avoiding the creation of new components. The panel explains that by avoiding creating new components it saves time but can also cause problems as you adapt components to fit more projects.  The next best practice is “consolidate duplicate code”, the panel shares their philosophies on dry code and when to consolidate. The fourth best practice is comment only when necessary, Charles explains how he uses comments to help him keep track of things inside his code and the panel warns against using too many comments as it may clog up your code making it hard to read.  The fifth best practice is, “name the component after the function”. The panel explains how it is an art finding a name that is not too generic but is not overly specific; mastering the art of naming is something that will benefit everyone.  Naming relates to the sixth best practice as well. “Use capitals when naming components”. The panel explains the need for convention and advises developers not to go off-book as this will slow down others.  The last six best practices are all self-explanatory says the panel. “Separate stateful aspects from rendering” is nothing new. “Code should execute as expected and be testable”, the panel explains how this allows for trust between developers.  “All files relating to a single component should be in the same folder”, this makes everything easy to find when necessary.  “Use tools like Bit”, while the panel doesn’t use Bit, they share tool recommendations. They also comment on the progress being made it tooling and the future of automated tools. “Use snippet libraries”, the panel discusses favorite libraries and building their own libraries. The final best practice is “Follow linting rules”. Panelists Charles Wood Christopher Reyes Thomas Aylott Sponsors NxPlaybook.com - Use code ‘NXDEVCHAT’ for 50% off the official https://nx.dev/React Advanced Workspaces course!  Sentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Links https://teachablemachine.withgoogle.com/  Practical React Hooks: How to refactor your app to use Hooks  12 React Best Practices You Need to Follow in 2020  https://github.com/nadeesha/saul  https://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundup Picks Charles Wood: White Christmas  Holiday Inn  The MaxCoders Guide To Finding Your Dream Developer Job  Christopher Reyes: https://github.com/microsoft/vscode-eslint  https://www.playingwithfire.co/  Thomas Aylott: test && commit || revert Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Today the panel is discussing how to introduce new tech at work. They agree that it’s important to get input from all teams on the decision, although it will primarily affect the development team. One should also consider the different ways people make decisions, such as through discussion or quiet thinking, and give everyone time to come to a decision. The panel talks about positive and negative examples of how to introduce new tech at work. Thomas believes that it is important to acknowledge your own biases in decision making and to try to avoid them. The React experts discuss the significance of the team dynamic and the necessity of different roles in decision making or if it is better to have an organic discovery phase. This relates to Thomas’ point about personal biases, and he believes that it is important to put people in roles that are opposite of their personality. When making decisions about new technology, it is also important to note that not all decisions require the same amount of input, and they discuss how to measure how much input is required for a decision. The discussion turns to methods for introducing testing, and the panelists talk about their experiences. The rule of thumb for introducing testing is to start simple, have an expected behavior, and test the output to see if it matches. Some other aspects of this discussion to consider are that introducing React Hooks could be considered introducing tech, testing is just a new process, introducing new tools, and budget concerns. Charles shares experience convincing his boss to introduce Agile practices which shows the importance of getting management to see the benefits of the new tech or strategy for themselves. The show concludes with the panel acknowledging that other than introducing tech, introducing philosophies on how to organize your code follows the same patterns as introducing technology. Panelists Thomas Aylott Charles Max Wood Chris Reyes Sponsors NxPlaybook.com - Use code ‘NXDEVCHAT’ for 50% off the official https://nx.dev/React Advanced Workspaces course!  Sentry | Use the code “devchat” for $100 credit Links Vue12 React Best Practices You Need to Follow in 2019SaulTest && commit || revertVS Code ESLint Picks Thomas Aylott Teachable Machine Charles Max Wood White ChristmasHoliday Inn Chris Reyes Practical React HooksAdvertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

In this episode of React Round Up Charles Max Wood interviews Ire Aderinokun at JAMstack conf 2019. Ire works for Buycoins, a cryptocurrency exchange for Africa. She gave a lightning talk, “Headless Chrome & Cloudinary for progressively enhanced dynamic content on the web”. After giving a brief overview of her talk to Charles, Ire defines progressive enhancement for the listeners.    Walking through how progressive enhancement works, she explains how Headless Chrome and Cloudinary helped her with the project she shared in the talk. Ire and Charles consider the blindspot that developers experience because they work on high-end devices and how using progressive enhancement helps those who use lower-end devices.   Ire shares her experience with JAMstack and explains how progressive enhancement works with JAMstack. Charles shares his experience using JAMstack. The episode ends with Ire giving advice and resources to help get started with progressive enhancement.    Panelists Charles Wood Guest: Ire Aderinokun Sponsors Nrwl | Nx.Dev/ReactSentry– use the code “devchat” for two months free on Sentry’s small plan CacheFly Links https://buycoins.africa/Headless Chrome & Cloudinary for progressively enhanced dynamic contenthttps://github.com/ireade/caniuse-embedhttps://ireaderinokun.com/https://twitter.com/ireaderinokunhttps://github.com/ireadehttps://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundupSpecial Guest: Ire Aderinokun. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

"The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood is available on Amazon. Get your copy here today only for $2.99! Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Paul Cowan was a painter and decorator for 30 years until he switched to front end development. He got into React because for him, much of programming didn’t make a whole lot of sense until he read about the flux model, and React Redux was one of the few frameworks that followed the flux model. Spending most of his life outside of the programming world has granted him a unique perspective frameworks like React. He talks about some of his frustrations with React hooks. Hooks can be frustrating because it’s a new paradigm to learn JS, the dependencies array can get bungled, React relies on the order in which hooks are called, and closures can be difficult. Overall, hooks come off at deceptively simple. Paul believes that we shouldn’t need external tooling to keep the dependency array on the right track. To avoid these frustrations, Paul reminds listeners that hooks have to be called in the same order each time at the beginning of your functional components. You also cannot have a hook in an if statement or event handler. It’s also important to remember the declarative nature of React. In production code, updating states is the best way to go.  The panel agrees that it’s good that react has clarified their position on what hooks are supposed to be used for, and how we are beginning to see the limitations of React hooks. They discuss unit testing with hooks and how to determine when the React framework becomes too big. They talk about some of the new features that are coming out and how they benefit new developers. When mistakes do happen, Paul talks about how he determines what went wrong. If you want to get advice from other humans, they suggest consulting StackOverflow, ReactiveFlux, and IRC chat. When you do consult these sources, it’s important that your problem is reproducible so that it’s easier for people to help you out. It’s also important that you learn how to ask questions.  The show finishes with them discussing how they handle changes in the industry. They have found that reusing components is difficult across Angular and React. They talk about the positive ways that React went version to version. They discuss complexity management in apps. The panel talks about some ways to do things in React without hooks, but also caution that avoiding the popular thing can also get you into trouble.  Panelists Thomas Aylott Charles Max Wood Chris Reyes Guest Paul Cowan Sponsors Nrwl |  Nx.Dev/ReactSentry | Use the code “devchat” for $100 credit   _______________________________________________________ "The MaxCoders Guide to Finding Your Dream Developer Job" by Charles Max Wood will be out on November 20th on Amazon. Get your copy on that date only for $1. _______________________________________________________ Links Flux modelReact ReduxuseReducerFrustrations with React HooksSolutions to Frustrations with React HooksESLintNext.jsRelaySeleniumStackOverflowReactiveFlux Picks Thomas Aylott Shada Charles Max Wood The MaxCoders Guide to Finding Your Dream Developer JobIt’s A Wonderful LifeMr. Kreuger’s Christmas Chris Reyes Netlify React Hooks deep diveAirPods Pro Paul Cowan Solutions to Frustrations with React Hooks Stay fit Special Guest: Paul Cowan. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Vitali Zaidman works for the WellDone Software consultancy. He has worked with a lot of different technologies, but currently works with React. In a recent React meetup, he talked about React performance. When someone says that React is not performant, Vitali disagrees and says that it is very performant unless you do certain things. If your React application is slow, it’s down to the tools you use. The panelists all agree that premature optimization is the root of all evil. The difference between premature optimization and good architecture comes down to experience. It is important to be data driven and consider performance a business environment. Vitali believes that performance is a feature and should be treated like any other.  The panel discusses accessibility versus internationalization. Launching to one language is different than launching to one set of abilities. While you don’t need to internationalize on day one, don’t make it impossible to internationalize. They talk about how creating a timeline of changes in your project can help you pinpoint where your performance issues came from. It is also important to remember that developers have strong computers, while users generally do not. As you build, check your product on slower devices to make sure that it works for your users.  Vitali talks about his tool why-did-you-render, which will notify you of avoidable re-renders. He also talks about considering why you are choosing to use React and whether or not is the correct choice for your project. The panel discusses their feelings on pure components. They talk about the importance of code review and manual QA since not everything can be automated, again suggesting having a slow computer or phone in the office to test as you go. They also agree that it is important to understand how your library works. They talk about the huge amount of work that is required to maintain an open source project, and how development is a team effort if you want to create sustainable software. The show concludes with Vitali talking about a performance issue he encountered and how he recognized it, diagnosed the problem, and fixed it.  Panelists Thomas Aylott Lucas Reis With special guest: Vitali Zaidman Sponsors Nrwl | Nx.Dev/ReactSentry use the code “devchat” for 2 months free on Sentry’s small plan Ruby Rogues Links KnockoutWhy did you renderFusion.js: A Plugin-based Universal Web Framework - Leo HorieReact Element's 'Parent' vs Rendered ByHow To Reduce Unnecessary Re-RendersWhy Performance MattersPerformance Impact CalculatorWelldone Software Follow DevChatTV on Facebook and Twitter Picks Thomas Aylott: Face-API.jsReact force graphReact 3 Fiber Lucas Reis: Opendoodles.comAdopting Optimizely at Compass Vitali Zaidman: JSJ 402: SEO for Developers with Vitali ZaidmanSpecial Guest: Vitali Zaidman. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

In this episode of React Round Up the panel interviews Chris Biscardi. Chris is now working with Gatsby. He shares a bit about his background and how he got into programming. Chris explains his move from Kubernetes and Docker over to Gatsby. His overall drive is to increase leverage for other people and what drew him to these projects.  Chirs explains what Gatsby is and what it has to offer to React developers. Gatsby is like a creat react app which is attached to a static site generator that has an API that allows you to pull in data from anywhere. Also, by using Gatsby developers do not have to operate alone, they get the whole Gatsby ecosystem to help them.  The panel considers Gatsby and if it would be a good way for developers to learn React. Chris explains with Gatsby’s documentation it would be great for learning React. The panel believes it would be a good place to learn because of the hands-on goal-oriented work engaged in when using Gatsby. Chris shares what developers get when using Gatsby and why it appeals to programmers today.  Chris explains what Gatsby themes are and how they are more powerful than CSS themes. The panel discusses how to use themes and how to write them. ThemeUI library is shared and Chris explains how it works. They consider what is next for both Gatsby and React.  Panelists Lucas Reis Charles Wood Thomas Aylott   Guest: Chris Biscardi Sponsors Nrwl | Nx.Dev/ReactSentry– use the code “devchat” for two months free on Sentry’s small plan Adventures in AngularCacheFly Links JSJ 386: Gatsby.js with Chris Biscardi  https://www.gatsbyjs.org/https://www.christopherbiscardi.com/Views on Vuehttps://vuejs.org/https://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundup Picks Lucas Reis: Don’t procrastinate Charles Wood: Find solid people in your life Get away Chris Biscardi: Chris's Discord Thomas Aylott: Real relationships with real people outside of work.  Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Monica Lent has been interested in software from a very young age, and made her first domain name when she was 9 years old. She studied legacy languages Latin and Ancient Greek in university, but ended up keeping her college development job and going into software. She recently left her job and founded a startup, analytic tool designed for bloggers designed around affiliate marketing. She talks about some of the lessons she’s learned, including how to sift through data and how to make it useful for people.  Monica gave a talk at React Finland and she first applies some of her principles from that talk to what she’s learned founding a startup. One of the main differences she’s found is a small startup has different needs and levels of stability than a business. In early stage business, you have to decide where you want to invest in quality and where you shouldn’t be investing. For example, her primary focus is on her algorithm that runs the tool, and UI is less of a priority. In a large company, this might be structured differently. The panel discusses how to distill the priorities from the project manager so you know where to spend your time, something that takes a lot of experience and failure. They agree that if something is business critical and will cause the business to lose money if it fails, those things should be a top priority.  Second, the panel discusses the merits of different practices such as whether or not to deploy on Friday and having engineers on call. In Monica’s React Finland talk, she talks about the importance of constraints, which can help with these kinds of decisions. She explains that instead of thinking of architecture as something super abstract, think of it as enabling constraints, as picking ways to do less and end up with code that is safer to run, longer lasting, and has fewer bugs. Thomas shares how he used to oppose constraints and architecture, and how he changed his mind. They discuss the importance of automation over documentation for building sustainable code.  Third, Monica explains her opinion on how copying and pasting code instead of adding dependencies is a positive constraint. She prefers this method most of the time but not in all cases because it keeps your code flexible and avoids unnecessary specialization. However she is not advocating for copy/paste over dependencies in every situation : rather the point comes down to using copy/paste instead of inappropriate coupling. Sometimes, when you create an abstraction and combine two pieces of code, this new combination makes code more brittle than it would be otherwise Components put in the shared folder almost never leave. This causes the  component to become very specialized and not work in all scenarios. The panel discusses where this method may not work. Thomas talks about some of his favorite tools for simplifying complexity, React Hooks and Relay. Monica and the panelists discuss the merits of using TypeScript and proper methods for coupling code. Fourth, the panel discusses how so much of programming is dealing with other people and the importance of keeping your ego out of it when designing constraints, especially since developers hate other developer’s abstractions. They debate whether pride is a characteristic of junior or senior developers. They note that it is easier to get prideful and opinionated when you’re not working on a team. Thomas believes that if you aren’t working on a big team, you should force yourself to talk to people with opposing positions. The show concludes with the panelists agreeing that it all comes down to the balance between priorities and making things work. Sometimes we can get so focused on making something work that we lose sight of what actually matters. They agree that  collaboration generally yields better results than leaving it to one person. Monica talks about the importance of senior developers nurturing their team by leading from behind to help people come up with their own solutions. The panelists talk about different methods they’ve seen for doing this.    Panelists Leslie Cohn-Wein Thomas Aylott Lucas Reis With special guest: Monica Lent Sponsors Progress KendoReact | Try now for FREE: kendoreact.com/reactroundupSentry use the code “devchat” for 2 months free on Sentry’s small plan Views on Vue Links Monica's React Finland talkNarcissistic design talkA Philosophy of Software DesignReact HooksRelayTypeScriptWebpackgRPCPrettier 7 Absolute Truths I Unlearned as a Junior Developer Follow DevChatTV on Facebook and Twitter Picks Leslie Cohn-Wein: Xochimilco, Mexico City, MexicoList of CSS mistakes Thomas Aylott: Get the Truth book Lucas Reis: LoveveryZero Fasting app Monica Lent: The Mom Test by Rob FitzpatrickSpecial Guest: Monica Lent. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

In today’s show, Chuck talks about the recent Twitter thread about 10x engineers. He goes through each of the points in the tweet and talks about each of them in turn. There are only two points he sort of agrees with, and believes the rest to be absolute garbage. One of the issues with this tweet is that it doesn’t define what a 10x engineer is. Defining a 10x engineer is difficult because it is also impossible to measure a truly average engineer because there are many factors that play into measuring productivity. Chuck turns the discussion to what a 10x engineer is to him and how to find one. A 10x engineer is dependent on the organization that they are a part of, because they are not simply found, they are made. When a 10x engineer is added to a team, the productivity of the entire team increases. Employers have to consider firstly what you need in your team and how a person would fit in. You want to avoid changing the entire culture of your organization. Consider also that a 10x engineer may be hired as a 2x engineer, but it is the employer that turns them into a 10x engineer. Overall, Chuck believes these tweets are asinine because it’s impossible to measure what makes a 10x engineer in the first place, and hiring a person that fits the attributes in the list would be toxic to your company. Panelists Charles Max Wood Sponsors Progress KendoReact | Try now for FREE: kendoreact.com/reactroundupSentry use the code “devchat” for 2 months free on Sentry’s small plan iPhreaks Links 10x engineer Twitter thread Follow DevChat on Facebook and Twitter Picks Charles Max Wood: Copyhackers.comGood to Great by Jim Collins Keto diet Podcast MovementAdvertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Dean Radcliffe has been web developing since the table tag was the new hotness. His interests include his wife and two kids, music, sports, and he likes to say he helps people make whatever they can dream of. Since starting to move towards the frontend, React has been his weapon of choice, which he got started with in 2014.  Dean works at G2.com, a software review site. They are developing a review form, which requires the code to react to events. For example, a person’s position in the company would affect what questions they see, so the form needs to react to which box is checked. Dean talks about the use cases for building a reactive form and what kind of things are going to happen when you fill in an input. For his form, the input will be remembered, and they want to increase the user’s involvement with the form through incentives. To accomplish this, Dean uses component driven development with Storybook. Storybook is a tool available for React and other frameworks, which lets you jump directly to each state you want to view instead of having to go through them all one by one. Basically, it gives you shortcuts directly to the visual states of your components. These states facilitate development and the feedback cycle going back to the designers, allowing them to see more than just the finished application and enabling them to circumvent mistakes.  Storybook relates to reactive programming because component driven development lets you discover the API and what sets of props are necessary to put this component into each possible state that can be displayed. Dean does not use it as a test environment on his team, but it does help them write unit tests. It has an addon that lets you write unit tests in Storybook, but he hasn’t used it. Dean compares where reactivity and Storybook come together by comparing it to a thermometer.A thermometer will get readings over time of discrete values, and that timing is how people experience your components. You can create an observable of those states, and Storybook Animate ties them together. Your components, however, are still your responsibility. Dean talks about how he creates the observables. The observables are hardcoded, but the great thing is you don’t need to know where it came from. Dean describes how the observables are connected to the components. Dean feels that having this dynamic feed cycle makes it kind of fun to write tests. There is also a function called After which creates a set time out, which creates an observable of that value over time.  Dean talks about his other tool, RX Helper. RX Helper provides an ‘after’ abstraction, and an event oriented layer in React. RX helper allows you to listen for custom events raised from the individual components of a form, and you respond to those events with observables, and the observables produce values over time.The goal of RX Helper provides some transparency and makes it easier to try out concurrency designs. The show concludes with Dean talking about some of the changes he’s made to his tools and how he came up with the idea.  Panelists Charles Max Wood With special guest: Dean Radcliffe Sponsors Progress KendoReact | Try now for FREE: kendoreact.com/reactroundupSentry use the code “devchat” for 2 months free on Sentry’s small plan My JavaScript Story Links Knockout.jsG2.comStorybookStorybookAnimateRX HelperMeteor JS Follow DevChatTV on Facebook and Twitter Picks Dean Radcliffe: Follow him on Github and Twitter  Kent C. Dodds@davidkpiano XStateGangstagrass Charles Max Wood: St. George MarathonThe 360 Degree LeaderSpecial Guest: Dean Radcliffe. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Dinesh Pandiyan is a developer from India. He started as a backend engineer and then moved to frontend. Currently he is working for ThinkMill in Sidney, Australia. Today Dinesh and the panel are talking about devtools and progressive SSR. Dinesh got started with React Redux. The panelists talk about their experiences using primarily Redux for projects. Dinesh talks about his transition from backend to frontend and how it’s a totally different world. On the backend he was working in Java and it ran on a server, but on the frontend, code runs in a browser and the browser is very different for each user. Frontend development is tricky because you don’t know where your code is going to run. One of the trickiest parts of frontend development is debugging something in production. Unless you have good logging tools, you won’t know what’s going on. Debugging this stuff when it’s running on client browsers is hard, but when you’re in development mode your own browser you’ve got handy tools.  They talk about some of the tools in React, and agree that console.log is the greatest debugging tool of all time. Dinesh talks about some of the most surprising features about React dev tools. You can benchmark your preferences and identify weaklings in your project, which are things that slow down your application or things that might slow it down. On an application level, you have to build a mental model of how the data flows from the top, where things change, etc, and dev tools can help you build that pretty easily. They talk about how things had to be done before great React tools. In fact, Dinesh chose React just for the devtools. They talk about how the dev tools for React compare to Java. The most important thing is that you have a good debugger that can stop where you want it to.  They transition to talking about the differences between SSR and progressive SSR For SSR (Server Side Rendering), rendering happens on the server and you send it to the client. CSSR (Client Server Side Rendering) is when all the rendering happens on the client’s side. PSSR (Progressive Server Side Rendering) is where you render small chunks on the server and then send it to the client bit by bit. They talk about how this has been occurring from the beginning of the internet. This concept is similar to microfrontends.  Dinesh gives advice on how to implement PSSR. He says that when you surver render, it loads on differently. Your framework has to do one complete pass of the histiema, so this means you cannot send things to the client until the whole histema is designated. To beat this they’ve been doing a mix of SSR and CSR, with the header, body, and non critical content rendering on the client side. PSSR bridges the gap between SSR and CSSR. How do we make it real and how do we use it? The panel discusses ways to make PSSR a reality. Dinesh has been experimenting with it with extra services, and he gives his method for doing it, emphasizing the importance of where you divide your code is very important, it has to be in sequence. CSS Grid solves this problem, so you could render things out of order and the browser puts it in the right spot. They talk about other ways to get around it. Lucas shares some of the difficulties he’s encountered with streaming and rendering. They talk about the new feature for the Phoenix framework for Elixir, Live View Now. For this feature, you don’t need client side frameworks to generate dynamic content and it enables two way streaming. However, it does not scale well for extremely large apps. They talk about some of the tradeoffs for using this feature. They conclude by discussing the gap between website optimization and device performance.  Panelists Thomas Aylott Dave Ceddia Lucas Reis With special guest: Dinesh Pandiyan Sponsors ​Progress KendoReact | Try now for FREE: kendoreact.com/reactroundup  Sentry use the code “devchat” for 2 months free on Sentry’s small plan My JavaScript Story Links React ReduxConsole.log  PuppeteerWebpackDatadog  CSS GridTransport headersPhoenixElixir Follow DevChatTV on Facebook and Twitter Picks Lucas Reis: Ben Hoyt Wholesome Learning ElmCast iron skillet Thomas Aylott: 6 Lessons Children Need to Learn Dinesh Pandiyan: To-Do List app David Ceddia:  On the Utility of Phoenix Live ViewSpecial Guest: Dinesh Pandiyan. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Jeffrey Cross and Victor Savkin are the cofounders of NRWL. They used to work together at Google on the Angular team and started NRWL so that people could use Angular 2 well. Victor talks about NRWL’s tool NX, which came from the desire to help people develop like the tech giants. Companies like Google and Facebook develop in the same repository so that people can collaborate. NX is an open source tool for this collaborative development, known as a monorepo.  Monorepo style development is a way to develop applications such that you develop multiple projects in the same repository and you use tooling to orchestrate development. The tooling connects everything, makes the experience coherent, and ultimately makes the monorepo style work. The benefits of monorepo development are that the tool chain enables you to interact with different projects in the same fashion, collaboration is more effective, and multiple apps can be refactored at once.  The panel discusses what situations are appropriate for a monorepo and which are not. Victor believes that any company with more than one large product would benefit from a monorepo, but it would not benefit a company that wants to keep their teams distinct from one another. The hosts express some concerns about implementation, such as scaling and creating the infrastructure. Victor assures them that a monorepo is inherently scalable, and most tools will work for years and years. As for the infrastructure, companies like NRWL specialize in helping companies set up monorepos, and NX provides many of the necessary tools for a monorepo. A monorepo can be tailor-made to fit any size of company, and can even be created for already established projects.  If you wanted to start your own monorepo, you can start by taking a project or handful of projects and moving them to the same place. As you develop, pull pieces of your applications out and put them into packages. Victor cautions that monorepos tend towards a single version policy, so you’ll want to get on the same version as your third party dependencies before you move your next application in. You can move things in and temporarily have different versions, but plan to make them the same version eventually. Victor talks about how the CI in a monorepo setup looks different, because you run tests against everything that might be broken by that change, not just the project its in. So, when you change something in your code, you need to consider what other pieces of code need to be taken into account. A monorepo does make dependencies more explicit, and when you have good tooling it’s easier to see the effect the changes you make have. This is where NX excels. One of the big advantages of NX is that it allows you to partition your application into packages with a well defined API, and prevents the project from becoming one giant node. You can then interact with those packages, and see what happens when you change something. You have a lot more clarity of how your app is partitioned and what the restraints are. NX allows you to share stuff between the front and backend.  The show concludes with the conversation turning to Jeffrey and Victor’s consulting work. They talk about some of the interesting features that are happening outside of React that we are missing out on. Victor is very impressed with tooling in the Angular community. He talks about a tool called Console for NX. They end by talking about the schematic powered migrations in Angular.  Panelists Leslie Cohn-Wein Dave Ceddia Lucas Reis With special guest: Jeffrey Cross and Victor Savkin Sponsors Sustain Our SoftwareSentry use the code “devchat” for 2 months free on Sentry’s small plan My JavaScript Story Links NRWLAngularNXBuilding Fullstack React Applications in MonorepoAngular CLI Follow DevChatTV on Facebook and Twitter Picks Lucas Reis: Dear StartupCryptocurrencies video by 1Blue1Brown Dave Ceddia: Help, I’ve Fallen (into code) and I Can’t Get Up!Code maps frontend Victor Savkin: Ember MugHeal the Internet Jeffrey Cross:  lululemon Commission pant Leslie Cohn-Wein Why I’m No Longer Talking to White PeopleEverylayout.dev Special Guests: Jeff Cross and Victor Savkin. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Zain Sajjad is a frontend developer at his company Peekaboo Guru, an app built in React. The show begins with Zain explaining why he chose to build Peekaboo Guru in React. Ultimately, he chose React for its composability and reusability. He talks about how much data is shared between his React and React Native applications. Zain explains what he means by a container since he is not talking about Docker, and how he has the app organized. He talks about the differences between routing and navigation between React and React Native. When approaching these differences, he breaks things down into components, containers, and platform, paying careful attention to how they work together. This differentiation can actually help a lot with testing as well.  The panel asks Zain about choosing between React navigation and React Native navigation, but Peekaboo Guru uses both React navigation and React Native navigation, but on different platforms. They use each on different platforms because React Native doesn’t let you configure it with existing native apps. He talks about the pros and cons of each, but prefers React Native navigation. They decided to use both because Peekaboo Guru is based in a region where there aren’t many users with high end devices, so this decision was made to accommodate them.  They then discuss how to approach making important software decisions with a team and how to make an objective decision away from your bias against old or new technology. Zain believes that you have to step out of your comfort zone and think of the team rather than yourself. They talk about the thought process of making these decisions, especially concerning who is going to do the maintenance. They talk about ways to give good feedback even when the maintenance is not going to be your responsibility and the importance of staying humble. Making decisions like this can be tricky because it is where hard skills and soft skills intersect.  The panel moves on to talking about machine learning, and Zain talks about his experience using it to screen comments on Peekaboo Guru. Machine learning is getting more and more common, with giants like Snapchat and Facebook doing it as well. There is also a lot of machine learning on our phones that we don’t think about. Zain gives advice for those who want to start learning about machine learning. He advises people to think of it in two parts, preparing a model and using a model. Thomas feels that machine learning is more approachable than it first appears to be, though it is always related to how good the abstraction is. They compare machine learning to AI and a database to assist with understanding.  If you want to play around with AI, Zain counsels that programming has the addiction of success. Keep your tasks small to keep getting those tastes of success. He advises that it is best to start by using the inference part and then make a model. He talks about different tools to help with the math. The show concludes with the panel agreeing to his counsel and reminding listeners that failure is trying to go from 0 to perfect in one step.   Panelists Thomas Aylott Lucas Reis With special guest: Zain Sajjad Sponsors Adventures in BlockchainSentry use the code “devchat” for 2 months free on Sentry’s small plan My Angular Story Links Peekaboo GuruReactReact NativeReact Native NavigationReact NavigationSQLTensorFlowFun Fun FunctionImmer.js Follow DevChatTV on Facebook and Twitter Picks Lucas Reis: Ember.js3Blue1Brown Thomas Aylott: Rite in the Rain notepadSpecial Guest: Zain Sajjad. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Episode Summary Today’s guest is Farzad Yousef Zadeh, a developer from Iran with a unique path into computer programming. He started by studying astrophysics and aerospace engineering in college, then dropped out in his last semester because it wasn’t the right path. He then taught himself to code, working mostly in web programming and frontend development. Despite his change in course, Farzad remains passionate about observing the night sky.  Farzad is here today to talk about the ideas in his talk Explicitness and Consistency in UI, where he talks about the difficulties of developing a user interface and how the experience can be improved by using state machines and state charts. He talks about his inspiration for the talk and how he has implemented state machines and state charts into his work.  The panel backtracks and talks about the definition of state machines and state charts. A state machine, from an academic background, is a model for computing something. It's for managing and controlling, taking over branching and managing a finite amount of state declaratively. State machines are not so much about sharing or reusing, but about how your communicate a certain behavior. Despite the fact that event driven programming permeates the programming consciousness, thinking about state charts and state machines is actually more natural than it first appears. The panel explains how it’s the same principle as whiteboarding to solve a problem. Lucas asks how state charts are different from pure React. Farzad talks about how it’s important not to just treat your static states as first class, but also the transitions between them. Otherwise, you would end up with something that looks like a map with cities and towns, but no roads. Using statecharts and state machines makes testing an application much easier, and in some ways you let the machine test itself. The machine will know what to do with your states because you define the path, and the machine will take the path for you.  They again talk about the difference between state machines and state charts. A state machine defines a finite set of states and defining the events that the machine can take and respond to when transitioning from state A to B. If you use only this, you will encounter a snag called ‘state explosion’ because not non-concrete things cannot be modeled. So, state charts were invented to compensate for this. A state chart brings the idea of an extended state, or the context and data you need to hold and reason from.  Farzad talks about other types of machines and supports that exist for branching, entry actions, and exit actions. This is similar to the use effect hook in React. He gives examples of where you would use this logic and how it would be worked into frameworks. Farzad talks about how your machine is just a definition, a declarative model of how something is supposed to behave, and how having that separation between the definition of the logic and behavior vs the implementation of API has given us so much more freedom and portability The panel talks about how using state machines and charts is an investment in the long term maintainability of your code. They agree that using state machines and charts makes it easier to communicate with other developers, new team members, and even non developers. They talk about Cerebral.js and its contributions and model.  As with everything in programming, state machines are not a silver bullet and don’t work in every situation. Farzad talks about situations where state machines can be unhelpful. It is still valuable to consider state machines and charts because it forces you to dedicate time thinking and organizing your thoughts so that you can build something maintainable that won’t just be thrown away. The panel discusses how thinking things out before starting to code can be beneficial. They finish by talking about how React Hooks has started them on the path to implement state machines and charts into their code.  Panelists David Ceddia Lucas Reis Leslie Cohn-Wein Thomas Aylott With special guest: Farzad Yousef Zadeh Sponsors Sustain Our SoftwareSentry use the code “devchat” for 2 months free on Sentry’s small plan My Angular Story Links Explicitness and Consistency in UIDavid Khourshid xstate libraryRRU 069: The State Machines in React with David KhourshidState machineState chartCerebral JSOrigami by FacebookElm  The GaryVee Content ModelOvermind JS Follow DevChatTV on Facebook and Twitter Picks David Ceddia: Reverse Interview Thomas Aylott: Machine Learning Zero to HeroTensorFlow at Google I/O 2019 channel Lucas Reis: How to Learn D3.js Leslie Cohn-Wein: Write Fewer Tests! From Automation to Autogeneration by David Khourshid Farzad Yousef Zadeh: Don’t Let Architecture Astronauts Scare YouSpecial Guest: Farzad Yousef Zadeh. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Episode Summary Today’s guest is Håkon Krogh, and the panel is discussing his talk on lightning fast SSR React apps given at React Amsterdam. He gives a brief overview and defines his use of the Uncanny Valley (called the Valley of Lies in his talk). In this instance, the Uncanny Valley in programming occurs when everything in a website or application looks great, but none of the buttons work or users simply can’t connect. This is especially common when users try to connect to a site or app with their cell phone rather than a computer. The panel discusses what can be done. It’s important to begin by measuring the lag in your applications. Designing the progressive loading experience first is suggested as a solution, as well as organizing what loads first and using React and HTML for different parts of the app. It’s important to realize that some tools don’t work in every situation. The panel talks about the merits of Next.js.  Next they talk about what kinds of applications require SSR that make the loading slow. They discuss the importance of SEO ratings and how it can affect your rank in a Google search. Services like Lighthouse can give you an SEO rating so that you can improve.  Håkon and the panel talk about other ways to improve on the Uncanny Valley. It’s important to make sure that users have a way to use your site even if they’re stuck in the Uncanny Valley. One way to do this is to provide fallbacks so that if your React isn’t working, the site is still usable. They discuss the merits of micro frontends, using SSR for only part of the app, and reducing bundle size. Unfortunately there is no silver bullet, so solutions will vary by what you’re building.  In spite of these setbacks, one of the great features of React is you don’t have to do everything in React. They discuss the emerging idea of shipping different JavaScript for different things and talk about some of the React-like alternatives available. Bridging the Uncanny Valley is vital because it is the reason many people are afraid of their computers, and a good user experience can make people gravitate towards your product. The show concludes with Håkon talking about things in the React community that are piquing his interest.  Panelists David Ceddia Thomas Aylott With special guest: Håkon Krogh Sponsors Sustain Our SoftwareSentry use the code “devchat” for 2 months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT Links Håkon Krogh’s React Amsterdam talkNext.jsSEO ratingsGatsbyLighthouse  Apollo GraphQLnpmTypeScriptPreactInferno.js Follow DevChatTV on Facebook and Twitter Picks David Ceddia: FXmicrojs.com Thomas Aylott: Mindset by Carol Dwek Håkon Krogh: Bundlephobia  Special Guest: Håkon Krogh. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Episode Summary Andrey Okonetchnikov is a specialist in frontend architecture and design systems. He runs his own consultancy and made the package lint-staged. Andrey has been in programming for 20 years and talks about his background, how he got into React, and why he started component-driven.io. Andrey has always been interested in design tools and design systems, it just wasn’t the right time because the right tools weren’t available.  Since Andrey has been working in frameworks for 20 years and has watched them come and go, Lucas asks Andrey how he has seen the communication between developers and business owners evolve over that time. Andrey reflects on his first conference talk and believes that not much has changed, even if the tools have. His perfect interaction between developers and business owners would be codeless, and would instead draw his design on a napkin.  This idea ties into Andrey’s ideas of creating things in primitives instead of wireframes. He relates his idea to the pattern philosophy of the building architect Christopher Alexander, the idea that specific design problems require specific solutions. He talks about since everything in React is a component, we can encapsulate a design decision into a component.  Since the power of components is redistributing knowledge, the panel discusses how components promotes reusability, accessibility, and sustainability in code. However, Frankenstein components are the dark side of reusability. Andrey talks about the dynamic view of a design system that does reuse and how to make sure that it evolves cleanly. They discuss how much of can be planned in advance the first time you’re creating a component versus how much should you not try to think too far ahead and fix it when it comes up. They all agree that early abstraction can be almost as destructive as early optimization Panelists Leslie Cohn-Wein Thomas Aylott Lucas Reis With special guest: Andrey Okonetchnikov Sponsors Sustain Our SoftwareSentry use the code “devchat” for 2 months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT Links Lint-staged  Component-driven.io PrimitiveShape Up bookCreate prototype using AI : Airbnb testMonica Lent twitterWireframe  jQueryCoffeeScript  Backbone.jsChristopher Alexander Follow DevChat on Facebook and Twitter Picks Leslie Cohn Wein: Frontend Masters Intro to Vue courseGatsby.js glossary Thomas Aylott: Designing Web Interfaces by Bill Scott Lucas Reis: Shape Up bookMIT open courseware Andrey Okonetchnikov: Components.aiSpecial Guest: Andrey Okonetchnikov. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors React Native RadioSentry use the code “devchat” for 2 months free on Sentry’s small plan GitLab | Get 30% off tickets with the promo code: DEVCHATCOMMIT Panel David Ceddia Lucas Reis With special guest: Jamon Holmgren Episode Summary Today’s guest is Jamon Holmgren from Oregon. Jamon is the the CTO for Infinite Red, a consultancy that designs and builds mobile apps. The show starts with Jamon talking about his background in coding, which goes all the way back to when he was 12 years old. The panel brings up his React Finland presentation on building a community around Ignite. Ignite is a plugins and boilerplate maker for React that can speed up app creation. Jamon talks about how it works and how it came about. The panel believes this to be an excellent product that will contribute to code quality and doesn’t contribute to the jumble of boilerplates out there.  Since Infinite Red engineers work on both web and mobile applications, Jamon talks about how they navigate the differences between the two platforms. Their primary tool for doing this is MobX, and Jamon expounds on how it works. The panel discusses situations where using React Hooks and React Context are too low level for a state management solution for a big application, and thus where tools like MobX become necessary.  The conversation turns to the React Core team and how they view the community coming up with their own solutions. The panel discusses the lack of executive decisions in React and compare it to other languages like Ruby, and how it affects the longevity of a language. They weigh the benefits of a core team that makes executive decisions and causes conflict versus one that doesn’t and the chaos that ensues. They discuss the benefits of standardization, but ultimately agree that collaboration almost always comes up with the best solution.    Links Infinite RedBuilding a Community Around IgniteIgniteBoilerplateMobX State TreeMobX ReactMobXEmerReact ReduxReact ContextReact HooksApolloElmPrettier@jevakallio Tweet Follow DevChat on Facebook and Twitter Picks David Ceddia: Devurls.comReducing Motion to Improve Accessibility Lucas Reis: CSS Grid like you are Jan Tschichold Jamon Holmgren: React Node GUISpecial Guest: Jamon Holmgren. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Adventures in DevopsSentry use the code “devchat” for 2 months free on Sentry’s small plan My JavaScript Story Panel David Ceddia Thomas Aylott Leslie Cohn-Wein Lucas Reis With special guest: Bruno Lourenco Episode Summary Bruno is a developer specializing in multimedia. He is currently building websites with React and the creator of React Morph, an animation library. Bruno talks about what React Morph is, how it originated, and the flip animation technique. React Morph is uniquely designed to be compatible with many platforms. Bruno talks about his goal to make everything simpler, from having animations on your website, to making things easier for users of the application.  The panel discusses the importance of animation and how it relates to user accessibility. They discuss how animation is interpreted in the brain to create meaning and purpose. On the other hand, it can be easy to go overboard with animation and can even make people feel sick. Since animation is important, Bruno outlines ways to avoid causing motion sickness in users. They discuss the difficulty of communicating animation intention between designers and developers. Animation should not be the last thing a team thinks about and should be given the same kind of considerations as for color and typography. They discuss the difficulties of adding animation to a project and whether or not animations should be included in the design system. They talk about the differences between mobile apps and web apps in how animations are used, and what the different expectations users have for them. React as a framework emphasizes static states, so Bruno and the panel discuss whether or not React is an animation friendly framework. Bruno talks about ways to get animations to fit the React paradigm so that they can be added. His hope is that React Morph will take care of a lot of animations automatically without CSS. He talks about other animation libraries that have influenced React Morph. The show finishes with Bruno talking about what he would like to accomplish next, which is to bring the design world and developer world closer together.  Links Render PropsReact MorphReact HooksFlip techniqueChange blindnessQartz composerOrigamiKeynotePopmotionPopmotion PopcornNode.JSDesigning Web InterfacesReduced motion preference Follow DevChat on Facebook and Twitter Picks David Ceddia: DevJoy Thomas Aylott: Lecture on Jung’s TypographyThomas’ Youtube channel Lucas Reis: Information Theory for Intelligent People Leslie Cohn-Wein: Resilient Management by Laura HoganSpider-Man: Into the Spiderverse Bruno Lourenco: A-Frame ReactBruno’s React Finland talkSpecial Guest: Bruno Lourenço. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Panel David Ceddia Thomas Aylott Leslie Cohn-Wein Lucas Reis With special guest: Shawn Wang Episode Summary Today’s guest Shawn Wang is a career changer starts off the show about how he got from finance to programming. The panel talks about how they each got started in programming. Shawn explains his Learn In Public manifesto. They discuss the benefits of learning in public and how concepts like Cunninham’s Law and lampshading can be a good thing. Shawn talks about the differences between inbound and outbound marketing. The two biggest benefits of learning in public is that people will come to help you, it helps you to build capital, and it os the fastest way to learn. They discuss the balance between sharing too little and oversharing.   Leslie brings up some possible safety concerns, and the panel discusses ways to stay safe while learning in public. Ultimately, it’s ok to learn in public and maintain anonymity. They discuss ways to adjust public learning to your comfort zone and how to know when you’ve done well with your public learning. Shawn talks about why he started doing TypeScript and React and the importance of saying thank you to your teachers, which also comes with some unexpected perks. They finish by discussing how to know if people care about what you’re producing.  Links VBAMicrosoft ExcelHaskellHoogleCunningham’s LawLampshadingNerd snipingJulia Evans cartoonsReact Suspense talk by swyxLin Clark code cartoonsLin Clark - A Cartoon Intro to Fiber - React Conf 2017Samantha MingReact/TypeScript Cheat SheetLearn In Public Follow DevChat on Facebook and Twitter Picks David Ceddia: Why React Hooks Thomas Aylott: Atomic Habits by James Clear  Lucas Reis: Tweet from James Clear Leslie Cohn-Wein: Storybook Accessibility Add-on Shawn Wang: Lizzo’s Juice  12 Leverage PointsSpecial Guest: Shawn Wang. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Panel Thomas Aylott David Ceddia Lucas Reis With special guest: Christoffer Niska Episode Summary   Christoffer Niska has been in web development for over a decade and works with mainly PHP and JavaScript, but knows about 8 different languages, often working in multiple languages simultaneously. The panel discusses the affect learning another language has on how you write the code you’re working on. They talk about TypeScript and Christoffer shares how he got into it. They discuss the prevalence of TypeScript and some of the tools available for it, like Fable.io. TypeScript is a very beneficial language because it can help with refactoring and automation. Christoffer believes that it is better to write libraries in TypeScript. He shares how to release an NPM package with Typescript. They talk about more tools that work with TypeScript. The panel talks about Reason ML, which is an alternative syntax on top of OCaml.They discuss how the success of ReasonML is evaluated. ReasonML has been found to dramatically reduce bugs and has many features, such as a pattern matching feature. The panel talks about the availability of ReasonML to those who are not on the Facebook team. ReasonML and Typescript can also be compiled into WebAssembly and other languages. They finish by talking about some of the many tools that Reason ML has built in.  Links ElmFlowTypescriptFable.ioF#Rollup.jsNode.jsNext.jsApolloThe PlatformReact RestrictedTSDXClojure specArticle on why you should look into ReasonMLReasonMLOCamlBuckleScriptPrettier   Follow DevChat on Facebook and Twitter Picks David Ceddia: Smashtest  Thomas Aylott: Brian Vaughn’s React Tools rewrite Lucas Reis: Complexity Explained Christoffer Niska: Exploring ReasonMLDiagonal LineSpecial Guest: Christoffer Niska. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Triplebyte offers a $1000 signing bonus Panel Thomas Aylott David Ceddia Lucas Reis With special guest: Daishi Kato Episode Summary   Todays guest Daishi Kato is a freelance programmer and has many open source libraries. He starts off by talking about how he got from tail call optimization to Redux and global state. Daishi talks about his definition of global state, how it differs from a regular state, and why it is a problem with the current context implementation. Thomas talks about his work with Android and how React has helped solved some of the problems they encountered. They talk about when different rendering issues they’ve encountered. Daishi shares his unique approach to solving rendering issues and how it applies to his libraries. His solution is to combine the system in React with proxy based tracking to solve issues with rendering. Daishi explains why this works and the importance of benchmarking. Daishi’s solution is designed as a same use state API, so someone can drop this in and see if it works. Daishi talks about his definition of proxies and how it triggers the rerender. He also talks about how it handles conditional reads. This tracking happens every render and it doesn’t have the same limitations as hooks. The panel talks about the new version of React Redux library implementation and how it compares to Daishi’s. Daishi’s approach is useful for people earning Redux because the used tracked state gives you all the benefits without a lot of the complexity. Daishi talks about how it deals with deeply nested pieces of code. The panel discusses the delicate balance of optimizing, but not doing it too soon, but to also remember how vital it is to maintain the performance of your app. Daishi’s work with Reactive React Redux to make sure things perform from the beginning is really important. It’s also important to understand how your product works so that when things do go wrong, you know how to fix it. Daisho talks about his other library React Tract for people who don’t like to use Redux. Links MobexGraphQLProc SQLReact-TrackedImmerReactive React ReduxReact Redux   Follow DevChat on Facebook and Twitter Picks David Ceddia: A Compiler From Scratch videoVerbal Expressions Thomas Aylott: The Making of a Manager by Julie Zhou Thomas’ Youtube channel Lucas Reis: Shun knives Daishi Kato: Remote FacesSpecial Guest: Daishi Kato. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Panel Lucas Reis Thomas Aylott Episode Summary   Today, Lucas and Thomas discuss how companies enforce what technology gets used, especially when companies get really large. Thomas talks about his experience with Facebook’s an ‘all carrots, no sticks’ approach, and says that if Facebook hadn’t given its employees the freedom to use whatever technology they needed, React would have never come about. Thomas talks about how he built his 2018 React Conference talk. He says that the hard part of being a programmer is not the technical aspect, it’s the social aspect and balancing the old and new. Lucas talks about his experience as a consultant, the path from analyst to manager, and how things change. Thomas brings up Facebook’s philosophy of “abstraction through extraction”. Thomas and Lucas agree that in the real world, it’s really difficult to have linear/boolean things, and as a result there is no one cure for everything. The great challenge is of solving problems is moderation in solutions and avoiding extremes. They agree that a lot of engineering is just moving complexity around, and it’s important to be aware of where you are storing the complexity and how it affects your workers, especially those who are just starting. This shifting is kind of where react came from. Ultimately, it’s important to leave a little room for chaos so that your project can evolve.  Links HooksCSS Follow DevChat on Facebook and TwitterAdvertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Triplebyte offers a $1000 signing bonus Panel Lucas Reis David Ceddia Leslie Cohn-Wein With special guest: Glenn Reyes Episode Summary Special guest Glenn is a software programmer based in Vienna, Austria and has been working in programming since 2013. He is the creator of the Graphpack library. Today the panel discusses how to choose between picking a 3rd party or handcraft component in React. They discuss the popular notion to avoid “reinventing the wheel” and always using 3rd party components. Glenn gives advice on approaching the decision between 3rd party components or making it yourself, including considering time constraints, risks of using premade components, and the popularity of the library and how up-to-date it is. It is also important to understand the big picture of your project and know what already exists that could be of use. The panel discusses different indicators of how well kept up a library is.  Glenn talks about situations when his library Graphpack would come in handy. He advises listeners to always test software before purchasing it. The panel talks about the issue of being able to change a component later if it doesn’t work. They agree that it’s important to consider the end goal and what other people on the team need when choosing whether to use 3rd party or custom make your code. Some decision will be your companion for years and years, like what language your project is written in. Glenn suggests that when you are trying something new, try it out in a clear and isolated  experiment, something React is very useful for. Last, it is important to leave notes for future developers as to why you made the decision you did   Links LodashMoment libraryGraphpackElm   Follow DevChat on Facebook and Twitter Picks David Ceddia: boringtechnology.club Leslie Cohn-Wein: The Ladybug PodcastBig Green Egg Lucas Reis: Top 20 CSS Navigation Menus Glenn Reyes: Lydia Hallie InstagramSpecial Guest: Glenn Reyes. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Triplebyte offers a $1000 signing bonus Panel David Ceddia Lucas Reis Thomas Aylott With special guest: David Khourshid Episode Summary David Khourshid is the author of a library called Xstate, He has been a developer for 7 years, currently works for Microsoft, his passion is frontendTalks a. In college, he actually studied piano performance, and so he talks about how he got into programming and where he started. The panel discusses his unique husky animation and how he came up with the idea for it and went about programming it. The panel discusses what a state is in React. David defines a state as a moment in time. States can change, when they do, that’s a state transition. They talk about the utility of states and thinking about your app as a state machine. They agree that describing your code as a state machine makes it easier to communicate and connect with non developers. The panel discusses the importance of learning from other industries, such as approaching programming the same way construction workers build a house. They debate the Waterfall versus the Agile mindset.  They talk about the advantages of programming in React and focusing on the state machine, especially because it is important to be intentional about dealing with concepts separate from other concepts. They share different ways to switch to state machine thinking, one of which is to look at your event handlers and make sure they are doing anything besides dispatching events. David talks about his library called Xstate and the basics of his library and his inspiration, and who else is working in state machines. The finish by discussing industry standards.  Links XstateKeyframersBootstrapDavid’s husky animationThe Checklist ManifestoSion SCXMLQTElmThunkObservableNoFloSketch SystemsState Charts  Follow DevChat on Facebook and Twitter Picks David Ceddia: Atomic Habits by James Clear  Bullet Journal Thomas Aylott: The Checklist ManifestoThomas’ Youtube Channel David Khourshid: Constructing The User Interface with State Charts (check the library first) Follow David @davidkpiano Special Guest: David Khourshid. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Triplebyte offers a $1000 signing bonus Panel David Ceddia Lucas Reis Leslie Cohn-Wein With special guest: Varya Stepanova Episode Summary Today’s guest is Varya Stepanova, who started her career in programming as a front end developer in Russia for Yandex. Now she is an independent consultant specializing in design systems. For Varya, a design system is a systematic approach to providing coherent products under the same brand. The necessity of a design system for a company is dependent upon how large it is and how quickly it is developing. Varya talks about how a component library turns into a design system and shares some of her experience. She talks about how the concepts in a design system are influenced and created by the existing interface. The panel discusses the importance of design system ownership. They all agree that the design system should be owned by either a team or a single person in order to avoid problems. Varya talks about dealing with breaking changes in a design system and the importance of working visual regression tests into a system. She shares a story about a time where broken code was released which ultimately lead her to find a way to automate visual regression tests. The panel discusses some solutions for dealing with the fact that the library is going to be used for multiple different projects and infrastructure technology tools available for a design system.  Links CSSVisual regression testCypressStorybookStyleguidistPercyGatsbyMetalsmith Follow DevChat on Facebook and Twitter Picks Lucas Reis: Webpagetest.orgSpeedCurve David Ceddia: Captain Marvel Leslie Cohn-Wein: Design Systems by Allah Kholmatova Varya Stepanova: Learn about service design and design thinking Follow Varya on Twitter         Special Guest: Varya Stepanova. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Triplebyte offers a $1000 signing bonus CacheFly Panel Nader Dabbit Dave Ceddia Lucas Reis Summary The panel shares their first experiences with CSS and compares CSS and CSS-in-JS. The best ways to learn CSS is considered. The panel shares some coding tips; considering when to use libraries and when to use homegrown solutions. Nader Dabbit shares his predictions for the future of frontend technology. The panel discusses these predictions and shares some of their own.  Links https://www.facebook.com/React-Round-Up Picks Nader Dabbit: 21 Lessons for the 21st Century Dave Ceddia: CSS Mastery: Advanced Web Standards Solutionshttps://conference.convertkit.com/  Lucas Reis: https://workflowy.com/  https://www.futureme.org/  Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small planTriplebyte offers a $1000 signing bonusCacheFly Panel Dave CeddiaThomas Aylott Joined by Special Guest: Leslie Cohn-Wein Summary Leslie Cohn-Wein joins the panel to discuss accessibility. She explains how she got passionate about accessibility. The panel discusses what you have to do to become accessible. Leslie brings up divs and explains how these get in the way of accessibility. The panel discusses roles; Leslie explains what roles does and how to use roles. Accessible testing is discussed and Leslie shares some resources for testing your sites for accessibility. The panel discusses ways to make sites more accessible and how doing something is better than doing nothing. Leslie advises having an accessibility champion on your team whose job it is to think about how to make sites and apps for accessible. The panel discusses the importance of accessibility and how accessibility changes the lives of disabled users. Links https://www.w3.org/WAI/standards-guidelines/wcag/https://www.npmjs.com/package/eslint-plugin-jsx-a11yhttps://github.com/reakit/reakithttps://reach.tech/routerhttps://reactjs.org/docs/accessibility.htmlhttps://www.tobii.com/https://ofone.co/https://twitter.com/lesliecdubshttps://www.facebook.com/React-Round-Up Picks Dave Ceddia: https://egghead.io/courses/start-building-accessible-web-applications-todayhttps://egghead.io/lessons/tools-building-forms-with-accessibility-in-mind \Company of One: Why Staying Small Is the Next Big Thing for Business Thomas Aylott: Journey By Starlight: A Time Traveler's Guide to Life, the Universe, and EverythingPhotoviz: Visualizing Information through Photography Leslie Cohn-Wein: https://www.udacity.com/https://inclusive-components.design/https://www.modsy.com/Special Guest: Leslie Cohn-Wein. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small planTriplebyte offers a $1000 signing bonusCacheFly Panel Lucas ReisDavid CeddiaThomas AylottJustin Bennett Summary The panel starts by discussing if useEffect is a good API or a bad API. The problems that useEffect solves are considered. The panel agrees it is a much better abstraction where subscriptions are concerned. Suspense and data fetching is discussed, the panel considers what the react team has in store concerning data fetching. The panel discusses what it was like to be a beginner to React and how using React is not an intuitive language. The panel shares some of their mistakes with useEffect, and try to consider useEffect from a beginners perspective. The panel gives advice for using hooks. Links https://twitter.com/ryanflorence/status/1125041041063665666 Picks Lucas Reis: https://github.com/kkuchta/css-only-chat David Ceddia: https://twitter.com/kentcdodds/status/1125876615177629696https://twitter.com/ryanflorence/status/1125041041063665666Fun with React Hooks - Michael Jackson and Ryan Florence Thomas Aylott: The Design of Everyday Things: Revised and Expanded Edition Justin Bennett: https://dusk.now.sh/https://developers.facebook.com/videos/2019/building-the-new-facebookcom-with-react-graphql-and-relay/Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsor NetlifySentry use the code “devchat” for 2 months free on Sentry’s small planTriplebyte offers a $1000 signing bonusCacheFly Panel Nader DAbitJustin BennettDavid Ceddia Joined by Special Guest: Aggelos Arvanitakis Summary Aggelos Arvanitakis shares things he has learned from his mistakes in his blog posts. The panel discusses the most common problems in react that causes poor performance. Aggelos gives a lot of advice on how to fix or avoid these problems and how to optimize performance. The panel discusses using CSS to optimize performance. The new React API’s are discussed and their effect on performance. Vue state and vue reducer are compared and Aggelos gives tips for maintain state. The episode ends with Aggelos sharing techniques for using redux. Links https://www.orfium.com/https://itnext.io/@aggelosarvanitakis Picks Nader Dabit: https://twitter.com/Eli_Whitehttps://devchat.tv/react-native-radio/react-native-open-source-the-react-native-community-feat-christoph-nakazawa/https://dev.to/dabit3/the-complete-guide-to-user-authentication-with-the-amplify-framework-2inh Justin Bennett: https://github.com/vadimdemedes/pastelhttps://github.com/DevExpress/testcafehttps://www.cypress.io/ David Ceddia: https://svelte.dev/ Aggelos Arvanitakis: https://vx-demo.now.sh/https://technology.riotgames.com/Special Guest: Aggelos Arvanitakis. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Triplebyte offers a $1000 signing bonus Panel Nader Dabit Lucas Reis David Ceddia Thomas Aylott Episode Summary On today’s show the panel discusses what what jobs should be delegated to the front and backend when doing fullstack development with React. They talk about where the data fetching starts coming into play in a react app and the big changes from the old web to the modern web in data fetching. They discuss how much interaction with the backend there is when working with front end applications, but also the importance of properly separating backend and frontend teams. They discuss the pros and cons of separating the front and backend teams, and agree that the problem space between both back and frontend is the user interface. They talk about where middlewares fit in. The panel notes that it is important to ensure that your new app can still communicate with older versions, and talk about different ways of dealing with it, such as continually evolving schema, installing new versions, or even never deleting anything and only adding new events. The panel talks about who should work the middle layer and who, between frontend and backend developers, should be put in charge of maintaining it. They discuss the misconception that using React makes server-side jobs irrelevant and how React actually helps. They note how automation in programming has changed the way that people use the web. They conclude by saying it is important to understand there are different ways to do these kinds of things, and encouraging listeners to look at the abstractions being built out in the serverless world Links StatejQueryMiddlewareRestBFFs (Backend for Frontend)Syscalls AWS Follow DevChat on Facebook and Twitter Picks Nader Dabit: The Never Hero Listening to books in the car with your kids. Lucas Reis: Why Softer Projects Take Longer Than You Think by Erik Bernhardsson Interviewing is a noisy prediction problem by Erik Bernhardsson David Ceddia: 11ty Thomas Aylott: Groovy Tie SquadThe Laws of Human Nature by Robert GreenAdvertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Sentry– use the code “devchat” for $100 creditNetlifyTripleByte Panel Justin BennettThomas AylottDave Ceddia Notes Today’s show has the panel discussing image lazy loading in React. Image lazy loading is the notion that images that are below the fold (rendered outside of your browser view when you initially load a page) are deferred and loaded later, so that your page loads faster. As you scroll down the page and things get close, then they are loaded in. This is a commonly suggested performance optimization, but often it doesn’t work well in React. The panelists talk about their experiences with lazy loading and different methods they’ve seen on other sites. They discuss the tradeoff between having a lot of images and slower loading and the importance of communicating with the design team. Since lazy loading is a unique challenge in React, they give recommendations for implementing lazy loading and tools for tracking site usage. They talk about dealing with JavaScript payloads, bundle and load splitting, and automating performance tracking. They discuss different performance tracking tools. The panelists address the NIH bias (Not Invented Here) and the trend that designers tend to be willing to pay money for good tooling, while engineers are cheap. There have been great improvements in the marketplace for good tools, so much so that oftentimes buying the tools is cheaper than making them yourself. They finish by discussing the pros and cons of building vs. buying and the future of the frontend. Links LighthouseGatsbyAbove the fold optimizationsBelow the fold optimizationsCrumpSurvive JS on WebpackReact lazy load image component CalibreSpeedCurveBundle AnalyzerInspect Pack by Formidable LabsCypressGithub Actions Follow DevChat on Facebook and Twitter Picks Justin Bennett: Netlify Dev ProductsEasy Peasy Thomas Aylott: Displaced: Stories from the Syrian DiasporaReact Rewind Dave Ceddia: NotionUnderstanding By DesignAdvertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan Triplebyte offers a $1000 signing bonus CacheFly Panel Nader Dabit Lucas Reis Thomas Aylott Episode Summary Today the panel is discussing the necessity of companies having a dedicated frontend team. They begin by discussing the technologies that might be used by a dedicated frontend team. According to the panel, the necessity of a frontend team is determined by the size of the company. When you try to have a frontend team too soon, it ends up being a huge debacle, but once you get bigger and have multiple teams, it gets more useful. A company is ready for a dedicated frontend team when it is able to build with a common set of components. The panel discusses the concept of ownership in a company. Nader believes that things should be run where there is a team that’s in charge of building a component, and once the component has shipped, they are no longer in charge. The other panelists disagree with that method because they believe there is a danger of the project getting bloated. Thomas shares his experience with working for Facebook and Lucas talks about how he has previously set up his teams. They talk about the necessity of having a design system before having a React design system, and they all agree that it is useful Nader shares his experience with his brother working for Cartoon network and the design rules they had for the websites for each show like Dexter’s Lab and PowerPuff Girls. Since the panel agrees on the importance of consistency in visual communication and designs, they delve into deciding what is owned by the design system and what is shared between other teams, who maintains these things, and how to differentiate between the different kinds of components. They talk about the idea of Atomic Design in programming, separating component into categories called names like atoms, molecules, organisms, etc. Nader talks about his experience with this method. He found it difficult because components didn’t always fit cleanly into one category. The panel believes that it all comes back to ownership and it is important that companies are handling ownership well Links StorybookFrontendClouderaNext.jsGatsbyReact Native WebDoczMaterial Follow DevChat on Facebook and Twitter Picks Nader Dabit: React Native in Action by Nader Dabit Lucas Reis: Kickstarting a Library of Internal React Components for Multiple Teams by Javier Lefevre Thomas Aylott: The E-Myth RevisitedThe Design of Everyday ThingsAtomic Design by Brad Frost Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small planTriplebyte offers a $1000 signing bonusCacheFly Panel Nader DabitJustin BennettLucas ReisDave CeddiaCharles Max Wood Joined by Special Guests: Thomas Aylott, Conlin Durbin Episode Summary Conlin Durbin is a front end software engineer for a company called Lessonly and occasionally writes about React. Thomas Aylott is a web guy from the 90’s who was briefly on the React team, and he makes thingsthatdostuff.com and groovytiesquad.com. The panel discusses  Conlin’s article Link Lists in the Wild: React Hooks. They begin by talking about the relationship between linked lists and React hooks. Linked lists are used under the hood to render hooks every time that they’re created and maintain integrity of the hook chain. They discuss the importance of knowing what goes on under the hood share their methods of learning. They give tips for learning on the job. The panel agrees that one of the best ways to learn is to teach. Conlin shares his experience working for Lessonly, a company that builds lesson-building software. The panel discusses WET (Write Everything Twice) vs DRY (Don’t Repeat Yourself) programming. They talk about when it is beneficial to have abstractions in code and when it is not. It’s also important to think about the humans that are going to be using it, and to write the code so that it’s humane. They praise good error messages that tell you exactly where you went wrong and how to fix it. They talk about the dangers of putting invariants everywhere, and finish by talking about ways to improve. Links Linked listReact FiberHooksBackboneJavaScriptReduxGatsbyFlowJake Archibald: In The Loop-JS Conf Asia 2018 (video)What the heck is the event loop anyway? (video)Practical 00 Design in  Ruby, Sandi MetzStop trying to be so DRY, instead Write Everything Twice (WET)Sebastian Markbage: Minimal API Surface Area – Learning patterns instead of frameworksSomeone Is Changing Your CodeConlin Durbin username for most places is ‘wuz’, except Twitter for twitter it’s @CallMeWuz Follow DevChat on Facebook and Twitter Picks Justin Bennett: The 3 most effective ways to build trust as a leader articlePheonix Live View Lucas Reis: Pamela ZaveSmall Functions Considered Harmful article Dave Ceddia: New Redux courseKinesis Advantage 2 Keyboard Charles Max Wood: MicroConfBuzzSprout Thomas Aylott: Noflojs.orgThe Laws of Human Nature by Robert Greene Conlin Durbin: https://dev.to/Soft Skills EngineeringConlin’s Discord serverSpecial Guests: Conlin Durbin and Thomas Aylott. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small planTriplebyte offers a $1000 signing bonusCacheFly Panel Justin BennettLucas Reis Joined by Special Guest: Parashuram Summary Parashuram (aka Ram) and the panel compares various frameworks including the differences between React Native and NativeScript. Ram discusses what it’s like introducing react native to mobile teams which leads to a panel discussion of web app developer experience compared to mobile app developers. Ram shares the changes that are being made to React Native and what this means for its developers. Some of the things to look forward to are a leaner and more browser-like React Native.  The episode ends with Ram sharing a little of his story. Links http://artsy.github.io/blog/2017/07/06/React-Native-for-iOS-devs/http://artsy.github.io/artsy-x-react-native.htmlhttps://github.com/necolas/react-native-webhttps://github.com/vincentriemer/react-native-domhttps://microsoft.github.io/reactxp/https://facebook.github.io/react-native/blog/2018/11/01/oss-roadmaphttp://nparashuram.com/https://twitter.com/nparashuramhttps://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundup Picks Justin Bennett: http://artsy.github.io/blog/2017/07/06/React-Native-for-iOS-devs/http://artsy.github.io/artsy-x-react-native.htmlhttps://github.com/vadimdemedes/ink Parashuram: https://github.com/react-native-community/discussions-and-proposalshttps://github.com/facebook/react-360 Lucas Reis: Family TimeSpecial Guest: Parashuram. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use code “devchat” for 2 months free Triplebyte Panel Lucas Reis Charles Max Wood Special Guest: Florian Rival Episode Summary Florian is a software engineer working for Facebook. He has previously worked with React Native making apps. He has also created an open source game creation software called GDevelop. Florian talks about his inspiration for GDevelop. He delves into the nature of GDevelop as a desktop app built on the web. Florian talks about his decision to not go full JavaScript in his app and to redo the interface. He ultimately decided to combine C++ and JavaScript, and top it with a React interface. Florian discusses how C++ is used in this web application and how it connects to react. The panel discusses the use cases for WebAssembly and the performance quality. They discuss the bundle sizes in WebAssembly compared to other languages and compatibility with different browsers. Florian talks about how WebAssembly and React work together in his app. He talks about some of the issues and solutions you had in desiging the UI and how he created the editable lists and trees. Florian concludes by saying that any LLVM language can be compiled into web assembly Links React NativeReactWebGLJavaScriptHTMLStorybookFeedback LoopC++The DOMAngularClankQT5EnscriptenC MakeEV computationC#WebAssemblyDomain Driven DesignSlackReact Sortable TreeCanvasGodotPixyLLVM Picks Lucas Reis: American food Charles Max Wood: Podfest Alita: Battle Angel Florian Rival: Material UIGatsbySpecial Guest: Florian Rival. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small plan TriplebyteCacheFly Panel Justin Bennett Lucas Reis Joined by Special Guest: Nat Alison Summary Nat Alison shares with the panel her work in translating Reactjs. Lucas Reis thanks her for her work in this very important project. Nat updates the panel on how the translation is going and discusses some of the specifics of updating, changing language direction and how it all got started. The panel moves on to discussing Nat’s work with her Polyhedra application. Nat discloses what she learned while creating this app, how she tested the app and why she used the react framework for this project. The panel discusses suspense features and what they could do for this app. Nat ends the episode by sharing her inspiration for this app. Links https://github.com/reactjs/reactjs.org-translationhttps://reactjs.org/languageshttps://isreacttranslatedyet.com/https://polyhedra.tessera.li/https://github.com/tesseralishttps://twitter.com/tesseralishttps://www.linkedin.com/in/nat-alison-2768a449https://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundup Picks Lucas Reis http://shadow-cljs.org/ Justin Bennett https://zeit.co/nowhttps://github.com/artsy/dupe-report Nat Alison https://www.npmjs.com/package/cronSpecial Guest: Nat Alison. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for $100 creditTriplebyte offers a $1000 signing bonusCacheFly Panel Charles Max WoodNader DabitJustin Bennett Joined by Special Guest: Adam Laycock Summary Adam Laycock describes his experience at React conf 2018, the atmosphere, the people and the talks. The panel shares how the approach conferences, taking notes, getting to know people, accessing information and getting out of their comfort zone. Adam shares some of the major topics covered at including, hooks, suspense, and concurrent rendering. The panel considers these topics and React conferences they look forward to attending. The episode ends with the panel comparing Angular and React, conferences, upgrades, and routers for React. Links https://www.microsoft.com/en-us/buildhttps://medium.com/curated-by-versett/talks-worth-watching-react-conf-2018-bfbdd40922aahttps://reactjs.org/community/conferences.htmlhttps://twitter.com/atlaycockhttps://github.com/alaycockhttps://adamlaycock.ca/https://medium.com/@adam.laycockhttps://twitter.com/reactrounduphttps://www.facebook.com/React-Round-Up Picks Charles Max Wood https://www.notion.so/The Effective Executive by Peter F. Druckerhttp://entreprogrammers.com/Michael FeathersKent Beck Nader Dabit https://dev.to/dabit3 Justin Bennett https://github.com/Bogdan-Lyashenko/codecrumbshttps://medium.com/palantir/tslint-in-2019-1a144c2317a9https://www.npmjs.com/package/rate-limiter-flexible Adam Laycock https://kentcdodds.com/blog/please-stop-building-inaccessible-forms-and-how-to-fix-themhttps://medium.com/curated-by-versett/dont-eject-your-create-react-app-b123c5247741Clean Architecture: A Craftsman's Guide to Software Structure and Design by Robert C. MartinSpecial Guest: Adam Laycock. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors NetlifySentry use the code “devchat” for 2 months free on Sentry’s small planCacheFly Panel Lucas ReisJustin BennettCharles Max Wood Special Guest: Ajay NS Episode Summary In this episode of React Round Up, the panel talks with Ajay NS, a Computer Engineering student at National Institute of Technology Surat who is passionate about frontend development and design. Ajay talks about his article Why you should use GatsbyJS to build static sites on Medium and why he felt the need to write it. After attending the Plone Conference in Tokyo where he gave a talk about GatsbyJS, he realized that compared to React or Angular, Gatsby helped new developers learn about frontend development without facing too many complications. Ajay explains that he decided to write the article and share his experiences with Gatsby to help ease the learning process for new developers who are curious about frontend development. They discuss best cases to use Gatsby for and also cases where it may not be a good idea to use it. They then discuss the best tools for people who are new to web development and are trying to find jobs as remote developers. One of the best methods recommended is pair programming which can also be done remotely. Links Why you should use GatsbyJS to build static sitesAjay NS — Plone Conference 2018 – TokyoAjay's Talk in the Plone ConferenceAjay’s LinkedInAjay’s TwitterAjay’s GitHubNetlifyEleventyhttps://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundup Picks Justin Bennett: gatsby-starter-typescript-rebass-netlifycmshttps://github.com/artsy/palettehttps://github.com/FormidableLabs/inspectpack Lucas Reis: react-spring Charles Max Wood: Green ScreenLED lighting for video  Ajay NS: https://github.com/storybooks/storybookBodymovin PluginSpecial Guest: Ajay NS. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Sentry use the code “devchat” for $100 creditTriplebyteCacheFly Panel Lucas ReisJustin BennettCharles Max Wood Joined by special guests: Chris Toomey Episode Summary In this episode of React Round Up, Chris Toomey introduces himself, talks about his work and his podcast and moves on to explaining the differences between a React vs GraphQL centric application. Justin explains in detail how the Relay framework works, and Chris describes the scenarios where GraphQL stands out in the process of building an application and also throws some light on the benefits of choosing it over other APIs such as REST. The panel then discusses how GraphQL is advantageous in the documentation context since it has a good schema, and also in data modeling. Chris shares some past examples of creating React applications where GraphQL and Apollo made things much simpler, and also elaborates on the trade-offs and challenges associated with it. Links The Bike ShedChris Toomey: React & GraphQL – Bringing Simplicity to Client-Side Development / React Boston 2018Chris’s TwitterThe Past, Present, and Future of GraphQL Native - Nick Schrock @ GraphQL Europe Picks Justin Bennett: Where art thou, my error?Auto by Intuit on GitHub Lucas Reis: MDX Deck libraryCode Surfer library Charles Max Wood: HubSpotZapierGoogle Docs Chris Toomey: Tell me when it closesQuicklinkUpcaseSpecial Guest: Chris Toomey. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Sentry use the code “devchat” for $100 creditTriplebyteCacheFly Panel Lucas ReisNader DabitCharles Max Wood Joined by special guest: Thomas Aylott Episode Summary In this episode of React Round Up, Thomas Aylott, Founder at Things That Do Stuff, gives an overview of Framer X, explains what it is used for and how it can be beneficial for web designers. The panelists then discuss the timeline and usage of different design and developer tools along with their compatibility with various platforms. Thomas shares his front-end development experiences from 2005, the kind of technologies he learnt and how, with interesting and fun anecdotes, and also talks about about his time at Facebook. They discuss the fact that how Ruby on Rails has brought about a significant change in web development, work-life balance in general, and in the end, the importance of making checklists and taking ownership. Links Things That Do StuffThomas’s websiteThomas’s TwitterThomas’s GitHubThomas’s YouTubePrettier Picks Nader Dabit: Gödel, Escher, Bach: An Eternal Golden Braid Lucas Reis: CSS-TricksIndirection is not Abstraction Charles Max Wood: Check out the recent milestone episodes on Devchat.tv!DevRevHiring Show Notes writers for podcastsExtreme Ownership: How U.S. Navy SEALs Lead and Win Thomas Aylott: Objective PersonalityNotionThe Checklist Manifesto: How to Get Things RightSpecial Guest: Thomas Aylott. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Sentry use the code “devchat” for $100 creditTriplebyteCacheFly Panel Lucas ReisCharles Max Wood Joined by special guest: Jared Palmer Episode Summary  In this episode of React Round Up, Jared Palmer, Lead Engineer at Palmer Group, gives the listeners an overview of React Suspense, how it helps to resolve conflicts with resource scheduling and how it differs from current practices. He mentions that it is developed completely by the React team and talks about some of its applications, especially in handling images. He explains how React Suspense will reduce code size for loading states, the mechanism of parallel execution and how complexity in logic can be simplified with it. Jared also mentions some modules where Suspense can already be integrated with and advises on where it is not recommended to be used yet. The panelists then discuss server-side rendering with Suspense and their approach in technology adoption, which is incremental. Finally they talk about Redux and move on to picks. Links The Platform - Suspense-ready components Jared’s GitHubJared’s TwitterJared’s websiteThe Palmer Grouphttps://www.facebook.com/React-Round-Up-297859274397129/https://twitter.com/reactroundup Picks Lucas Reis: Sunlight Alarm Clock Charles Max Wood: Gel PadsNotion Jared Palmer: DevHubThe Undefined PodcastSpecial Guest: Jared Palmer. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Sentry– use the code “devchat” for $100 creditTripleByte offers a $1000 signing bonusCacheFly Episode Summary In this episode of React Round Up, Justin Bennett speaks with co-founder of Couchbase, Chris Anderson. Chris has been working with NoSQL databases for approximately a decade, and is currently working on FaunaDB, doing development outreach, while writing codes to connect with the different eco systems: Serverless, JAMStacks and React Native. He is also a blogger on a platform he calls ‘Serverless’ and enjoys decoding web applications and converting them to mobile. Chris elaborates on the particulars and functions of JAMstacks, FaunaDB, React Native, Expo, Firebase and Netlify along with their databases. He tells of his journey with FaunaDB and explains what led to its introduction. He also gives a detailed explanation on Serverless functions, Multi-cloud deployment and extends advice to apprentices in the similar field. Links https://serverless.com/author/chrisanderson/https://twitter.com/jchrishttps://github.com/jchrishttps://fauna.com/ServerlessNetlifyReact NativeFirebasehttps://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundup Picks Chris Anderson: React Native Starter KitNetlify Fauna Todo Justin Bennett: Refactoring UIBuild Your Own MintSpecial Guest: Chris Anderson. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Sentry use the code “devchat” for $100 creditNetlifyTriplebyteCacheFly Panel Lucas ReisJustin BennettNader DabitCharles Max Wood Episode Summary In this 50th episode of React Round Up, the panelists start with talking briefly about themselves, their work, as well as their side projects. Lucas Reis is a Senior Frontend Engineer at Zocdoc, and is working on the Zocdoc website, specifically on performance and SEO. He is also involved in sharing frontend knowledge throughout the company. Justin Bennett is a Senior Engineer at Artsy and focuses on web performance along with several open source projects. He is also interested in release processes and continuous integration. Nader Dabit is with Amazon Web Services as a Developer Advocate, working on GraphQL, React to React Native, Vue and is involved in community work too. Charles Max Wood is mainly focused on making this podcast better that includes things like getting sponsors, dealing with business issues, releasing the episodes on time, etc. He talks about his mission to help people find fulfillment from coding and enabling them to achieve their ideal lifestyle. They discuss hard and soft skills in software development, their interdependence and importance, and also the fact that the skills required to become a good developer are needed for personal development in general as well. They then mention their favorite past episodes and the growth of different programming ecosystems and communities such as React, Vue, Angular, etc. With respect to upcoming projects in React, they talk a bit about Suspense, Concurrent React, server-side rendering, performance issues, Prepack, compiler optimizations and Reason React. Finally, they each mention what they do apart from regular development work to unwind and relax. Links ArtsyThe Dev RevReact 16 RoadmapReasonReasonReactClojureScriptThinksterDisney Heroes Battlemode Picks Justin Bennett: InterCan’t Unsee design game Lucas Reis: The Law of Leaky Abstractions Nader Dabit: React NativeOpen GraphQL newsletter Charles Max Wood: LibsynWordPressDigitalOceanMicrophones – Electro-Voice RE20, Audio-Technica ATR2100Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors: NetlifySentry use the code “devchat” for $100 creditTripleByte   Panel: Charles Max Woods Special Guests: Donovan Brown In this episode, the Charles speaks with Donovan Brown. He is a principal DevOps Manager with Microsoft with a background in application development. He also runs one of the nation’s fastest growing online registration sites for motorsports events DLBRACING.com. When he is not writing software, he races cars for fun. Listen to today’s episode where Chuck and Donovan talk about DevOps, Azure, Python, Angular, React, Vue, and much, much more! Links: Donovan Brown’s GitHubDonovan Brown’s TwitterDonovan BrownDonovan Brown – Channel 9Donovan Brown – MicrosoftAzureYoTeamAzure.com/devopsGitHubAzure DevOps’ Twitter Picks: Charles Jet BlueBeta Testers Donovan YoTeamVSTeam Powershell ModuleSpecial Guest: Donovan Brown. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors: NetlifySentry use the code "devchat" for $100 creditCacheFly Panel Lucas ReisNader DabitCharles Max Wood Special Guest: Kay Plößer Episode Summary In this episode of React Round Up, the panel talks with Kay Plößer, describing their experiences learning React. Kay is a software developer from Stuttgart, Germany and the author of the book React from Zero. They discuss the best approach to learning React from scratch. Kay describes the process of writing and producing his book 'React from Zero'. Initially he started with tutorials and lessons and then turned those into a book. It is constructed in two sections: basic and advanced and it's purpose is to help developers learn React without being overwhelmed. He has received great feedback from the people who have bought the book. Kay then describes his experiences teaching React to developers and talks about his blog post React Hooks Demystified which became really popular. The panel then about how developers can increase and diversify income through writing books and side projects. Links Kay's Book: React from ZeroKay's Blog Post: React Hooks DemystifiedKay’s LinkedInKay’s TwitterKay’s GitHubKay's WebsiteKay's SkillshareKay's Facebookhttps://www.facebook.com/React-Round-Uphttps://twitter.com/reactroundup Picks Nader Dabit: Finite and Infinite Games by James Carse Lucas Reis: An Introduction and Guide to the CSS Object ModelAST Explorer Charles Wood: Charles' New Devchat.tv Build on Eleventy on GitHub Kay Plößer: Wardley mapsSpecial Guest: Kay Plößer. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors Sentry use the code "devchat" for $100 creditAdvertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.

Sponsors: KendoUISentry use the code "devchat" for $100 creditTripleByte $1000 signing bonusCachefly Panel: Nader DabitJustin BennettCharles Max Wood Special Guest:  Charlie Cheever Notes: This episode of React Round Up has the panelists talking to Charlie Cheever, a former Facebook employee, who currently works on Expo.  The panel discusses Charlies article called “Should we be using React Native?”,  Airbnb sunsetting their React Native app, and the nature of the Expo app. Charlie describes Expo as the easiest way to do React Native using just JavaScript, and making it as easy and powerful as possible. Expo works kind of like a web browser for JavaScript, and is available on iOS, Android, and and Google app stores. Expo CLI has replaced Create React Native CLI because Expo is more user friendly. Many features are already included in Expo, including OTA updates, dealing with fonts, video player, Facebook ad and Google ads, barcode scanner, Native maps, and much more. To get started on your computer, go to snack.expo.io or download the Expo app on your phone. The panelists chat about the success of Charlie’s company and how he has attracted so many great programmers to his company. Charlie gives a history of how Expo got started. Charlie gives advice on how to start a business around a free tool, and the goal of Expo to make every service available on the app before focusing on making money. The panel discusses sustainability in the software world, as making people pay for things can drive them to write their own stuff. They talk about the benefits of using Expo and its ability to cross platforms, and enterprise companies such as Youtube and Instagram shifting over to using React. Charlie attributes this shift to two things; the increase in software developer salaries driving down the number of available software engineers, which makes it difficult for smaller companies to hire engineers, thus pushing them to use things like React and Expo to make up for it. Last, the panelists talk about the possibility that the world is moving towards a future characterized by a “write once, run everywhere” and more uniform experiences across operating systems. Terms: React NativeExpoExpo CLIVS CodeEmacs VimXamarinTitanium Native ScriptAWS Picks: Nader: Video series on EggheadOn Grand Strategy Justin: rePNGDark Reader Charles: Pomodoro methodKanbonflowJohn Somnez video Charlie: React navigationReact Native Gesture HandlerReact Native ReanimatedWiliam Candelon “Can It Be Done in React Native” videosSpecial Guest: Charlie Cheever. Advertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacyBecome a supporter of this podcast: https://www.spreaker.com/podcast/react-round-up--6102072/support.