Hey folks, and welcome to The Small
Tech Podcast by Ephemere Creative.

I am your host Raph.

And today we're going to be talking about
frameworks and specifically, we're going

to be talking about web development,
mobile app development frameworks.

I haven't been pushing this
stuff yet, but if you enjoy our

content, please, please, please.

Like, and subscribe on YouTube.

Go give us a rating of
five star rating hopefully.

On apple podcasts or wherever
you listened to your podcasts.

It's really, really helpful for us.

We're a small team, hence
small tech, and we would be so

grateful for any help we can get.

Also, if you have anything that
you would like to talk about.

And you want to hop on
the podcast with me.

That would be awesome too.

You can reach out at
raphael@ephemerecreative.ca.

I'll put my email in the show
notes and I'd love to have you on.

Okay.

So before we dive into it, I think we
really need to define what is a framework.

And again, specifically software
development, web mobile app

development frameworks, and
there's a few different things that

kind of fit into this category.

But basically, we're talking about
code that provides a base for

a variety of functionality that
you can generally expect to need

in a web or mobile application.

This often means stuff like
authentication a way to generate an API.

Maybe a way to generate a frontend
and usually like a workflow for

making all of those things happen and
figuring out how they work together.

Often, these are split into
different little sections and they

might actually be cobbled together
from existing open source tools.

They just give you a nice way
of working with them altogether.

So why would you use a framework?

It seems obvious to those of
us who have done this before.

But for a lot of new developers, they
don't know that frameworks exist and

they dive right into just building
all kinds of stuff from scratch.

So why should they use a framework or
why should any of us use a framework?

The first thing that comes
to mind for me is speed.

If you have a bunch of tools that are
already pieced together, and there's nice

documentation on how to use them together.

Then you're going to save a lot of time.

That stuff is already built.

It's organized.

You just use it.

So speed.

Speed is a big one.

Another thing that I find is when
you're using a framework, you're

forced to be more consistent
and that's helpful on a team.

If you don't use a framework,
it's easier for different people

to write code in their own way.

A lot of frameworks will sort of
force you to write things the way

that they expect things to be written.

And so it makes it easier for different
developers on your team to move between

different modules, different components
that they're working on and understand

what other team members are, are writing.

The last thing that really
sticks out to me is support.

And sometimes that
might mean paid support.

There are frameworks out there that will
give you help in exchange for money.

But the other thing is a lot of
really great frameworks have really

big communities built up around them.

And so you can just go onto a forum
or a discord and ask a question

and somebody who is part of that
community will be happy to help.

But the other side of that too, is
when you have big communities, there's

lots of people writing stuff about
these frameworks and how to do things

and they've encountered the bugs.

And so if there is an issue, you can
be almost certain that someone else

has already had it and it's already
documented and they've explained how

to fix it or how to work around it.

Let's talk about some
examples of frameworks.

Some of the ones that are really popular
out there that you may have heard of,

even if you're not a developer are
Ruby on rails Django, and Laravel.

Rails is a Ruby framework.

It has been around for a really
long time and got really popular.

I feel like in the sort of late two
thousands, which is also when Django

started to become quite popular.

I think Django's a little bit newer.

Django is a Python framework.

And, Laravel is a PHP framework.

They each have their
own way of doing things.

I wouldn't say that one is
particularly better than the other.

They all provide very similar
functionality in the end.

One of the considerations might be what
other things you want to do outside

of the framework context that might be
easier to do in Python, Ruby, or PHP?

Python, for example, is commonly
used for machine learning and AI.

So if you're going to build a web
app that also relies on AI stuff.

Then it might be practical to
use a framework like Django.

Okay, next, I'm going to talk
about things that aren't exactly

frameworks, but provide a lot of
the functionality of a framework.

These are backends as a service.

So when we think about frameworks like
rails, Django, and Laravel, they allow

you to do a few different things, that
are quite common in app development, which

is they help you manage authentication.

Reading and writing data from a database.

And creating the user
interface on top of that data.

Now backends as a service, do
most of that without the UI.

So they just give you.

A way to interact with data
as an authenticated user.

And that's it.

So you usually need another
framework or another tool.

To build your user interface
separately from them.

So the backends that I am.

Not necessarily super familiar
with, but at least somewhat

familiar with our Supabase,
Pocketbase, AppWrite and Firebase.

Now I have only used Supabase and
Firebase personally, and they're

pretty similar products in many ways.

The main difference is that Supabase is
open source and you can host it on your

own machines whereas Firebase is a closed
source SaaS product offered by Google.

So, if you're going to use the backend
as a service, you're going to need some

separate way to build your front end.

And that's where front
end frameworks come in.

Some of the ones that I'm familiar
with are Angular, Next, and Expo.

Expo is for building mobile apps, Angular
and Next are for building web apps.

They give you a lot of
stuff out of the box.

Primarily around.

Routing, so figuring out which
URL go like we'll show which page.

Uh, expo we'll do that
with mobile app screens.

They'll do a lot of other stuff around
caching and data management and how

you interact with your backend as
a service or your API or whatever.

I think it's kind of up to you to
just choose one that feels right for

you because in the end, most of them
can do pretty much the same thing.

Okay.

Finally, I am going to talk about.

What we are calling a deep stack
framework and that's because it's

our own product, the Chewy Stack.

The thing that's different about the Chewy
Stack is that if you want to deploy a

Django app or a Supabase app or an Next.js
app, those all need to be configured for

the place that you're going to host them.

So if you're going to host Django,
you'll need to make sure you know, how to

deploy to AWS or DigitalOcean or Heroku
or Fly or any other solution out there.

You'll have to do the same for
Supabase or with Next or Angular.

Each of these things requires a
lot of work to sort of configure to

make them play nice with different
parts of your digital product.

The thing that we think is special.

And the reason we build Chewy is it's,
kind of like a framework of frameworks.

So it ties together backend
tooling to build, on top of your

database and manage authentication.

So we've got different components
for that, that are open source tools.

One is called Hasura.

The other one is called Ory.

And, Uh, front end, built
on Next.js and Expo.

But the secret sauce behind Chewy is
that we make it dead simple to connect

all of those things and to get them up
and running in a developer's machine.

And then more importantly, get
all of them up and running on

different types of infrastructure.

So you don't need to think about, well,
which sort of database should I provision?

How do I make sure that the
database is properly networked?

So it can connect to my API servers.

And is my front end, actually going
to be able to connect to my API and

how do I make Auth play nice with
all of those different components.

We just take care of that for you.

So you can say Chewy deploy to staging,
and we'll provision a staging environment

for you or Chewy deploy to production,
and we'll deploy to production and manage

those servers and configurations for you.

So that's the promise that we are trying
to deliver on with the Chewy Stack.

We want to make it easier for people
to build scalable complex products

without having to put in a ton
of work, just to configure things

and get servers up and running.

Alrighty.

Well, thanks for listening folks.

If you enjoy this stuff.

Please like subscribe on YouTube.

Subscribe to the podcast in
your favorite podcast app.

Leave us a review.

We'd love to hear what you think and
we'd love to have you on the podcast.

If you are interested in
talking about this stuff.

Also make sure to sign up for
our newsletter, where we will be

sending you tons of great info about
how to build small tech products.

It's going to be videos, blog posts, any
podcast episodes you might have missed.

And plenty of other stuff.

So go to smalltechpodcast.com and
you'll see a little newsletter

button at the top there.

And, you can use that to subscribe.

So that's it for this week's
episode, we all want to do some

good in the world, out there folks.

So go build something good.

See ya.