My Initial Impresson Of Go

Sdílet
Vložit
  • čas přidán 19. 05. 2024
  • LIVE ON TWITCH: / theprimeagen
    Become a backend engineer. Its my favorite site
    boot.dev/?promo=PRIMEYT
    This is also the best way to support me is to support yourself becoming a better backend engineer.
    Get in on Discord: / discord
    Get in on Twitter: / theprimeagen
    Got Something For Me to Read or Watch??:
    / theprimeagenreact
  • Věda a technologie

Komentáře • 157

  • @tielessin
    @tielessin Před 24 dny +140

    When he started to talk in terminal commands I was really scared

    • @microburn
      @microburn Před 24 dny +23

      Skill Issue

    • @Rana-yk6xn
      @Rana-yk6xn Před 23 dny +8

      @@microburn nil issue

    • @opposite342
      @opposite342 Před 23 dny +3

      You don't need to do what he did. TeeJ shows the line count for his neovim config with the tokei package, which is one command and it gives out nicer output.

    • @Spelaren7254
      @Spelaren7254 Před 23 dny +1

      @@opposite342it’s not that hard to understand tho. Also that will work for everything, your config needs to be setup etc

    • @opposite342
      @opposite342 Před 23 dny

      ​@@Spelaren7254fair point

  • @TheMASTERshadows
    @TheMASTERshadows Před 23 dny +54

    I feel like every primeagen video is just a showcase/flex of cmd line wizardry for us mere mortals ...

    • @MartinMarcher
      @MartinMarcher Před 12 dny +1

      Really?
      I think that's just normal average usage? How else do you do that stuff?

    • @alexandrecosta2567
      @alexandrecosta2567 Před 8 dny +3

      @@MartinMarcher I count the lines of each file...

  • @_billitech
    @_billitech Před 24 dny +66

    My mentality about writing code changed the day I discovered the power of golang interface

    • @Kane0123
      @Kane0123 Před 24 dny +6

      Go mentioned

    • @rez188
      @rez188 Před 24 dny +10

      Traits are way better

    • @carlosmspk
      @carlosmspk Před 23 dny +1

      @@rez188 in what way?

    • @natescode
      @natescode Před 22 dny +3

      ​@@carlosmspkin every way. They allow polymorphism but with proper type safety and no overhead of runtime dispatch

    • @carlosmspk
      @carlosmspk Před 22 dny +8

      @@natescode but go lang's interfaces are also type safe. The check is performed before you run the code if I'm not mistaken

  • @bitmasked
    @bitmasked Před 17 dny +9

    In Go we call it "duck typing". It it looks like a duck and quacks like a duck, it's a duck.

  • @0marble8
    @0marble8 Před 23 dny +3

    I think with errors, there are three types: user errors (user enters an incorrect input), programmer errors (your algorithm is wrong) and enviroment errors (lost internet connection). I think only the user and possibly the enviroment errors have to be handled nicely, programmer errors should result in a crash

  • @hamm8934
    @hamm8934 Před 24 dny +43

    I agree, implicit interfaces in go really encapsulate some of the the sludge feeling in java and c#. This is such a goated feature in go. It makes scaling an app so much easier. Avoids so much frustrating refactoring when requirements change

    • @gusryan
      @gusryan Před 24 dny +10

      I still wish you could do something like 'implements' just to make sure you're implementing all the methods you need

    • @bionic_batman
      @bionic_batman Před 24 dny +8

      @@gusryan actually you can quite easily do that
      Just assign instance of your struct to _ variable of that particular interface type. The program won't compile if you don't implement the interface

    • @hamm8934
      @hamm8934 Před 24 dny +6

      @@gusryan if a function takes an interface and youre missing a method defined on the interface, it wont compile

    • @gusryan
      @gusryan Před 24 dny

      @@hamm8934 It's way nicer to see it when you're actually writing the struct

    • @hamm8934
      @hamm8934 Před 24 dny +3

      @@gusryan i used to think this until i really used go and completely inverted my stance. Its just as safe, faster, and more flexible than explicit interface implementations. Have you tried using it?

  • @GoWithAndy-cp8tz
    @GoWithAndy-cp8tz Před 22 dny +5

    Hi! I really enjoy Go programming and all your videos, not just the ones about Go. I appreciate your talks. Cheers!

  • @krunkle5136
    @krunkle5136 Před 24 dny +26

    Those Bell Labs people were something else.

    • @gcxs
      @gcxs Před 24 dny +8

      They are true engineers

    • @diskpoppy
      @diskpoppy Před 23 dny

      Yet it's a deadend

  • @hobyt3
    @hobyt3 Před 24 dny +8

    The title makes a good impresson

  • @pookiepats
    @pookiepats Před 24 dny +3

    These are great points that all make me grateful I chose Swift.
    Protocols, optionals and final class solve so many problems for me

  • @marcs8325
    @marcs8325 Před 23 dny +7

    Go is the Toyota Corolla of programming languages. It gets the job done, but leaves me wanting for more.
    Still, it gets the job done. It's easy and fast. I like that aspect of it.

  • @theevilcottonball
    @theevilcottonball Před 19 dny +1

    Its the same for me with C. Such a simple language, yet you can do a lot with it.

  • @felgenh399
    @felgenh399 Před 24 dny +1

    Were you overdoing Arc as well?

  • @MrAlanCristhian
    @MrAlanCristhian Před 24 dny +1

    I agree, structural typing is amazing.

  • @guyvandenberg9297
    @guyvandenberg9297 Před 24 dny +5

    Really glad you are enjoying GO. I have been using it since 1.0 release. It is a great language, especially implied interfaces (kind of duck typing). Enjoy your channel. Thanks for the great content.

  • @seannewell397
    @seannewell397 Před 23 dny

    Very interesting you felt that way about Go's structural type system. TypeScript would like a word.

  • @deado7282
    @deado7282 Před 24 dny +6

    U really start to appreciate a structural static type system if u want to test all of that stuff.
    It makes it much more enjoyable to test if u just hand in snippets instead of producing the mock-mess in a nominal static type system.

  • @its_finn96
    @its_finn96 Před 24 dny +5

    Love Go, love Prime, love the uploads 🤌🏻🤌🏻

  • @OceanSlim
    @OceanSlim Před 24 dny +1

    You're going to give go a real... go!

  • @esra_erimez
    @esra_erimez Před 23 dny +32

    After programming in C++ professionally, I think Go is a Godsend.

    • @i-am-linja
      @i-am-linja Před 22 dny +3

      A GOdsend?

    • @esra_erimez
      @esra_erimez Před 21 dnem

      @@i-am-linja Precisely

    • @isodoubIet
      @isodoubIet Před 18 dny

      It's really funny how people might say "structural typing is so good omg less than three" but then dunk on c++ in the same breath.

    • @Heater-v1.0.0
      @Heater-v1.0.0 Před 16 dny +2

      After programming in C++ professionally I find almost anything a Godsend. Assembler is good. Rust is better. I'm sure Go is great where it is usable.

    • @esra_erimez
      @esra_erimez Před 16 dny

      @@Heater-v1.0.0 Oh my God, I can relate to assembler, at least with assembler you *know* that you have really cross your T's and dot your I's. I get a lot of hate for disliking C++. I think C++ was a squandered opportunity.

  • @ccs4321
    @ccs4321 Před 24 dny +18

    go is so good for code reading for learning all thing other than coding.
    you can learn encrpytion, TCP , pacakge matching , media, h264 , FFT ...etc. , all those thing are way easier to read than all other language( yes, for code reading, It easier than python and JS)
    And because it so easy to read and have decent performance, you can see it can make a team project very easy.
    for me, go is always a good lenguage, not beacuse it easy to write, it because it easy to read.

  • @k98killer
    @k98killer Před 21 dnem

    Python also has Protocols for structural/duck typing. The main difference is that you have to wrap each Protocol in runtime_checkable to be able to enforce it at run time, which kind of sucks.

  • @ProjectTurtleTech
    @ProjectTurtleTech Před 23 dny +2

    I'm going to give go a go... Just say I'm going to give go a go.

  • @phaZZi6461
    @phaZZi6461 Před 24 dny +1

    question: what are your editor text colors and whats the background color? i feel the contrast is just right without everything looking like a rainbow. please let me try them :P

    • @ristomatti
      @ristomatti Před 20 dny +1

      I believe it's Rose Pine with the background color removed. For the background color of the terminal, I suggest you take out the color picker and grab it from the video. It looks pretty similar to what I've ended up using for years (#141414).

  • @The-Funk35
    @The-Funk35 Před 23 dny

    This might be my ignorance speaking but how is the structural typing in Go different from C++/Java interfaces? It's basically the same thing, right? Except maybe you don't have to explicitly declare what implements XYZ?

  • @ikiris9456
    @ikiris9456 Před 23 dny

    You should rarely ever panic/crash, especially if you're a library or a goroutine, because if you're running a service that will kill the whole service. You really want to get into the habit of just returning proper errors.

  • @TheRealMangoDev
    @TheRealMangoDev Před 24 dny +40

    only the real ones remember the old title

    • @TheRealMangoDev
      @TheRealMangoDev Před 24 dny +16

      impresson

    • @diego.almeida
      @diego.almeida Před 24 dny +8

      @@TheRealMangoDev it's not a misspelling, he just says that word with a spanish accent

    • @ProjectTurtleTech
      @ProjectTurtleTech Před 23 dny +2

      I'm 10x this level dyslexic so I won't notice the defense

    • @i-am-linja
      @i-am-linja Před 23 dny +2

      It still says "impresson". Was there a correctly-spelled title before?

    • @TheRealMangoDev
      @TheRealMangoDev Před 23 dny +3

      no i just thought itd change

  • @hatter1290
    @hatter1290 Před 22 dny

    Structural sub-typing is pretty freaking useful for scaling teams.

  • @andrewmanninen1244
    @andrewmanninen1244 Před 23 dny +1

    I really want to like GoLang. I really do.
    My issue with it was I was trying to create an API that did some light computing on the data that it received and I kept running out of core memory for the application. No matter how I increased the memory for the stack, it would not behave after running the computation.
    Writing a similar API endpoint in nodejs with express was:
    1. Computed faster,
    2. Could be rerun without issues,
    3. Used less memory.
    I understand that I could've been doing something completely wrong with the ingested data (I was creating new objects for all 10k items in a JSON array) and I was doing this blind.

  • @Yupppi
    @Yupppi Před 21 dnem

    I find it funny but I'm happy that last year prime poke fun at go and had sort of attitude "why would you do go when there's better options in everything" and now I've seen him do go every time I've opened the stream.
    I suppose it goes to show that every language has a reason it exists to begin with and sometimes you only realise it by diving deep enough. Or do a project different from your usual projects. Obviously some languages are just part of histort now or never really succeeded in why they were trying to do so there's also just better options for the same thing.

  • @bcpeinhardt
    @bcpeinhardt Před 24 dny +3

    In BEAM world defining your “error kernel” (the subset of you application where you simply have to be correct or crash) is a big part of application design 😌

  • @ultraderek
    @ultraderek Před 23 dny

    The Stringer interfaces is BA.

  • @LukeeeeBennettPlus
    @LukeeeeBennettPlus Před 23 dny +1

    Came for the go, stayed for the fluent xargs

  • @GoddamnAxl
    @GoddamnAxl Před 24 dny

    Structural typing good but it is also why we can’t have generic receiver method 😢

  • @soggy_dev
    @soggy_dev Před 21 dnem

    I've never thought go interfaces as being structural typing 🤔 I can see it but i associate that term so tightly with TypeScript it makes me feel weird lol

  • @bipinmaharjan4090
    @bipinmaharjan4090 Před 22 hodinami

    Bro how many channels you have?

  • @dazoedave
    @dazoedave Před 24 dny +2

    I thought it was called duck typing? Looks like a duck quacks like a duck... it must be a dog acting like a duck

  • @christiansmith2658
    @christiansmith2658 Před 9 dny +1

    Your philosophy on crashing is valid but I don't think it's as universal as you might think. I used to work in aerospace and we had recovery plans within recovery plans within recovery plans. The final destination of which was an "totalizing system recovery", if you will. Your mentality has to change about these things when human lives are on the line...

  • @abelkasu8238
    @abelkasu8238 Před 10 dny

    "Loosey Goosey" lmfao

  • @srijanraghavula
    @srijanraghavula Před 24 dny

    My uni taught us C. Then i started learning go, it feels so good

    • @srijanraghavula
      @srijanraghavula Před 24 dny

      Dang, I should come back to this video after a good understanding of go

  • @ivandubkov7138
    @ivandubkov7138 Před 22 dny

    Why does Prime save files (:w) unchanged at 05:12, 05:14, 05:25?

    • @dustvoice
      @dustvoice Před 22 dny +1

      The answer is: there probably is no reason.
      I do the same when my ADHD brain thinks about something and I use my keyboard or editor as some kind of fiddle toy. I also often unnecessarily save while editing and coding during mental pauses.
      It would be perfectly reasonable to save once you completed some kind of function implementation etc., but I just perma :w.
      I mean, when you watch the way he codes, it's all just immediate conversion of thoughts into texts so that he probably also saves in this reactionary way.

  • @micahburnside2281
    @micahburnside2281 Před dnem

    This is so syntax heavy i won’t Go near it

  • @uuu12343
    @uuu12343 Před 23 dny +1

    After learning Rust, I really miss using C and am really happy with python and go

    • @kiwiladi
      @kiwiladi Před 23 dny

      That's what rust does to ya. Your program is better but experience of making the program is a lot worse. Sometimes you just want to chill when you code.

  • @AdamPoniatowski
    @AdamPoniatowski Před 24 dny

    crashing works great in a container/orchestrator environment. but when it hits baremetal/VMs, then the IT/ops overhead starts to take its toll. then you need monitoring set in place, logging setup (or deployed, depending on how much your employer is willing to spend on it), etc. Crashing would then suck in prod, but it would make the noc team take their job more seriously... or rather they will no longer be bored at seeing a green board majority of the time XD

    • @Leeway4434
      @Leeway4434 Před 23 dny

      or you just have a daemon restart it?

    • @AdamPoniatowski
      @AdamPoniatowski Před 23 dny +1

      @@Leeway4434 linux with systemd, sure... but what about the rest, like the sysv enjoyers, freebased lovers and the point-and-click adventurers aka windows admins? hence, my remark about the IT/ops overhead (meaning scripting involved to recover it automatically) ;)

  • @crimsonmegumin
    @crimsonmegumin Před 23 dny

    Impresoooon Jsoooon

  • @natethor
    @natethor Před 23 dny

    Go Go Go!!

  • @Gornius
    @Gornius Před 24 dny

    Go is such a great language, you really need to be nitpicky and have a lot of experience with it to actually point out its weak points. Every other language I tried I needed 2 hours with it to find something that annoys me or makes me anxious.

  • @thekwoka4707
    @thekwoka4707 Před 23 dny

    I was hoping he was gonna say "and now iv been using go for 5 7 months, and I know it's shit"

  • @cariyaputta
    @cariyaputta Před 23 dny +1

    Go is great.

  • @user-hn1ph6ry8l
    @user-hn1ph6ry8l Před 13 dny

    I try Go as my new language for pet project and its fun and horrible, just because I write GO in JS-style. And I think major criticize post about Go actually about Java-Go code. All you need - write Go Go code, its perfect.

  • @dante600
    @dante600 Před 24 dny

    Impressón

  • @pleggli
    @pleggli Před 24 dny +1

    I have been programming Go since before 1.0 and I never seen any issues with the structural typing interfaces.
    There are a bunch of things things in Go that potentially could be problematic (like null references) but in practise I very rarely see any null access panics reach production environments. I can probably count the number of times that has happened on one hand in the programs I have worked on.

  • @igorcastilhos
    @igorcastilhos Před 24 dny

    Does he have published the code on GH?

    • @airkami
      @airkami Před 21 dnem

      He has tons of code on there. So, maybe

  • @beest_
    @beest_ Před 24 dny

    I'm a mostly Data driven programmer, but also very involved in text based languages.
    It's a very lonely place , because how prevalent text languages are and biased of text based developers.
    I honestly think you'd enjoy data driven languages too. It is utterly different paradigm and imo handles many development architects better. My opinion.😊

  • @maleldil1
    @maleldil1 Před 12 dny

    What he described as a reason structural subtyping is good doesn't make sense to me. He literally copied the definition of the interface so he wouldn't get it wrong; would it hurt so much to declare explicitly that you're trying to implement the interface/trait/whatever so the compiler helps you?

  • @turolretar
    @turolretar Před 24 dny

    let’s gooo

  • @jogurtnaturalny
    @jogurtnaturalny Před 24 dny

    MRyogurt on the video

  • @sohn7767
    @sohn7767 Před 24 dny

    Empressión

  • @conundrum2u
    @conundrum2u Před 24 dny +2

    the tendency to do duck typing leads to an object doing all of the things. it leads to functions that are hundreds of lines that have a ton of side effects. the only advantage is that composition leads to excellent flexibility when refactoring. go's creators emphasizing that interfaces should be small is excellent architecture, but you can do that in most if not all strongly typed languages. strongly typed interfaces lead to your realizing that incorporating too many interfaces means the object is doing too much. of course if you're more senior you're going to have a lot of this worked out and you won't make as many of the above pitfalls, but when the possibility exists to "oh just one more thing" it will happen

  • @FabulousFadz
    @FabulousFadz Před 20 dny

    10:45 In face the guidance is that you should panic when the entire program is in an invalid state. Go panics if you try to access element 21 of a 5 element slice. That is an invalid operation and the assumption is that your logic is wrong. Likewise, as you say... when you unreachables have been reached then something is very wrong and very likely the best thing is to just dump the current state to a log and bail out. Essentially what Windows does with a BSOD. No time to figure out if this is somehow legit. This should not happen so pull the plug.

  • @yonas6832
    @yonas6832 Před 23 dny

    and now Zig

  • @numeritos1799
    @numeritos1799 Před 23 dny +1

    This unironically happened to me with Java. Yes, it's very boilerplatey but using the right libraries the experience is great, OOP definitely has its upsides.

  • @demmidemmi
    @demmidemmi Před 24 dny +1

    Having done a couple of years in go I have to say, there being no way to declare that a struct should implement an interface is up there with no enums as the most annoying traits of Go. Fixing it wouldn't even have to be a breaking change just give us a way to pin a struct to an interface for goodness sake. Even if it was just some absolute hack like using comments inside the string that would be better than nothing.

    • @diego.almeida
      @diego.almeida Před 24 dny

      totally agree. Not having enums and union type is a bummer. the duck type for structs and interface is quite confusing too, and can get quite messed up if you split the implementation in multiple files. Rust is perfect in the way it addresses both things

  • @TON-vz3pe
    @TON-vz3pe Před 23 dny

    Keep selling

  • @foxwhite25
    @foxwhite25 Před 23 dny

    structual typing is super hard to debug and refactor in a large codebase, it is such a pain to track down all the implement when it's effectively anonymous

  • @dmitriyobidin6049
    @dmitriyobidin6049 Před 24 dny

    Is it cause of go? Or cause you left Netflix and just do what you like? )

  • @user-uf4rx5ih3v
    @user-uf4rx5ih3v Před 24 dny +7

    The problem with Go for me is that it's very repetitive and its interface features are not really that great. You also don't get pattern matching or tagged unions and the error handling paradigm is kinda bad. There are just a lot of small things about it that don't really do it for me. Google's involvement in the project is not reassuring.
    While no language is perfect, I think it might be interesting if we had a language that's basically Rust, but garbage collected and maybe with a more extensive type system. You could argue that's Haskell or Ocamle but those languages just don't value reproducibility and backwards compatibility enough. If they had more of a backing from industry they would be a lot more enticing.

    • @diego.almeida
      @diego.almeida Před 24 dny

      have you taken a look at Vlang? it's exactly what you're looking for, but still in alpha release.

    • @diego.almeida
      @diego.almeida Před 24 dny

      Vlang is maybe what you're looking for

    • @ThePandaGuitar
      @ThePandaGuitar Před 22 dny

      You don't need those features.

  • @zeocamo
    @zeocamo Před 24 dny +1

    11:28 i got a example about why you don't kill your app, or the "Java way of coding", why can't any one really use kdenlive, because if just the smallest of error happen, they kill the app, and the user lose all the work, and in the process of making a 1 hour video, you use 12 hours because it kill it self all the time.
    you can just print that and that feature have problems in a window and let the user try again,(and save) and in many cases stuff can work any way, so try to give the user the UX. and just killing the app is not that.

  • @nikgordon1288
    @nikgordon1288 Před dnem

    Ur a cutie

  • @AbstruseJoker
    @AbstruseJoker Před 21 dnem

    Tired this go love when the example programs are trivial

  • @deltapi8859
    @deltapi8859 Před 24 dny +2

    7K lines of a complex project like this? The guy is improving. Started as a JS kid and he's becoming a serious coder.

    • @frknue
      @frknue Před 23 dny

      He should work at faang, netflix or something.

    • @deltapi8859
      @deltapi8859 Před 23 dny +1

      @@frknue Netflix doesn't say anything on how good a developer is. Especially at international scale.

  • @OczEkPower
    @OczEkPower Před 24 dny

    please let me know what golang doing bettern then c# or rust, there is no reason to use this pice of shiet. I work as a golang developer over 5 years and trust me i relly do not wont to change golang to different lang, and i want to be good one but this is just poor language without any pros over this two before.

    • @obkf-too
      @obkf-too Před 24 dny +2

      Here is my opinion, c# is Microsoft's shit and I will take google's shit over MS's shit any day, plus I don't want to see classes everywhere.
      As for rust, it is a different perspective to programming and I don't need the hustle that comes with it, Odin or Zig are way better IMO, plus go isn't trying to replace rust (it has a GC). Also rust is becoming the JS/TS of the system programming languages, with huge dependencies and long compilation times everywhere.

  • @nandans2506
    @nandans2506 Před 22 dny

    Duck typing is one of those things i don't like about go honestly

  • @micahburnside2281
    @micahburnside2281 Před dnem

    Way too many abbreviations and shortened words. Too hard to read.

  • @windows99
    @windows99 Před 18 dny

    Stop using languages associated with Big Tech, i.e. Go, Java, C#

    • @motozirillo
      @motozirillo Před 12 dny

      So, clojure. Got it thanks

    • @CarlosRLotus
      @CarlosRLotus Před 20 hodinami

      @@motozirilloisn’t Clojure now owned by Nubank? A Brazilian fintech?

  • @otockian
    @otockian Před 22 dny +1

    Personally I think Go is the ugliest language.

  • @serhiiko7141
    @serhiiko7141 Před 24 dny +1

    415 in 14 min.
    TheVimeagen fell off

  • @BrazenNL
    @BrazenNL Před 24 dny +1

    x, err := so.annoying()

  • @KhaledKimboo4
    @KhaledKimboo4 Před 24 dny +1

    type Wether struct{
    Temp int32
    }
    Var t *Weather
    t==nil // True
    New temperature of 0 degrees
    t.Temp = 0
    t==nil // True (what??!!!??)

    • @diego.almeida
      @diego.almeida Před 24 dny

      "In Go, the zero value is the default value assigned to a variable of a given type when it is declared without an explicit initialization. The zero value depends on the type of the variable. For reference types, like pointers, slices, maps, channels, and interfaces, the zero value is nil" - That is why it's called nil and not null, because it's essentially the zero value.

    • @massy-3961
      @massy-3961 Před 24 dny

      This isn’t how this works, you can’t compare a struct instance to nil in the first place it won’t compile, but even if you changed it to &Weather{}, t==nil would be false.

    • @KhaledKimboo4
      @KhaledKimboo4 Před 24 dny

      @@massy-3961 that's not the point just do
      var t *Weather , again you missed the point

    • @KhaledKimboo4
      @KhaledKimboo4 Před 24 dny

      @@diego.almeida not looking for an explanation I know all of that, bad language design leads you to this mess

    • @diego.almeida
      @diego.almeida Před 24 dny +5

      @@KhaledKimboo4 well you'e comparing nil to nil why are you so surprised?