How I Structure New Projects In Golang

Summary

本视频由一位创业者讲述，他介绍了他的公司Laue近期开始进行的2.0版本重写过程。他解释了原项目是用Next.js和TypeScript编写的，但由于公司规模和项目范围的显著变化，他们决定将后端改写为使用Go语言，前端使用SvelteKit。视频中详细讨论了Go项目结构的设置，强调没有绝对的项目结构模式，而是应根据项目需求灵活调整。他还提到了如何处理数据库、业务逻辑、以及如何通过简化的方法有效地管理代码。此外，他鼓励开发者拥有结果驱动的开发心态，并提供了关于如何组织代码、选择框架和处理性能考虑的实用建议。

Takeaways

• 😊没有绝对完美的项目结构,选择什么结构要根据自身团队需求决定
• 👍使用 make 构建命令非常简单实用
• 💡把逻辑分别放到 handlers、packages、data 等文件夹中可以很好地组织代码
• 📁利用 types 文件夹存储共享的类型定义
• 🔨利用 util 文件夹存储公共的工具函数
• ⚙️handlers 只关注请求处理,业务逻辑放到 packages
• 📦data 文件夹处理所有数据库相关逻辑
• 🌈不必局限于后端或前端开发者的身份,要学会全栈思维
• ✅测试业务逻辑用单元测试,测试数据逻辑用集成测试
• ☝️简单的结构容易扩展,要用结果导向的方式迭代改进

Q & A

Laue公司是什么时候成立的？

Laue公司是三年前成立的。

为什么Laue公司决定进行2.0版本的重写？

因为Laue公司最近获得了大量资金，且项目范围发生了显著变化，需要扩大规模。

Laue 2.0版本后端和前端分别采用了哪些技术？

后端采用Go语言编写，前端使用SvelteKit。

视频中提到的'CMD文件夹'在Go项目结构中起什么作用？

CMD文件夹包含独立的包，每个包中都有一个main.go文件，用于引导不同的应用程序，比如API服务。

为什么作者认为在编程中没有完美的项目结构？

因为编程领域中，很多人会强加他们创建的编程范式，认为它是最好的。但实际上，每种方法都有其好处和不足，应根据具体情况灵活调整。

在Go项目中，作者如何看待性能问题？

作者认为，性能在大多数情况下不应该是主要关注点，因为在达到性能瓶颈之前，项目通常会有很大的用户基础，届时解决性能问题是可行的。

什么是'result driven development mindset'，作者为什么推荐它？

结果驱动开发心态意味着专注于实现目标和结果，而不是过分关注使用的工具和包的组织方式。作者推荐它，因为它鼓励开发人员根据实际情况灵活调整，专注于产出。

视频中提到使用什么工具管理数据库迁移？

作者提到使用了一个简单的脚本来管理数据库迁移，尤其是在开发过程中处理数据库处于“脏状态”的情况。

为什么作者提倡在开发中避免过度使用第三方CLI包？

作者认为使用简单脚本可以有效地完成任务，而不需要引入可能复杂和过度的第三方CLI包，从而保持项目的简洁性。

在讨论Go项目结构时，作者如何处理全局变量的使用？

虽然全局变量在某些情况下可能带来风险，但作者认为，如果在正确的时间和地点使用，全局变量是可以接受的。尤其是在数据库实例的上下文中，全局变量可以简化数据访问。

Outlines

00:00

🚀 介绍Laue 2.0版本更新与技术选型

视频开始介绍了Laue公司及其背后的创立故事，并宣布了因获得大量资金投入和项目范围的显著变化，决定对项目进行重写，升级到2.0版本。新的技术栈选择了Go语言作为后端开发语言，前端则转向使用SvelteKit。视频中还承诺展示Go项目的结构设置，因为这是观众经常询问的问题。此外，作者鼓励观众订阅频道，点赞视频，留下评论，并加入他的Discord服务器和Patreon页面，以便获取更多学习资源和课程折扣。

05:02

📁 探索Go项目结构与开发策略

本段落深入探讨了Go项目的文件结构安排，强调在编程领域不存在完美的项目结构，而是应依据项目的具体需求灵活调整。作者提倡结果驱动的开发思维，鼓励开发者追随直觉进行项目结构的设计和调整。具体到项目结构，介绍了二进制文件存放的`bin`文件夹，以及包含主要启动文件的`CMD`文件夹。此外，强调了选择框架（如Echo、Gin等）的灵活性，以及性能问题通常不应成为早期开发的焦点。

