We’re talking about RedwoodJS. What precisely does it mean to be a full-stack Jamstack framework? I spoke to society champion Anthony Campolo to find out.

Show Document

RedwoodJS Anthony on Twitter Anthony’s commodity series A First Look at RedwoodJS

Weekly Update

An Introduction To Running Lighthouse Programmatically”written by Katy Bowman “Animating React Components With GreenSock”written by Blessing Krofegha “Designing For Attention”written by Victor Yocco “Advanced GraphQL Usage In Gatsby Websites”written by Aleem Isiaka “Comparing Styling Methods In Next.js”written by Adebiyi Adedotun


Drew McLellan: He’s a Lambda School student, studying full load web exploitation, as well as being a contributor to RedwoodJS. Something of a community champion, he’s recently written a 12 place clause successions called A First Look at RedwoodJS that helps to explain the causes and motivations of Redwood, along with many of the different notions that the framework introduces. So, we know he’s an expert at RedwoodJS, but did you know he’s never seen a dog? My smashing friends, delight welcome Anthony Campolo.

Drew: Hi, Anthony. How are you?

Anthony Campolo: Hello. I am demolishing, thank you so much for having me.

Drew: I wanted to talk to you today, and it’s probably obvious from the prologue, about RedwoodJS. For those who haven’t heard of RedwoodJS before, at a high level, what is it?

Anthony: I think there’s a couple ways that you can describe it depending on where people are coming from, but the canonical definition is it’s a full load serverless framework for the Jamstack. So, it mixes full load network improvement with serverless AWS Lambda type stuff and the Jamstack, which is a big thing these days.

Drew: So, it’s a full load fabric that tries to put together a lot of the relevant recommendations around a Jamstack development ecosystem? Is that right?

Anthony: Yeah, it’s pushing the boundaries of what a Jamstack application can be, so by label it full stack, Jamstack, it’s about how do we go beyond precisely the front end to having the same sort of deployment paradigm of simply get pushed, getting your totality code deployed. How do we get that but also with our back end, and have it all connected?

Drew: Now, before we probe more seriously into it, I think it’s quite interesting to hear that it’s from quite a seasoned team, isn’t it? The people behind Redwood, they’re not spring chicken. Not to say they’re age-old, but they’ve been around the block, haven’t they, in terms of web development?

Anthony: They’re seasoned. Yes, I’ve actually framed a nice quantity of time into writing about the history of the framework and the ideas that have led to it, and Tom Preston-Werner is the creator, and so he’s also known as the builder of Jekyll, which is a really influential static place generator. He likewise did TOML, the configuration file language. And he was the CEO of GitHub originally. So, his work with Jekyll and GitHub pages and that sort of thing I fantasize has really led to what we now think of as the Jamstack. A fortune of people would say, “Oh, the Jamstack’s brand-new. They’ve been doing this forever.” That’s how we’ve been talking about how it’s an extension of these older suggestions, the static area generations, but with GraphQL and serverless and these ideas of how to use glue code and APIs to make your app work.

Drew: So, this is definitely from people who are very embedded in that community? I imply, the CEO of GitHub, you really don’t get more embedded in the kind of open informant community than that. So, Redwood is a full load frame and I guess that means you’ve gone Redwood code running in the front end and in the back end. Is that right?

Anthony: Yeah, this is the first thing I like to explain to beings when I’m showing them a Redwood project, is that it’s a monorepo. So, you have your front end and your backend in the same repo, and then each of those live in their own folders. You have a web folder, which is your front end, and it’s fairly similar to what you’d get from a Create React app. Then, you have API folder, which is your back end, and this is where all of your performs get basically shoved into one large-scale GraphQL handler that comes deployed to AWS Lambda through Netlify.

Drew: Okay, so starting at the breast, as you mention, it’s located around React. Is that React plus a assortment of Redwood code, or is it just plain React? What’s the balance there?

Anthony: It’s a lot of things. It’s definitely really React in the sense of you’re not bringing in a lot of state management libraries, you’re not even bring back a router actually. They have their own router that they wrote, and they use a lot of GraphQL stuff. So, when people talk about React and GraphQL and friends, that’s a bit of what’s going on now, is that it gives you a lot of default integrations to get React talking to your GraphQL. Because we have a lot of patterns now over how to use React, but the data deliver is still a huge hassle.

Drew: So, it’s React configured with a cluster of other implements “whos working” neatly with React to give you a functioning ecosystem for doing this particular style of duty. Is that a fair description?

