Hearted Youtube comments on Kantan Coding (@kantancoding) channel.

  1. I see some people complaining about the code extraction. In the example, I would do a similar extraction, but for another reason. Avoiding code duplication is a nice side effect, but the core idea should be: Keep the abstraction level of a function or class or whatever constant. An example: You don't want a function dealing with structuring a report page doing regex stuff, this is clearly too low-level. Think about how you would explain your function with a few words to your colleage: "I look if there is a report header, else I use the default, then I add the body, and if there is a footer, I include it as well". And that's what the function should do. If it does some finicky stuff with the body, extract it. If it does some regex, definitely extract it, maybe even a level deeper, below the functions dealing with the header, body or footer. Having one abstraction level is much more important for readability than to avoid code duplication.
    36
  2. 3:02 "Instead of needing to write two functions". But you did exactly that, it's just that they are called the same and the appropriate implementation is picked automatically by the compiler based on the object it is applied to. If you need two different actions, you will have two different functions, there's absolutely no way around that. You can hide it in a bunch of layers of extra stuff, of course, but at the end of the day, it's two functions/procedures.
    36
  3. why do you say enum like it's the name of a goofy side character in Star Wars
    34
  4. braces is wild
    34
  5. You forgot one rule: COMMENT YOUR CODE... No seriously, it takes like 5 seconds to do and makes any and every piece of code much easier to read and understand. So please, for the love of god, comment your code.
    33
  6. I catched the suffix one! Not the trimSpace, I don't know Go :D
    32
  7. Very clear overview of how merge sort works , thank you so much
    32
  8. Hey man worth waiting keep posting such a quality content
    31
  9. These comments are full of junior developers telling you what’s senior or mid level code. Gotta love the internet.
    31
  10. One suggestion I would have is to increase your font size a bit in certain parts of the video, good work though
    31
  11. the point of extraction in this case is to define a new logic property for the entity user: whether it's valid or not. currently user is valid when they're authenticated and authorized, but who knows, maybe there will be some additional protection in future, like user will be required to have some special security ID, or restrictions like no banwords in username, not being deactivated or banned by administrator
    31
  12. Good code doesn't need comments tho
    30
  13.  @kantancoding  you only check if it's empty after trim, nothing prevents from saving " username " to the database
    30
  14. This was great! I had no idea you worked in Tokyo, this is my big goal. Could you do a video on what it's like working in Japan and how to get a job in japan?
    29
  15. I don't understand why nobody is explaining it like this at our uni. Our Prof. is really good at making concepts look harder than they actually are. Thank you for the video.
    28
  16. this tutorial/guide has more personality than the entire cast of friends
    27
  17. As a tech manager, I found this video extremely useful and insightful. It's important for software engineers to be proactive in their learning and development, and this video provided some great strategies and tips for self-study. I particularly appreciated the emphasis on setting clear learning goals and finding resources that align with those goals. Thank you for sharing your experience and insights!
    27
  18. I don't touch duplicated code until either: a) I start fiddling with the code and need to change both instances rather than just one of them b) My program is feature-complete and abstracting the duplicate code won't make it harder or, more importantly, slower to read c) It's a problem I have a lot of experience solving and know already that abstracting it is the best way to go about it Otherwise, I don't bother, because it would cause the following scenario: I'm shoving time into something other than the problem I'm actually dealing with just to solve something that might become a problem (time neutral if any of the above three would have become true). It also might be completely irrelevant (loses time). It might also be harmful to abstract it by causing me even more extra work down the line (loses time twice). Best-case scenario it's time neutral, any other scenario it's a loss of time, time I could have used to significantly improve my code where it actually mattered. Also, I'm sure if someone wanted to waste their time, they could stretch "every code duplication is bad" to such a degree that it would become comically ludicrous, humans are really good at shenanigans that.
    27
  19. I agree with the overall message you're trying to share. But I can't be the only one who shudders at the sight of those function names being entire novels. What the expected return value is can be communicated using comments or even just by reading the code itself. The way you've written the tests is understandable enough: "age = minAge - 1", "isUnderage" and "assert.True" is clear and easy to understand. You write readable code and you do it very well, which makes me not understand the need for such function names. That aside, I enjoyed the video
    26
  20. Bro is evolving, his edits are and effects are getting stronger 💪🏾💪🏾
    25
  21. Liked the elevator akwardness😂, keeping your mobile devices in contact with your smart cards may cause the card to have a defect in efficiency
    25
  22. Somehow youtube recommend me this and wasn't disapointed at all. Thanks for the awesome explanation!
    24
  23. That last example looks so bad lmao, just make an abstract class and inherit it for all types of document classes
    24
  24. I've catched the Trim issue because I made some stuff in the past that I needed to cut spaces from both sides, and thankfully the Go developers already thought about that
    24
  25. Best video I have found on the internet about Go concurrency. You really are great at not missing any important points while teaching. Salute.
    24
  26. i had the same mac, upgraded the storage to ssd and its was perfect and yes it had the perfect keyboard the BEST one, was so durable.. feel sad that i had to sell it for m1 air
    23
  27. I think that example "The Done Channel" is not correct. Instead of call close(done) it should be done <- true/false. If you add log in the case done <- you will see that the statement is not invoke. But with that call done <- true/false it is. func doWork(done <- chan bool) { for { select { case <-done: fmt.Println("work done") case default: fmt.Println("doing work") } } } func main() { done := make(chan bool) go doWork(done) time.Sleep(time.Sleep * 3) done <- true } Despite this, your channel is great and very educational. You can explain complex concepts very well and clear. Great Tutorials !!! Keep up with the great work.
    23
  28. so function createUser will create a user with a user that is already created?
    22
  29. Depends. On library always document functions. For applications don't because the cost is high to maintain such comments and they very often get out of date. Any modern IDEs can show the input/output automatically. And yes it's less detailed than comments but again for apps it's not worth and get out of date often.
    21
  30. I don't know dude, I think you ended up with same level of deep function calls or am I missing something
    21
  31. The last point is a non-issue if you use a proper IDE. For example, I mainly code in Java using IntelliJ and if I encounter a function requiring many parameters I can press Ctrl+P and I get a tooltip displaying which arguments to pass and where.
    21
  32. Please remove the annoying continuous background noise in the video if you can, I was having a hard time ignoring that.
    20
  33. so we start with 1- coarse Locks, and then to 2- finer locks, and then to 3- enough precise memory access patterns which doesn't require locking (since there is no sharing memory) Great Job Kantan, I really enjoy your videos in golang !!
    20
  34. I try to use comments to explain "why". If I feel like I should explain "how", it means the code is not readable/explicit enough. Besides, comments tend to "expire" during refactoring and updates, especially when working in teams.
    19
  35. Incredibly clear explanation, by far the best on YT. Thanks a lot for all the effort!
    19
  36. "self documenting code" is a fallacy. Comments are not bad, they are necessary. Are they redundant with the code? They can be, but that's a good thing. Why? Because they provide a layer of confirmation, whereas code all by itself may be correct or may be wrong. Without the comments, there's no way to compare what a function was intending to do (the comments), verses what it actually does (the code). The problem in this video's example isn't that there were comments, its that the later developer was lazy and didn't update the comments, which is a bad developer.
    18
  37. The long names for tests are actually pretty standard. It's not so much about the long name as it is about documentation. A well-tested code-base can contain thousands or even tens of thousands of tests and when the business logic becomes a bit more intricate than these examples you can have multiple failed tests for one seemingly simple change. Being able to read through the test names and understand what their testing without opening each one up to read comments or the code itself saves a lot of time and keeps you from getting distracted from your actual goal of fixing your regression. Another reason for verbose test names is that a test tends to be more granular than a method would normally be. You could potentially test 10 outcomes for one, let's say 10 line method. To use one of the tests in the video as an example: 'TestIsBlankStringShouldReturnTrueWhenBlank 'could be shortened to something like 'TestIsBlank'. This would work fine in the video because it's just used as an example, but you would normally test more than just the one outcome. You'd need to test that the method behaves correctly if a null value is passed in or that it does, in fact, return false if the string is not blank and not true as well. Never mind languages that don't have type safety like javascript where you'd have to check if the method handles integers correctly. What would you call the methods for these tests, considering that 'TestIsBlank' is already in use? With that said, most test frameworks have a some sort of description feature that would display the description instead of the test name in the test-runner. The descriptions act as a sort of comment. Sorry for the essay, but there are a lot of intricacies in writing maintainable tests and rather specific reasons for things that look arbitrary or unnecessary. Much like test names, the explanation as to why they are long is also, well, long.
    18
  38. Literally could not find any other videos for years on explaining these concepts at this simple of a level. Such a great job on this and excited to watch the rest of this series. Thank you for doing it!
    18
  39. Separation of Concerns is good but I feel like people sometimes take it too far. So you'll find a function which calls 3 other functions and each of those functions perform only 1 line operations. A rule of thumb I like is that I only extract functionality to another function if it's used in multiple places.
    18
  40. unit tests for functions that can be easily verified by inspection is in fact not a good thing. You don't need to write unit tests for things like "shouldReturnTrueWhenAgeBelowMinimum". Granted its just an example but people watching this will take that at face value and write tests for trivial functions that do not need unit tests. There is no clear guide for what is considered a unit. You risk creating units that are too granular. edit: also, factoring out code that is both small and never reused is stupid too. Don't pull something out into its own function if its a handful of lines and is never used anywhere else. You're just adding to the call stack for no good reason. Write readable and commented code instead of pulling something out into its own function. If it's a massive chunk of logic or is duplicated, yes factor it out.
    18
  41. I spent an hour in my class trying to understand this and you just did this this in 8 minutes it's really simple ,thanks a lot !
    18
  42. Not a fan of all that mutation with the builder. I’d just create the structure literal as an argument and pass that. No need for the user variable or any setter functions.
    18
  43. Liked and subscribed. Very good explanation (but the background music is little bit annoying and distracting)
    17
  44.  @kantancoding  yes, exactly. Also, I think what is being talked about here is polymorphism, inheritance being one way to implement it. I think the subject is complex and the video does a great job at demonstrating it.
    17
  45. As a self-taught, I watch a lot of tutorials on YouTube, so I can say that I know high-quality content when I see it. And this right here is a gem! Keep it up, man. I just came from the other O(log n) video and I LOVE your channel!
    17
  46. 2:06 While extraction is good in some cases, in this case that is a step too far. Code is easier to reason about if you keep basic operations inside the main function. You should only extract large chunks of code into their own inline functions. They should be inline to start with because you have no reason to take external code doing the same thing into account until it becomes common enough. Somewhere about 3-5 usages is the minimum amount for this, depends on the complexity of what is being done. In the case of one liner expressions extraction is in fact incredibly poor developer behaviour. If the code spans at most just a few lines (3-5) then an inline function is all you need for it. If it spans 5+ lines then it's a candidate for a shared function to avoid mistakes in logic due to complexity.
    17
  47. the overly nesting problem often comes (at least where i live) from the way coding is taught at university. i was taught that a function should have a single return, and early returns where a bad thing, so that resulted in a deeply nested code
    17
  48. Liked for the elevator awkwardness.
    17
  49. Hello, this series is the most useful that I've found on YouTube in relation to the Big O notation, you not only explain the concept itself, but show with detailed examples how to discover each order of growth. I really appreciated that. Thank you very much!
    17
  50. Excellent Kantan, I'm a retired elementary school teacher and you explained these algorithms so a third-grader would understand algorithms. Thanks for doing such a great job. Keep up the good work.😊
    16