10:02

🔧 简化CLI命令与数据库迁移策略

在这一部分，作者讨论了他对CLI工具包的使用方法，偏爱简单直接的脚本来处理数据库迁移和数据填充，而非复杂的CLI工具包。通过实例解释了`drop`命令的用途——解决数据库迁移中遇到的问题，以及如何通过`make`命令来执行数据库操作。这些操作展示了作者对于工具和技术选择的实用主义态度，即选择适合自己当前需求和方便的工具，而不是追求技术上的完美。

15:03

📚 数据管理与全局变量的合理应用

讨论了在项目中管理数据和使用全局变量的策略。作者首先解释了`DB`包的作用，它用于初始化数据库连接，并介绍了为何选择使用`bun`作为数据库交互工具。尽管存在类型安全的担忧，但作者强调了`bun`的实用性。此外，提到了全局变量的使用，虽然它在某些情况下被视为不佳的实践，但在恰当的场景下可以简化开发。数据层（Data）的设计重点在于集中处理数据交互逻辑，而不是混入其他逻辑。

20:04

🌐 处理请求与业务逻辑分离

这一段落深入介绍了如何处理网络请求和组织业务逻辑。通过举例说明了如何使用Go的新特性来创建中间件和处理函数，进而实现请求的处理。作者解释了在Leue项目中如何根据不同的用户角色（比如买方和卖方）来分组处理请求，并使用中间件进行权限控制。这体现了对代码组织和权限管理的深思熟虑，旨在提高代码的可维护性和安全性。

🔨 业务逻辑、类型定义与工具函数

最后一段深入讨论了项目中业务逻辑、类型定义和工具函数的组织。业务逻辑被放在`package`文件夹中，以区分简单的CRUD操作和需要复杂处理的业务场景。`types`文件夹用于存放项目中的共享类型和常量，以便在不同的包之间使用。`util`文件夹包含了一些辅助函数和工具，用于简化常见任务。作者还提到了保持开发者技能的全面性，鼓励不仅仅局限于前端或后端开发，而是成为能够解决问题的程序员。

Keywords

💡Laue 2.0

Laue 2.0代表视频中提到的一个重大更新和转型项目。原本的项目使用Next.js和TypeScript开发，但由于获得了大量资金支持和项目范围的显著变化，团队决定使用Golang重写后端，并采用SvelteKit作为前端技术栈。这一变化旨在提升项目的可扩展性和性能，反映了技术选型随着项目需求和环境的变化而变化的实际情况。

💡Golang

Golang是一个开源的编程语言，由Google开发，专注于简洁、高效和安全。视频中提到，团队选择Golang重写后端，主要是因为它的性能和适合于大规模系统的特性。Golang在项目结构组织和并发处理方面有独特的优势，这与视频中讨论的项目结构设置直接相关。

💡SvelteKit

SvelteKit是一个基于Svelte的框架，用于构建更高效的web应用程序。视频中提到，为了前端开发，团队决定采用SvelteKit替换原有的Next.js。这一决策体现了团队对于前端技术趋势的关注以及追求更好用户体验和开发效率的目标。

💡项目结构

项目结构是指如何组织代码文件和目录的方式。视频强调没有所谓的'完美'项目结构，而是应根据项目的具体需求和团队偏好来决定。视频中提供的结构示例包括了bin目录、CMD目录、data目录等，展示了一种针对Golang项目的组织方式，旨在提高代码的可维护性和扩展性。

💡Echo框架

Echo是一个高性能的Go web框架，提供了简洁的API来创建RESTful服务。视频中提到，尽管有多种框架可供选择，但他们选择了Echo来作为API的基础，这说明了在技术选型时，团队更倾向于选择能够满足项目需求且团队熟悉的技术。

💡性能

在视频中，性能被提到是在选择技术和框架时的一个考虑因素，但不是最关键的。视频中指出，除非应用达到了非常大的用户规模，性能才会成为瓶颈。这表明对于大多数项目而言，开发效率、易用性和可维护性可能是更重要的考量因素。

💡全局变量

全局变量在视频中被提及作为数据库连接实例的一种实现方式。尽管全局变量在某些情况下可能导致问题，但视频中认为如果在正确的时间和地点使用，它们是可以接受的。这一点反映了在设计软件架构时需要权衡不同方案的利弊。