Anthony: Yeah , no, yeah, that’s a great way to keep it. The highway Tom has put it is that there’s all these best of reproduce answers that exist, and certainly sophisticated tools and technology we can use, but it’s really hard to actually leverage them because you have such a huge startup cost, and having to learn them, having to figure out how to integrate them. So, they set the tagline as, “We do your webpack config for you.”

Drew: I think it’s a common tendernes notes that you hear from lots of parties when they’re trying to get started in the modern progress framework with client side JavaScript apps and configuring network multitude, configuring all the different things, the build processes, the body-build steps. It can be quite a minefield, can’t it, to get everything stolen together and labor? And it’s a long way before you get to “Hello, World! “. So, Redwood is giving us all that preconfigured?

Anthony: Yeah, it’s very much a gathering over configuration category intuition, because you have … Tom was, like he improved GitHub with Ruby on Rails and Rob, one of the other core benefactors, he’s been a Rails developer forever. They have a lot of intuitions that philosophically they align with in terms of Rails, but they wish to make those pact over configuration feelings, the full stack framework themes, and implement that with all the modern engineering we have now.

Drew: So, you mentioned that Redwood gives you a router or a router, as we say over on this feature of the pond, does it come with things like default components and any of that sort of stuff in React, or are you merely then to implement all that yourself?

Anthony: Yeah, the router is, it’s very sophisticated. It does most of the stuff that you would get time from React router, it has only been recently kind of different ideas in terms of how these should be established, because Next they likewise have their own router, and it’s still not really perfectly figured out how we want to get our single page app routing to work. Because of Suspense, you have a lot of these kind of questions over where is the async stuff going to come in? We have with Redwood, this idea of a cell, and this is what really does your data fetching for you.

Drew: So, perhaps we could go into that a little bit? What is a cell in terms of Redwood?

Anthony: Yeah, so a cadre is a default way to write a GraphQL query and then have your page basically tell whether you’re getting the data back, whether you’re getting an error back, whether you’re in a loading government, or whether … There’s one more state, I forget. But yeah, so it gives you the different states that basically you can be in based on whether you are getting your data or not. It’s setup with Apollo under the treats. So, if you’re exercising Redwood, you’re using Apollo as your GraphQL client, but you don’t ever have to think about it. You never have to write any Apollo or even “ve been thinking about” it, it’s all roasted in. It lets you time write GraphQL queries, which was really the dream of why people wanted GraphQL, is that it was this really simple query language that front end devs could use. But then, you had to figure out how to set up a GraphQL server, you had to figure out all this other substance, and how do you get that everyone is cabled up. So, it does all of the GraphQL integration for you so you can precisely write GraphQL, you don’t have to think about how do I even implement GraphQL.

Drew: So, I approximate one of the classic activities of a framework is to take all the boiler plate code that you could write yourself and implement it for you, and tidy the way behind the scenes so you never have to look at that boiler plate ever again, and you can really write the system that’s unique to your environment. I guess that’s what’s going on with a cadre is it? There’s nothing revolutionary now, it’s something that you could set up a React component to have all this different states and you could hook in Apollo and you could do all this yourself, but that’s actually quite a lot of work and it’s a common blueprint. So, Redwood has straightened up into a nice, reusable pattern that you are eligible to simply start using without having to think about it. Is that a good description?

Anthony: Yeah, they came up with the list but they unquestionably acknowledge that this was a practice they heard regularly and that they accompanied a lot of people merely coding it themselves, and they decided that they demanded a declarative channel to do your data fetching. So, that’s why you have this setup, because it lets you just have your different states and you don’t have to do if/ then logic to figure out, need to do this if this happens. So, it’s about precisely having a single road to declare all the different territories your data could be in as you’re loading it.

Drew: It’s one of the characteristics of React, isn’t it, that React doesn’t try and give you an architecture for your assignment, it lets you decide how you’re going to structure things. That, of course, has pros and cons. But, it seems like Redwood is imposing some of that design for you so that you don’t have to think about it and so that it can positioned the plumbing in for you and sort of pick up where React left off in terms of giving you that sort of structure.

Anthony: Yeah, and I think it’s really interesting that we’ve identified several different attempts at this solution to this problem, because I mean you’ve had people who’ve been saying it forever, “Why isn’t there a Rails for JavaScript or a Rails for React? ” There’s a great Full Stack Radio interview between Michael Chan and Adam Wathan announced React is Not a Rails competitor. This is one of the different frameworks.

