DEV Community


Posted on

Is There a Complete In-Depth Reading/Tutorials/Guide for Full-Stack Development?

Are there any resources out there that really get in depth about a true full-stack for building web or mobile applications? I know about MERN/MEAN stack which includes: M - MongoDB - used to host your data E - Express - middleware to spin up a server R/A - React/Angular - used to build the front-end through components (Made up of HTML, CSS, JS) N - Node - I think of it as an easy way to keep track of and download dependencies instead of going through one by one. It makes it easier for multiple people to use and start working locally. An index in a ways to your project.

However, this doesn't really cover anything like testing, CI/CD, Docker, Kubernetes, pipelines(yml), Schemas, version control hosting(GitHub/GitLab/Bitbucket), git vs yarn, etc. Maybe this is what DevOps is?

I am sure I am missing a few things, but is there anything like that out there, or do I just have to piece it together as I do my own research?

It would also be good to know alternatives, like git vs yarn, MongoDb vs a traditional database like MySQL, using client-side JS vs a true back-end language like C# or Java.

I have experience in the front-end; HTML, CSS, JS; but I am lacking in the back-end knowledge and am curious to learn more. I've even gotten things working locally on a C# project with MySQL, but have no idea how to move forward and host it in the cloud to make it truly a live application.

Anything will help moving forward, even main keywords to look for.

Top comments (6)

nikfp profile image
Nik F P

If you were compelled to write this post to begin with, you are obviously interested in tech in general, which is good! Remember though that tech is HUGE and it's easy to spread yourself very thin in the name of learning everything you can.

If it helps, I started following this heuristic to help me out.

  1. If I hear about something new, make a mental note and move on.
  2. If I hear about it again, take a brief look at it on a break or when I have some downtime. If it's cool but I don't think I need it right away (or at all), put it on a "nice to learn" list, and move on.
  3. If it turns out I might need it or I do need it, find some introductory resources and dig a bit deeper.