💡单元测试与集成测试

视频中讨论了单元测试和集成测试在软件开发过程中的应用。尤其是提到对数据库交互的测试更适合通过集成测试而非单元测试来执行。这体现了测试策略应根据测试目标和项目需求灵活调整的原则。

💡业务逻辑

业务逻辑是指驱动应用程序行为的底层逻辑，通常反映了实际世界中业务操作的规则。视频中提到，某些功能可能直接与数据库交互，而不涉及复杂的业务逻辑，而更复杂的功能则需要在'package'目录下进行更深入的业务逻辑处理。这强调了根据功能的复杂性来组织代码的重要性。

💡前后端开发

视频最后讨论了前后端开发的界限，强调开发人员不应仅限于一个领域，而是应该具备解决问题的能力，无论是在前端还是后端。这表明在当今多变的技术环境中，成为一名全栈开发人员越来越重要。

Highlights

没有完美的项目结构,只有适合你和你团队的结构

追寻好的感觉,而不是被方法论束缚

性能不是重点,真正重要的是用户体验

使用全局变量可以很方便,但需要权衡利弊

数据相关逻辑都放在data包中

handlers只包含处理请求的简单函数

业务逻辑放在package包中

types包用于共享的类型和常量

util用于一些通用的小帮助函数

cmd包用于编译二进制文件

Makefile用于自动化调试和部署流程

整个项目结构足够灵活扩展

不要局限于某一类开发者,学会全栈

简单开始,需要时再引入更复杂的架构

满足需求才是成功与否的标准

Transcripts

so we're recently starting to rewrite

leue into the 2.0 version for the people

I don't know what laue is it's a company

I created three years ago and the

original project was basically written

in next GS everything in typescript

which worked very well but right now we

received a big amount of funding and the

scope is changed dramatically so it's

time to scale up and we decided to write

the back end in goaling and use spelt

kit as the front end right so uh and in

this video I'm going to show you how we

set up our gooling project structure

because it's still a question that comes

up a lot like Hey how do you structure

gooling projects and before we continue

if you like the videos that I'm

providing to you please consider

subscribing give me a thumbs up leave

some questions in the comments and jump

into the 4,000 people big Discord server

where we learn from each other each and

every single day and for the people that

want to level up I also have the

full-time GF course which is 50% off

right now for a limited amount of time

and I also have my patreon page so check

these things out if you want to learn

more about goang so before we actually

continue with the folder structure here

you can already see it on the left side

of my screen there is no such thing as

the perfect project structure or the

good project structure or something that

is good something that is wrong I think

that doesn't exist in programming uh

space I think a lot of people are

forcing paradigms to you because they

created that Paradigm and they want to

Market it so we cannot blame them right

if you make something you're probably

going to Advocate that it's going to be

the best thing because it sols a lot of

problems and maybe it will right but

whatever you do in life there's always

some it's always going to give you

benefits but it always also going to

give you some uh negative Parts also

that's something you need to keep in

mind right um so if you have the if you

have the possibility to start from

scratch you actually never know what

what's going to be the best thing you

can have something in your mind like

okay if we do it like this and and and

these are the Futures we need this is

probably something we're going to

utilize in the future maybe we should do

it this way most of the time it's going

to change dramatically over time right

it's going it's never going to stick

like you like you originally planned it

right so that's something you need to

take in consideration and that's why I

think everybody needs to have a more

result driven development mindset which

is basically instead of being confused

about oh the tools and packages and ways

to organize stuff I think you just need

to go and Chase your good feeling what

feels right what feels sus what feels

good you know what I mean and change it

along the way I think and just focus on

the results instead of on um the way you

program stuff right all right cool uh so

basically how do we do these things well

it's very simple uh we have um goang

project here

and first of all we have this bin folder

here and this bin folder is basically

just uh a folder where we are dumping in

our binaries right uh and these binaries

they are coming from the CMD folder

right you can see there is no main. go

in the rout right that's because we

using this pattern it's it's a very

common thing where you have these um

separate packages right and each of

these packages they have a main. go file

here you can see that right and in this

main.go we basically bootstrap um or API

which is an

echo project right uh it's using the

echo framework so what framework do you

need to use actually guys it does not

really matter right you can use gen

fiber Echo gorilla you can use the

standard Library it doesn't really

matter right people say yeah you don't

need to use that or you need to use this

it doesn't matter it really doesn't

matter they all do the same things and