Anthony: The other ones are BlitzJS which has come a good amount of chatter, and then Bison is kind of a brand-new up and coming one. They all have a same load, but they use different sections. You’ll have React query instead of Apollo, or you’ll have Chakra instead of Tailwind. The people who are putting together all these bits into their stacks, all these loads are kind of, they’re battling it out, it’s all very friendly competition. Actually, that’s one thing that I certainly appreciate, is that we actually all collaborate between the frameworks as well. There’s no antagonism there.

Drew: So, we’ve mentioned Apollo and GraphQL, Redwood abuses GraphQL quite heavily as one of the core patches, isn’t it, of the agreed framework? We are likely dedicate an part podcast incident to simply GraphQL, but for those who aren’t familiar, what bit is GraphQL doing here, what trouble is it solving in this context?

Anthony: Yeah, this is a great question. When I am telling beings what they should know to have a good start with Redwood, I’d say that you should have worked Create React app, really if you’ve made a Create React app, and you’ve deployed it to Netlify or Vercel, that’ll get you a good start. Then, know at least a little bit of GraphQL because it is very central. So, the GraphQL is how your front end will talk to your back end. They say it’s a query language for APIs, the idea being that it’s meant to be an alternative to RESTful API programmes, and that instead of doing that RESTful thing, you are sending queries which specify exactly the hierarchical data arrangement you want to receive back from the database. So, it requires a little more startup is necessary to get your GraphQL server to talk to the two cases. Then, once you have it there, the front end makes have the ability to get data in much more flexible way. You don’t need all these different API endpoints that your back end guys need to keep making.

Drew: So, if there are changes in requirements in the front end, probably you can then merely nip your GraphQL query and you don’t need the help of somebody who works on the back end to originate that reform for you?

Anthony: I represent, the real dream is you can throw on a mobile buyer to it, that it would be that resilient eventually that it becomes, you are eligible to have various patients all is speaking to your one API. Your GraphQL API becomes your source of truth, that’s where all your logic is centralized. Then, you can build all these different view beds on top.

Drew: So, we’ve get GraphQL there sacrificing us the ability to query some sort of back end. In Redwood, what is the back end?

Anthony: Yeah. There’s a duo different ways to create your back end. There’s the mode you’ll get out of the box with the tutorial, which is you use Postgres database deployed on Heroku, super easy, super simple. Then, your Redwood app talks to it with Prisma. I don’t know if you’re familiar at all with Prisma, but it’s like an O/ RM. They specific say it’s not an O/ RM, it’s a query make, which is a little more lower level. But, for the sake of only illustrating it to beings, Prisma is the thing that lets you talk to your database. It does your migrations and designates up your tables. It does all the SQL stuff so you don’t have to write SQL. To me, that is just like an O/ RM. You don’t definitely need to use Prisma though to use Redwood.

Anthony: I actually built a simply proof of concept app where we use FaunaDB instead. FaunaDB, they have their own GraphQL API, so you are eligible to time route GraphQL API directly to Fauna, and then do your database mutants that acces. You lose a lot of the functionality of Prisma’s CLI, but Prisma really it’s a appliance influence to work certainly readily with your relational database. But certainly, anything you could think of, you could figure out how to secure it up with Redwood is what I found out only because it’s built around GraphQL and the whole degree is to be able to talk to all these different pieces.

Drew: So, Prisma is essentially a sort of abstraction layer between your system and whatever data warehouse that you’re applying presumably that Prisma assists, is that … or is it doing more intelligent things than that?

Anthony: Yeah, so you write a schema, so you create a schema.Prisma file, and it would have model post, and then it would have id and integer and vehicle increment, like claim sting, figure string, created at date, experience. So, you’d create basically what you want to be in your database with the different types, and then it does the database stuff for you so you don’t have to interact with the database.

Drew: So, you use Prisma to define I guess what sort of database or what sort of data store that you’re talking to. Then, in there you lay out your different mvc representations to use that parlance. So then, when your employment is talking to the data stores, it’s kind of using an instance of a Prisma client, is it? Is that what’s going on?

Anthony: Yes. Yeah, that’s exactly it. So, in your back end’s API folder, you have a lib folder with a db.js, and really by default that has your Prisma client set up. So, that’s all the stuff you get out of the box, and like you said, Prisma can work with different databases. It can switch between SQLite for progress and then Postgres for make, that kind of thing. It’s chiefly relational ones right now, but the roadmap has things like Mongo and Fauna on it.