My thinking is that there are SO MANY things to learn and I find them all interesting, and I needed a way to NOT feel like a cat chasing a laser all the time. By pruning the things I was trying to tackle, I was able to stay in the context of the thing I really wanted to learn at the time, and the useful things that directly related to my core focus made themselves more apparent and prominent. I also feel that I gained a more natural progression from where I started (C#, .NET, Entity Framework) into Front end (HTML, CSS, JS, React), then eventually back around to back end and full stack (Typescript, Nodejs, graphql, Nextjs and Sveltekit, etc.) There were also lots of little things along the way, like NPM vs PNPM vs Yarn, that just sort of made themselves important when I found I was touching a boundary between 2 pieces of tech. Had I tried to plan all that progression out ahead of time, I think I would have gotten the plan wrong. There is just so much variety in how things can be done, and what fits some people doesn't fit others. I couldn't have possibly know what I would enjoy ahead of time.

So, what can offer based on my words above is not really a roadmap, but perhaps a compass? Find the thing you are working with that makes you the happiest, and work from that. I can say this much though: Learn git. It's one of the few truly ubiquitous things in tech.

mitchelln11 profile image
mitchelln11 • Edited

I guess even a basic level guide/list would be nice as well. What are all the areas of development. What are some programs that I could look into on my own.

Ex: Version Control Hosting:

UI building:

  • React
  • Angular
  • Vue -etc.

Maybe not necessarily "in-depth".

nikfp profile image
Nik F P

Given that you have already learned both JS and C#, I will make the assumption that you understand things like decoupling and modularity, scope, and other basics of writing software. So let's look at what comes after.

At a fundamental level, Git will be everywhere, so it's a good place to start. Once you understand the basics (commits, branches, merging) you can start looking at version control systems. In the beginning, Github is probably your best bet as it will have the best coverage from people writing tutorials. (Not to knock on Gitlab and Bitbucket - both still good!) Whereas Git is about managing code as it changes locally, Github is about managing code as teams change it in a distributed atmosphere. This is a subtle but important distinction.

With Github you can start learning about Issues, Pull Requests, forks, etc. One thing I've seen people do is open 2 github accounts and use them to practice forking projects, creating issues and merging in pull request from one to the other.

UI building for web and mobile is HUGE, so it's hard to even know where to make a list. Obviously React is there, but so it vanilla HTML/CSS/JS. Mobile adds another layer entirely and is it's own beast - do you use something like React Native, or go fully native and develop in Swift or Kotlin? It's a big subject on it's own.

At the other end, you will eventually need a way to store data, so you will need at least a cursory knowledge of databases. In the beginning, relational vs document based is probably enough, and as your experience and confidence grows you can get into the finer points of which options within each category are best for your needs.

Then you'll need the bits in the middle. Somewhere you need a place to receive requests from clients, process them and return results. This could be a traditional Nodejs server, designed to run until you tell it to stop, with something like Express or Fastify as a web framework. (or an server, or a Rails server, or Laravel, etc.) It could also be something in the serverless domain, designed to run in discreet pieces of executable code. Each approach - long running or serverless - will have it's own strengths and limitations.

The last thing to mention - but something important to think about - is where everything will run. For example, you can run a database instance locally, but you will need to manage it. Or you could run it on a virtual machine on a service like Linode, but you will still need to manage it. Or you can use a cloud vendor like MongoDB Atlas, Supabase, etc. - and they are responsible for managing it with the tradeoff that once you get past the free tier you will have some expenses involved.

Same pattern for your server application - Are you planning to run it locally? In a cloud VM? Using a cloud service?

And again for front end - will it be statically hosted and delivered from a CDN? Or will your back-end application serve it on a route?

Looking at these things early can inform your whole build process, but it can also get very overwhelming very fast. And THE LAST THING I WANT TO DO IS MAKE YOU OVERWHELMED! I want you to be successful and enjoy learning. So I'll (cautiously) make the following recommendations.

  1. Don't worry about Docker or Kubernetes yet. Those are useful technologies for the problems they are meant to solve, but until you understand the problems, those pieces of tech will get in the way. Similarly, don't worry too much about CI/CD and building CI pipelines yet.

  2. Find a CURRENT full-stack course you can follow. I say current, because something that is just a few years old might use tech that isn't well supported anymore. So you want to be reasonably up to date or use a course that had a recent refresh. I also think something that does a JS based front end and a Node back end is a great start, because your language skills are portable from front end to backend AND there are some great options out there.

  3. Follow the course and get a full stack app running on your dev machine - a front end in any tech you want (react is common), a web server, and a database. You'll have to install a database locally, but a good course should talk you though that as well. Make sure all the pieces are all talking to each other and you can use the app locally. A classic example is the MERN stack - MongoDB, Expressjs, React, and Nodejs.

The idea is less about what you build, and more about the concepts you learn, which is why a course is helpful. For example, once you hit a Cors issue and work around it, the idea is the same everywhere, and any decent course will teach that. A connection string for a DB is the same concept everywhere. HTTP Methods are a known standard. The implementation might be different in different languages or frameworks, but once you have the concepts and know how to quickly integrate new concepts when needed, it will set you free and you can build anything you want. Then, and MOST IMPORTANTLY, take what you have learned and go build something on your own. Taking the training wheels off is where you really start to embed everything you have learned.

It's a marathon, not a sprint, but it's worth it.

Thread Thread
mitchelln11 profile image

This is a good start. Thank you!

I've gone through MongoDB before and that seems pretty straightforward, but one part I am struggling to find is traditional databases. It seems like any resource points you into the newer json-file-esque database like Mongo. I feel like a MySQL database, on a very light level would be great to learn and I feel like most established companies are still going that route.

I've gotten a MySQL database working locally with a C# project, but beyond that, it's kind of a black hole. Documentation can be a bit overwhelming. I think I would like to have a project with a database hosted somewhere other that locally, but it seems like most places don't really advertise a free-tier for learning purposes. I like how Google set up their APIs and base prices on usage.

Thread Thread
nikfp profile image
Nik F P

Mongo gained a ton of ground as the JS ecosystem exploded, because the data model is easier for people familiar with JSON and Javascript to understand. It's not the only way though.

Supabase is Postgres in the cloud, and has a pretty generous free tier. You can get a connection string to use in any application from their dashboard. Also SQL is the query language for MySQL and Postgres, with some minor variations between the 2 systems. And trust me, relational DB's are everywhere and not leaving any time soon.

MySQL is also the core of Planetscale, but the way they are set up to allow their database "branching" makes foreign key constraints break, so you would need to handle data relations at the application level. Not fun if you are still trying to sort out the bigger picture, but possibly very powerful if you need it.

You can also run SQLite locally as a small, lightweight option.

And depending on how you want to work, you can abstract the queries in a lot of ways. There are rare occasions when it makes sense to send a raw sql query to a database, but it can be unsafe to do so. (look up sql injection) More often you'll use either a query builder library or an Object Relation Mapper library to get it done, and those will usually protect against sql injection attacks.

For example, in C# you can use either Entity Framework or Dapper together with Linq and do awesome things. JS has libraries like knex for query building and Prisma as an ORM, and Sequelize fitting somewhere in between. You can also us db specific packages like postgres.js.

So you have tools, and you have options. Entity Framework from what I remember is very well documented, and you just need to connect to the DB to get going. Prisma.js is very well documented and again just need a connection string. (I use Prisma all the time lately) I'm not sure what stack you want to pursue, but hopefully this points you in the right direction.

mistval profile image

There are some courses that cover a lot of material and bringing things together (I like to recommend Colt Steel's full-stack course on Udemy) but I'm not aware of anything as expansive as what you're looking for (and a lot of things you mention do indeed fall under "DevOps", but they are great for full stack developer to understand as well).

Even if all of that knowledge were packaged up into one single Udemy course or such, internalizing all of it and "really getting into depth" can only be done with hundreds/thousands of hours of hands-on experience. No course can do that, really, though it sure would be nice.

Ultimately I think you will have to, as you say, piece it together as you do your own research, though courses and tutorials can be a great supplement to that (but unlikely to get you all the way there on their own).