they will all get you the same result

right that's that's that's the reality

right uh and you could say performance

performance doesn't matter right again

people are going to be very very

confused and angry about the comment I

say like performance doesn't matter like

if per maybe performance will matter at

a certain point of time and if

performance is a

bottleneck then I'm going to say

congratulations to you because you

actually makes made something that has

some traction that that's a big traction

because before you go to be in a

performance bottleneck you're going to

have a very very very very large user

base and that's a luxury problem and

that's going to be solved at the time

it's going to be there right uh which in

your case most of the time will never be

right so performance is not something uh

especially in goling with echoin you

will you cannot go wrong it it it has a

good performance don't worry about that

guys don't worry about about about these

paradigms uh about that fugazi right so

we have this main thing which basically

boots up um our API server and all that

stuff right then we're going to have

some other things so what I like to do

um which is a little bit weird a lot of

people use some kind of um CLI package I

think I don't know maybe Viper or

something I have no clue I never use

these things and with the CLI package

you can write all these commands and

then you can execute them based on the

user input but what I like to do is very

lazy and very simple is just make um for

example this drop thingy here right

which basically drops all our accounts

and why do I have this because um in our

migration sometimes you can do make down

for example which will um migrate will

will

will use all the down migration you know

what I mean delete these tables but

sometimes you're going to end up in a

dirty State and then it it basically is

going to refuse to uh drop your tables

right make down is not going to work

it's going to say yo your database is in

a dirty state of course in production

that's a good thing that that happens

right uh but in development it's

sometimes it's nasty because you have in

a dirty State and you need to force do

that stuff uh you need to force drop and

sometimes you need to manually delete

some tables and it's just a pain and

yeah so I made this very dirty simple

script it basically just deletes the

whole shebang even the

migrations uh and then we can just do a

makeup again

um and it's all good right that's this

drop and the same thing with migrate you

can see that basic um with this other

thing here for for example the seat it

basically go it's a dirty script that

seeds some stuff into the database um

just for yeah testing purposes right if

you want to test your front end uh you

just dump some some some seats uh into

into your database um so you can see

this all very simple scripts and the way

we actually trigger them is in our make

file you can see uh for example make

down it just runs these main. go files

right this the same thing here with up

with uh drop and all that stuff it it

uses these these uh separate programs

right very simple um you could use

something like a CLI package like I said

what's good what's bad it doesn't really

matter this was just easy peasy without

a lot of squeezy you know what I mean uh

so that's that so the next step here uh

like you let let me show up this make

file right so I'm using a make file

people say you should drop that in in

favor for other

stuff like I said man if make file works

for me it works for me right maybe it

doesn't work for you maybe you want to

use something else that's perfectly fine

right um it all depends what you want to

use it doesn't really matter right uh

it's

fine all right because you have these

goal tools I don't know go make or

something you have these these cool

stuff U where you can write goang things

and but like I said a make file

everybody knows it it's simple it's most

of the time already installed on Linux

things so it's fine right uh so the next

step is a very important step is our DB

I'm going to uh start with this DB

because this is a little bit of

controversial right so the DB package

has just one file and what this does is

basically creates

um it it basically uh bootstraps or

database right and as you can see we are

using bun here but we and it's a global

variable so there's a lot of things we

need to discuss here right um so I

started out we started out with using

sqlc right sqlc is something that

generates um goang codes and structures

models based on U your schema your SQL

schema uh and you can write your SQL

queries and it basically generates code

for that which is actually very very

good right

but need to drink some coffee for this

one but the problem with sqlc is it's

it's getting very tedious something we

had a ton of queries already and I

thought man this is just so nasty all

these queries and then we have a schema

for our migrations we have a schema for

sqlc and you need to sync these things

and then some people are working uh like

me and Teddy we working on that it's a

two people project right now and we are

doing work for for 16 uh but the thing

is that it's just it gives conflict it

was was

nasty for current operations I'll really

like it but we need to have some

more dynamically stuff going on some

more genetic stuff and I used BN for a

long time um in in other projects and I

really like it right of course something

that's the downside like I said for

every positive thing also comes

something that's some negative stuff and

the cons for bun is that your queries

are not going to be type safe right if

you make a mistake

that's bad for you nobody's going to

it's going to it's going to give you an

error or something or or user that not

being found uh but hey it is what it is

right like I said pros and cons what do

you want it's it's a a weight scale that

needs to be in Balan for you right not