Drew: So, that’s quite useful then if you can set up and use SQLite in your neighbourhood exploitation environment as you’re getting things up and running, and then go into production with something like MySQL.

Anthony: That’s exactly how the tutorial must be drawn up, that’s the workflow it shows you.

Drew: It’s quite interesting, isn’t it, to see a very modern approach to a structure then precipitating back on some of these more traditional databases like MySQL. I’m very familiar with MySQL. I desire it for its stability and I cherish the relational way of accumulating data. I think it uses so well for so many things. Often you insure the baby throw out which was the soap water when it comes to the newer types of data store, so it’s quite interesting to see Redwood by default support such good, age-old relational databases.

Anthony: Yeah , no, that’s such a good point, because I say that for all the brand-new substance Redwood mixes together, there’s some things that actually says the aged, tried and true way is actually the best. So, they are really big on relational databases. That comes from Tom’s experience with using Rails and having a relational back end. Active Record was the O/ RM layer that Prisma’s “ve been meaning to” approximate.

Drew: I approximate, we’re talking about a serverless architecture here with Redwood, and we talked to Chris Coyier I speculate two or three chapters back, all about serverless exploiting APIs and massed purpose and things. So, taking a step back, if you were to think in terms of a server based fabric, like we mentioned Ruby on Rails or something like Laravel in the PHP world. Even with a React front end, your API request would be running code that is Rails code or Laravel code plus then your customer code and configuration. Is that the same with Redwood? Is there actual Redwood server code that runs, or is it time more implements and formation and glue that enables you to implement your own?

Anthony: Yeah, so in the back end, there’s a file solely that is a way to take your SDL, so you have your schema definition language, and then you have what are called your services, which are like your methods for talking to your back end. Then, all of this does stitched together into a GraphQL handler that is deployed to a single Lambda function. So, it’s optimized for Lambda specifically. We actually most recently had someone get it on with the serverless framework, and we’ve got some people working on Azure and Google Cloud something. It’s not Google Cloud function, it’s the one built on top of that. But yeah, so it’s right now basically optimized for deploying your back end as a GraphQL function in an AWS Lambda. This is the stuff that’s all occult happening in the code I don’t understand, but that’s the high level explanation.

Drew: So, there are deployment tools are there, that take all the code that you’ve written, squash it all together into some sort of magic ball of code that can be executed in the mas and leans it up onto AWS or do you still have to manage that process yourself?

Anthony: Yeah, so it’s all done through Netlify if you follow together with the tutorial. You don’t genuinely have to mess with any sort of serverless capacities yourself. The material that wires your back end together to shove it into the AWS Lambda, that’s all handled, you don’t have to touch any of that system. That’s all rendered out of the box as your pacts over your configurations so you don’t truly have to think too much about how to make it serverless. It’s serverless by default. It’s certainly a hard thing to wrap your ability around. It made a while in order to be allowed to wrap my head around it.

Drew: Yeah, because it’s an important point isn’t because there are actually now a few cases different arenas we’re keeping track of now. We’ve went I study three different places. We’ve came our front end React app, that’s running in the browser, and then we’ve got an API that is GraphQL based, running as a vapour purpose, and that’s responding to our inquiries, but that’s then interacting with a data warehouse which employs Prisma. And that data store is what and where in this, because you can’t run a MySQL server on Netlify, can you?

Anthony: Yes, that’s where Heroku comes in. So, in the very last part of the tutorial, you deploy your front end to Netlify and then you deploy your back end to Heroku Postgres and you precisely grab your config variables from Heroku, push it into Netlify. Getting your Netlify front end to talk to your Postgres back end is a really, really simple thing. They wanted to go with the thing that was going to be the easiest for anyone to get invented up, but there has good stable, clash measured tech. At the end, what you get out of the box merely by following the instructions, is really incredible.

Drew: Jamstack devotees will be familiar with assistances like FaunaDB that you mentioned that accommodates a data store as an API, AWS has DynamoDB, Google has come Cloud SQL, and so on. So, you mentioned that Redwood is looking at integrating, or I predict Prisma is the component now that’s looking at integrating with those kinds of services that are further down the line?

Anthony: Yeah, this is a good question. This is something I’m actually talking with Ryan Chenkie at Prisma about kind of helping out with, is what is the kind of database story for Redwood for things that don’t undoubtedly work with Prisma? Would it be better to figure out a method to get Redwood to work with it immediately like I did with Fauna or would it induce more feel to implement a operator for Prisma? So, there’s different ways to approach it. There’s obviously hundreds of thousands of different databases now that everyone wants to use, so it’s how motivated are you to get your data store onto it. There’s a lot of community contributions going in there.