for somebody else on the internet it

needs to be in balanced for you and for

your team and is everybody thinks that

the scale is in balanc and it's fine

right everybody know the consequences

here um but also everybody can use the

positive side Ides on that right so

that's what we do and it's a global

variable why is it a global variable

just for the ye of use and of course

this is very this could be dangerous but

like I said a global at the right time

at the right place is is is okay it's

it's it's no big of a deal because we

are using this data

folder and this data folder is most of

the time is going to be used models for

a lot of people but I think models is so

weird because I think models they belong

on the catwalk you know what I mean um

it's I think everything that involves

storing data retrieving data structures

which is just

data I think it it can be in a data

folder it makes a lot of sense right so

everything uh that's

involving data

structures queries for inserting or

retrieving or updating whatever all

database related logic is housing into

this data folder right just like models

most of the time

and what this does is basically it uses

it uses queries um it the only thing it

does is basically interacting with your

database right that's what it's doing

you got have a query you're going to do

some joints or some some separate

queries you're going to aggregate that

data and return it that's basically what

this data folder is this data package is

going to do right and nothing else and

nothing nothing less and nothing

more for tests it's very important

because the global variables uh can be a

problem in your tests but I don't like

to test the data or your database into

the unit form right I don't want to use

unit tests for data I think interacting

with your database should be on the

integration Port again this is something

that can be discussed it has its pros

and it has its cons it really doesn't

matter right um I think if you test your

business logic based on on unit tests

that's pretty good and if you use your

data everything that needs to be

interacting with your database if you do

that on an integration

level it doesn't really matter that your

database is

global the only thing you need to do is

instantiate the correct database right

if you have if you want to do some test

you use a test database um and if you

yeah whatever right and if you deploy

the production you're basically going to

init initialize your database with the

production credentials right so that's

the data thing right the next step we

have is very simple is our handlers and

our handlers are just plain functions

right there are no uh you can see for

example here uh some middleware where we

validate gbt we have um some error stuff

for centralized error

handling some lock middleware it's very

simple uses the S from gooling the new

stuff pretty amazing let me show you

something here can I show some something

diff uh something interesting uh for

example handle get User it's just very

simple handle get user we always prefix

this with handle and then we use get and

that's not for example not for getting

the user it's the get request right

handle get user handle post user handle

update user right um just a convenience

method is that the way to go I have no

clue it works for me

uh you're you're like I said you're the

ball pros of your painting you can do

whatever you want right of course if you

join a team um that already has these

kind of things set out laid out yeah you

need to follow them right but if you can

choose from the start you can do

whatever you want right as long as it

makes sense for you um so what do we do

with these hand handlers well uh like I

said before we have the CMD API Maino

file and then we have these very simple

um uh yeah like like these these these

route handlers right this these routing

stuff so for example uh what we're going

to do here because in leue we have the

concept of sside accounts and buy side

accounts because there's a double-sided

marketplace where you're going to sell

or you're going you're going going to

auction your uh recurring Revenue in

return for upfront cash from

institutional investors right so we have

sell site and buy side and of course the

sell side they cannot they can only do

specific certain actions and the same

for the buy side so what we do here is

we make this a group thingy which

basically is most of the time in every

single web framework you're going to

have something like that where you're

going to group your handlers with some

um how do you call it with some

middleware right and uh it basically

some some authentication authorization

middleware right he's going to see oh

yeah this user is this a cide user yes

then he can do these things if it's a

buy side user then you cannot do these

things right then uh you are basically

not authorized to access these things

right so that's what we do here handlers

and then we're going to say handle

cellsite demo metrics in this case we

don't follow this stuff it's probably my

bad handlers handle post funding request

handlers handle get funding request you

know what I mean very simple um no big

of a deal here right so that's basically

our handlers here then we have package

um which is

something where more of the business

logic houses because most of the time

you're going to have something like a

transport right you're going to have

your Json transport your Json HTTP

Handler so what it's going to do is it's

going to get some Json data it's going

to uh Marshall that or decode that into

a structure right and then you're going

to have that structure and then you're

going to decide do we need to do some

business business logic onto that data

or can we basically just use our data uh

package and just store that user into a

database right or store a funding

request into a database some some simple

crit doesn't really need to have some um

business logic because it's very simple

it's just receiving data decoding data

validating data and storing data that

doesn't actually is some kind of a

business logic in my opinion but if

there is some business Logic for example