Drew: So, because Prisma understands your simulation and it knows how to query them, is it able to generate some kind of movements or things like that to help you get that database set up?

Anthony: That’s precisely the thing that you lose out when you are required to take Prisma out and get your data, is that you lose all the migration operates. It has a really boosted CLI that does a ton of stuff for you, so you can go through the whole Redwood tutorial and participate the Prisma requires and you don’t have to have any idea what it’s doing, it time wields. It’s a really great tool for doing all that kind of database type stuff that wishes to make sure you get right and you want to make sure it’s done correctly.

Drew: It seems like having a really good tooling around fabrics is quite a modern trend, isn’t it? To not just say, “Here’s all the things that this framework can do, but here’s perhaps some CLI tools that are going to do a entire cluster of it for you.” Time Redwood have tools for things like CLI generators and trash to get you up and running soon?

Anthony: This is probably the biggest key aspect that you get from Redwood, is you get a whole mounted of very sophisticated generators. For anyone who’s ever seen the original Ruby on Rails demo, that DHH generated, he builds a blog in like 15 hours and he does it all with Railing, and beings are like, “Whoa, this is amazing.” That’s the effect Redwood is going with. They require you to be able to get everything spun up really quickly so you can generate sheets, you can generate layouts, you can generate your cadres, which I was talking about, and you can do a scaffold dictation that is going to create your part CRUD interface. I have a whole segment, percentage four of the blog succession, really explains all the code that the scaffold gives you. It gives people so much code. There’s an off generator, there’s even a Tailwind generator that configures your tailwind for you.

Drew: That’s amazing. I recollect interpreting DHH’s demo of Railing. I convey, it was probably, what, 15 years ago now when he first did that scaffold and showed you, and you get a fairly rudimentary but functional control panel virtually to enable you to create new pieces, edit them, remove them, et cetera. That can be invaluable in a project, especially working in a sort of dynamic environment where, okay perhaps you’re going to implement better implements in the future for editing that content, but it means being able to spin something up swiftly, you can get test data in, or you are eligible to even side that over to a material team who could start working whilst you’re working on the front end, so that’s really useful.

Drew: If wishes to merely deploy that and have that in product, presumably you can just deploy it along with your front end code, but you’d need some path to secure that aspect, those beginnings in your application.

Anthony: Yeah, there’s a marry different options for authentication. You can use Netlify identity. That’s the default if you go into the tutorial, and then you can also use Auth0, and then one I’m not familiar with announced Magic.Link, and there’ll probably be a couple of extra ones added in the future. But yeah, so there’s a couple built in solutions there already, and that’s the very last thing you do so that’s the very last part of my totality 12 duty blog serials is the Auth one. I don’t envision I’d ever figured out Auth before I squandered Redwood. It’s hard-boiled and they’ve certainly done a good job with it.

Drew: Does that integrate at a superhighway level, or a superhighway degree, sorry, how do you assure things?

Anthony: Yeah, so part of how they have their own router, they too have … You can do private routes, so they have a private roadway ingredient. Then, your actual login shape, that’s what you get from Netlify identity so you don’t have to actually create a form and do your country conduct with that, that is where a lot of problems come into play. Taking apart the really key parts and then you can time implement role located access. We have capacity located access govern add on that was been done over the last couple weeks be David T. So, there’s a lot of work happening to create other ways to do it, but what they got now is already … it wreaks, it’ll get you functional.

Drew: People always say about security algorithm hashing cryptography, that you should never write your own because it’s never going to be as good as the things that are out there. Increasingly, I think that’s also true-life of authentication at a higher level; that authentication is such a complex area these days that people want to not just log into your site with peculiar credentials, but they might want to authenticate consuming Google, or they might want to authenticate employ an Apple device, or they might want two point authentication, or they might want to integrate it with a single sign on service that they’re use from an enterprise. All these things are such a headache if you try and implement it yourself and so much opportunity for getting something wrong and exposing defence defects in your employment, that using an authentication work seems almost like a no brainer at this point to me. So, simply being able to drop something in with virtually a few wrinkles of system and be up and running sounds like a really productive channel to work and to keep things secure.