you need to fetch some transaction from

the the bank you need to aggregate them

do some calculations and all that stuff

uh maybe some third party things are

going on some third party API calls or

need to be um executed then we put

everything inside of a

package folder here and in this case

it's going to be salt and then client y

yada y you can see the project is very

very early in the stage we already have

some project running but that's the next

GS this is still in development right so

that's going into package uh that's

basically a goaling em to to put it in

in package you could use it lip you can

you can call it whatever you want but I

think package is something that is very

common inside of the goang community

right then we have some types here uh

and types is very important

because you could put these types into

Data but these types are basically

shared you can use you can make you can

you can call this common is is is I can

I see that a lot of times in other

projects in other repositories on getup

people call it common people call it

shared in this case just types because U

the only thing we have is some kind of

enums quote quote I need to be very

careful for the YouTube police right

because they are actually no enims but

they act like enims right um constants I

would say all the constants are here all

the types are here that are shared

between uh packages right that's in

types um and you could basically split

that out right you could make it a a

file for each type but then you're going

to have a file with three lines of

sometimes that's who cares right you

just dump everything into the types at

go and if your types are getting too big

then you can start splitting things out

and group Things based on on domain or

something right but that's for later on

that's a problem we don't have yet right

and then of course the UIL right util

utils shared whatever you're going to

call this is a very simple stuff where

we going to have uh like nothing inside

right is Pro app M and all that stuff

some simple helper functions that are

going to help you with uh simple simple

things in your application right crypto

is

this not quite sure what this is

probably T did some stuff right anyway I

think it's for encrypting um some kind

of API tokens we don't want to uh every

API token from from a third party

library for our user we don't want to

expose that uh with plain text we want

to basically encrypt that stuff into the

database so if it's get hacked they are

the hacker right not the client

uh that's basically it of course get

ignore go mod some make read me that's

all that stuff that's basically it guys

and with this project structure you can

scale it as as far as you want right you

because every data structure you're

going to have or every data logic you're

going to have is going to be in the data

every new Handler is going to be in the

handlers every new business logic you

can put that into package and every new

type you put it into type and you can

scale it as big as you want is this

going to change over time most likely it

will right it's like I said it's

something that works for me for a very

long time this this structure it's very

simple um don't make it too complex with

all that clean architecture and

hexagonal architecture and they will all

have his benefits don't get me wrong

like these are basically invented by

very smart people but I always say start

very simple right start simple make some

uh diesel driven stuff and I'm going to

show you how it looks right so you can

see this is basically the sells side

dashboard right um which again another

question is like people say how do you

make this beautiful wise well guys it's

very simple uh don't be a single-sided

developer very important people want to

be a backend developer people want to be

a front-end developer I don't think

there is something such as a backend and

a front end developer in my opinion you

are a programmer or you're not you are

an engineer or you're not you can solve

problems or you're not because by the

end of the day the only thing you do is

write code right you're pressing buttons

If it's JavaScript typescript goang

python rust it doesn't really matter you

can write it in every every single

language there are some benefits and

there are some cons there are some pros

there are some Cons with everything in

life and the only thing that matters is

if your weight scale of pros and cons is

inbalance or may basically if your Pros

are a little bit

um uh if if your Pros weigh a little bit

more actually weit a little bit less

right if the balance is a little bit

more in the favor of the pros instead of

the Conant it's a win for you right but

that does not mean that my balance is

the same my weight balance is going to

be balanced the same as yours or my

neighbors or whatever right or other

produ um engineering teams it's all

subject to the people are using it right

that's something you need to uh take in

consideration um that's basically the

thing of course we are we are doing some

stuff it's it's it's still in progress

here we we we have some look at this

it's it's we have some stuff but we're

still uh working on that right that's

basically it and it's calling basically

spell kit in the back end and all that

stuff maybe I'm going to make it another

video because we're already 20 minutes

in and I'm not even done it's crazy guys

I really want to provide 10minute videos

but I can because the things I need to

say uh take some time right you know

what I mean it takes some time so that's

basically on B it if you have more

questions feel free to dump it in the

comments like I said uh is not for

everyone right people going to going to

dislike it people going to like it it is

what it is it's the balance again right

it's again the weight balance as long as

the people like it or in favor of the

people that dislike it it's all good for

me Isn't it so thank everyone for

watching this video and I'm looking

forward to see you in the next video or

live stream peace stay safe and have fun