Drew: It sounds like the deploying both the front end and the server aspects, the serverless perform things, is a naturally fit for deploying to Netlify. Are you tied into that with Redwood? I represent, we mentioned that Tom Preston-Werner is one of the prime proponents of this framework, he’s also on the board at Netlify. Do you think there’s potential for too tight a coupling there if you were to choose Redwood as the basis for a project?

Anthony: Yeah, this is something that Tom’s emphatically conscious of. He’s invested in a lot of companies that float around. He invested in Prisma and Fauna. He wants to only compile the tools he wants to use. It’s not about we want to lock you into this thing so much as what Netlify has built he thinks is the best option, so that’s why they built around it. But, they don’t want it to be locked in to any one deploy target, and that’s why we have work being done on things like the serverless structure and some people have talked about Begin. We want to be pragmatic, we want it to work for whatever someone’s use case is. So, we got to get 90% of the acces and then you just have to wire up the last couple things to get it working in collaboration with whatever your servers of select is.

Drew: I guess even Netlify is using AWS Lambda for the servers runs so it’s actually the deploy portion that’s taken care of by Redwood there, and actually you could deploy that to Lambda yourself. Posting your front end is just documents, isn’t it, it’s CDN based the rest of it? So, there’s quite a lot of opennes there without being too tied in.

Anthony: Yeah, there’s a actually a word that Tom talks about as the core philosophical doctrine behind Redwood, which is that we want to get to a universal deployment machine. That’s various kinds of t hypothesi, is that you can time deploy things and you don’t have to think about it at all. He’s been talking about this idea for years and times and years, and this is what Jekyll was even about back in the day. When you hear that now, you’re like, “Oh, you signify like Netlify? ” That’s basically what Netlify is to most people who are working on the front end. They don’t even “ve been thinking about” deploying anymore, it’s not even a thought.

Drew: Here’s my employment in a Git Repo, this directory is the front end, this directory is the back end, here’s my database, and that’s about as much configuration as perhaps you would need for then whatever assistance to take it and to build it and host it.

Anthony: Yes, and one thing I was necessary to point out, we just very recently went Vercel Redwood default deploy set up, so when you’re deploying on a server area app you can say, “Oh, I have Gatsby app, ” and it knows exactly how to build a Gatsby app versus a NextApp. We have that for Vercel now. So, there are really, really good non-Netlify alternatives as well, if you’re more into that.

Drew: So, if I wanted to get started and build an app and take it into creation the coming week, is Redwood ready for that? Is it mature?

Anthony: Yeah, we’ve got about a half dozen apps that are in production right now. The first one was announced Predict COVID, which came out back in March, and it’s like a realtime data visualization application. Then, we’ve came repeater.dev is done by Rob, it’s like a cron errand like thing for Jamstack. Then, there’s Tape.sh, Duoflag I think is another one. So, there’s at least a handful. If you go awesome Redwood repo, “youre seeing” a schedule of all of them. If you go to the community meetings, you can find write ups of these as well, because people have thrown these into make and kind of said how it travelled. So far, they’ve all been successful and no one’s said, “I’m never employing this again.”

Drew: But, it is very new. I guess there’s no escape that, but in terms of maturity, Redwood’s fairly new, it’s getting a good following.

Anthony: Well, it’s funny, it is and it isn’t. It was announced in March. At that pitch, it had been used to work for about a year by Tom and Peter. So, they’d already gave a ton of upfront work into this, so it wasn’t like I’m going to announce this project with a Read Me and then start building it. By the time they announced it, it wasn’t … It’s not a 1.0 now, but it’s quite dang close in terms of what people would expect out of a 1.0. But, Tom is very against what we call type driven development so he ever deviates on the say it’s not ready. So, we say it’s not ready for production even though it’s in production.

Drew: I reckon one thing that parties sometimes get burned on using frameworks is that they’ll build a project around the framework and then that fabric will very quickly go to another major version that had downwards conflicts, and they’re then left with a big project to update everything onto the new version of the framework. Is that something that’s likely to happen with Redwood? I want , nothing of us has got a crystal ball, but simply with these new technologies that are involved and the lane it’s organized, do you think that’s a big danger or a little danger?

Anthony: Yeah, it’s a super valid concern and obviously something the team has thought about. The CLI has an upgrade command, so you are eligible to basically every time there’s a version protrusion, you only do a mastery and it bumps you up the edition. I’ve been dealing with this a little bit only because of the succession I wrote, I started it when it was on version 11 or 0.11, it’s like 0.17 or something now. So, I’ve been slowly iterating on it as it’s gone but nothing destroys. It’s all, you get slowly things, or like “Oh, this is kind of a neat little touch you’ve got now, ” but it’s pretty much set in stone architecturally. Redwood as it’s organized, the breast or the back end is not going to change at all. It was very well thought out in terms of what they want architecturally. That’s why they improve it, so they could get something that’s organized like this thing.

Drew: I suspect with modern web development, there is a certain point where you’re just never going to get away from being reliant on reliances revising themselves and changeable. I want, even consuming React, React goes through as many different deepens as anything else.

Anthony: That’s exactly why Tom inventing semantic versioning.

Drew: I predict from the other side of that coin, if Redwood did happen to go away, which is always something we consider when picking a framework, if growth stopped somehow, I guess the impact on a particular app might not be too great because it is just so heavily built on existing other projects around. Is that-

Anthony: Well, some is suggested that a Redwood tree can live a great deal, it lives for a very long time. That may have been why it’s called that, is that you can merely make a site and deploy it and it’s not going to break, it’s just going to work. So yeah, maintainability, sustainability, all that kind of stuff, that’s vast. Being built by people who tried to scale Rails apps, I imagine they’ve thoughts a good deal about that. But in terms of the going away part, that’s always going to be a danger with any open source projection, so I think what you have to look for is how fervent is the community to continue it without the team if that ever happens. I don’t think you even need to worry about that because Tom’s a billionaire and he has a venture fund thing that is funding some of new developments. It is an open informant projection that is well funded actually. It has four full occasion representatives, Tom, Rob, David, and Peter. You just go to the forums, you can see the activity that’s going on, so I wouldn’t worry about that too much-

Drew: Of course.

Anthony: Beyond normal open root was concerned that being here with that stuff.

Drew: What is the community like? You mentioned the community, are there lots of beings exploiting it and contributing to the code base or is it mainly the core crew who are doing the evolution?

Anthony: Yeah, it’s very much structured to be a community thing. They want to get as much buy in from the community as possible, and this comes from the lineage like you said. There’s few people with more open source cred than Tom, so he’s done a really great job of introducing people into the fold. I visualize exactly my story in general is a big win for the community because I “re coming”, I’m a boot camp student, I’m learning all this nonsense as I disappear. I’m not propagandizing system to the repo, I’m preparing doc lodges and writing blog clauses and trash, but they still invited me to the core helps matching because they saw what I was doing and they thought it was adding value. Yeah, there’s genuinely a lot of things about how they approach parish build that I have a lot of respect for, and that is why I’ve been so invested in it and putting so much of myself into it.

Drew: Some fabrics have got this sort of natural inclination for certain types of projects. For instance. The Python framework, Django came out of online news publishing, and so it’s a really good fit if you want to rapidly publish content like you would in a news organization. Does Redwood lean in any particular direction when it comes to the type of projects? Is it suited for material publishing or constructing web lotions or-

Anthony: It’s made to be fairly agnostic to that. It wants to be a tool that you use for a lot of material. First, before it was announced Redwood, it was called Hammer, the idea being that you do a good deal of stuff with a hammer. But, there obviously is a kind of sweet spot, which I think is the multi client type applications. So, if you know that you’re starting with a entanglement front end but you’re pretty sure you’re going to end up with a mobile client as well, then it’s a really good fit for that because it starts you off in a manner that is that you’re going to be able to extend into having multiples patients with GraphQL, which we kind of talked about a little bit. So, I’d say that’d probably be the first thing that I would say is its sugared recognize. But, it’s meant to work for as many things as possible.

Drew: Does Redwood have a published roadmap of where it’s proceeding? What can we expect to be coming in the near future?

Anthony: Glad you asked. We just put under a roadmap to 1.0 less than a month ago, it was probably like two or three weeks ago. It kind of lists things that we’re working on, things we think we’re kind of close on, things we think we still have a long ways to go on. That kind of facilitates the community see where can I help contribute. That’s one of the things we’re really great about is showing here are the things that still need to be worked on. They’re aiming for 1.0 by the end of its first year. We’ll envision where we get with that, but that’s the path we’re currently on.

Drew: One of the elegances of a Jamstack and a serverless approaching I always think is that it’s this idea of lots of segments loosely connected that has acted us so well in computer science up until this extent. It should be really easy to scale up a Jamstack and serverless campaign because you can add multiple front ends or you could leant more resources behind extending your runs, and you can scale up a big engineering team by having people work on different small-scale segments. Is there a possibility that accepting a structure around all of that, that you might be taking a strewed structure and creating a tighter fixing than you might otherwise have? Could Redwood become the monolith that acts as a impediment in your engineering attempts?

Anthony: Yeah, this is something I think about a lot because as I learned web blooming, I was taking … I’m in a boot camp that supposedly is full stack development, but you learn each section in isolation. We’re essentially learning the PERN stack, but you learn React, and then we learned Express. We never has spoken about how it actually is currently working. So, I do think that there is definitely a danger of not being able to comprehend in your campaign because of how it’s all cabled up. So, what I really liked about Redwood is that it just made sense. It was a mental framework of how to think about my part app and all the segments and how they fit together in a way that really made sense to me. But, what I was surprised to find doing the Fauna project is that it’s much more modular than you would think based on … You talk about it, and like you said, it sounds like it’s a monolith thing, but you can rip parts out and replace them with other fragments and they can still work. So, it’s made to be a fully integrated solution, but not a solution that is tightly coupled just because this is a good way to integrate all these technologies doesn’t mean you need to tightly couple them to integrate them well.

Drew: Yeah, that reverberates a very promising way of organizing things, and it’s going to be really exciting to see what happens with Redwood as it gets to version 1.0. Is there anything else we should know about it that we haven’t talked about?

Anthony: No. I intend, I would say if you’re interested, merely check out the tutorial on YouTube, the RedwoodJS tutorial. They have what they call tutorial ride growth, which is kind of a play on Read Me driven development, which is another thing Tom coined, that you should start with a Read Me, and then create your system to make sense with what your Read Me was. This is the idea of you create a tutorial and then you write your framework to spawn the tutorial undertaking. So, that’s why it’s a really easy way to get spun up with it because it was made to make sense of going through the process of learning it. They’ve genuinely thought about how to actually get onboarded into a massive framework with all these different pieces and all this different brand-new tech. They progressively reveal it to you as “theres going”. The series that I wrote is very heavily influenced by it. I virtually constructed the same project, but I write my own stuff as I go, and invoke the docs. So, if you’re interested in exactly learning Redwood, start with the actual tutorial and then check out my series.

Drew: So, I’ve been learning all about Redwood, what have you been learning about?

Anthony: Yeah, so I’ve been learning about CMSs, and I was actually actually curious to get your thoughts on this because I imagine you’ve been around the block, you know a lot of CMSs. Obviously, you know you’ve got your WordPress’s, your Drupal, but what’s really interesting with something like Redwood is since you have this GraphQL stuff roasted in, it has the CMS, it’s precisely such a natural fit. So, I’m trying to figure out, what are interesting headless CMSs to check out? Which ones have GraphQL integration? Which ones have different sweet smudges? If I wanted to take a CMS to build an app with RedwoodJS, what would you recommend?

Drew: That is a good question, and I’m not sure I have an immediate refute. I have looked at lots of different CMSs , not particularly with a view to GraphQL. I’ve not worked with GraphQL myself hitherto, and so that was not-

Anthony: Oh man, you’ve got to join the club, dude.

Drew: Yeah , no, I’m certainly getting onboard. But yes, I have a requirement at work that may be coming up to know a bit more about GraphQL, so it’s certainly one of the things that I need to be learning.

Anthony: I actually learned GraphQL through Redwood. I didn’t truly know GraphQL, and I’d say you should know a little bit before going into it, and I had a unusually, very tiny basic knowledge. You going to be able to learn what a schema description word is, and that GraphQL kind of jargon. You’ll learn a lot and you’ll pick it up as you go with Redwood.

Drew: Yeah, I is certainly get onboard and maybe doing some Redwood is the way to do it. Perhaps I need to pick up a project and start going with Redwood and encounter where it takes me.

Anthony: Yeah, at the least I would say precisely check it out, exactly because it’s interesting. I find it to be time a really fascinating reckoned experimentation to seeing how do we do modern network application developing differently and more coherently.

Drew: If you, dear listener, would like to hear more from Anthony, you can find him on Twitter at ajcwebdev. His comprehensive streak of articles about getting started with Redwood are on the Redwood community site, which we’ll link to from the reveal indicates. Of trend, you can find all about Redwood and is starting at RedwoodJS.com. Thanks for assembling us today, Anthony. Do you have any parting terms?

Anthony: Just if you’re interested in any of this stuff, feel free to be achieved. My DMs are always open. The community is very open in general. I’ll be happy to explain or walkthrough or get you set up with anything you need to know to get going.

Read more: smashingmagazine.com