- "How the heck did this code become this messy and long?" - "One if-statement at a time."

Great video, I learned something again. Just a technical remark, I found it quite distracting that you micis in the frame with your face, would look much better it it was hidden

Legacy Code.... brrrrr.... :D

agree, pull request are not a right way to review code. But sitting with a whole team infront of a big screen once a month for a few hours and then go deeply into the code. Not to review juniors code especialy. But giving tips can never be wrong. But more about explaining design decisions and start discussions

We do code reviews for everything. Haven't had a bad experience so far. Seems like a company culture problem. We usually work in very small teams, often enough just 2 people. So it's pretty standard that even a junior reviews the CTO. Haven't encountered any ego problems, yet. If your company has toxic people, maybe start working on that or look for a different job.

Lest not forget that we're dealing here with enlarged egos and programmer divas most of the time, rendering all these "techniques" and "suggestions" useless.

Thats good !!! I will think how to implement this in our team.

I like them just fine on teams when no one is bringing their ego to the table.

Code reviews…not awesome. But very short regular code walks with the entire team (yes, including non-coders) focused specifically on what a developer thinks are the one or two most salient *functional* elements being worked can really help. As they say, “Every line of code can turn out to be a business decision, and every business decision that doesn’t understand the code is risking being a bad one.” I’ve seen marketing people come up with non-trivial innovations and catch what would have been a time consuming blunder, just by walking the code with a developer and applying common sense and their knowledge of the larger context. (By the way, “strong style” is great.)

At this stage we do have really cool software but like 90% of it is sucks. And it sucks grandiosely. To the point where I am struggle typing simple comments on KZfaq due to stupidity of the virtual keyboard on my tablet. And years doesn't change it.

I had once this "code review" approach in a team I was working. It was the most miserable team I ever worked with. I see it so that your feature should just work, has and entry point and the scope of it's effects was easily determine and debugable. Well, I guess the closer you are to ECS and further from OOP - the easier your life. But what do I know

but how am i gonna nitpick trivial stuff? 😆

Great video, would've liked to have heard a mention about mutation testing (as you did in the older "Introducing the Gilded Rose Kata and writing test cases using Approval Tests") as it was a concept that I really think compliments approval testing as we want to make sure we don't change behavior only the strcuture.

Code reviews among "equal" peers is toxic and annoying. The solution to avoid the toxicity is owning your own company and do it your own way.

I am ashamed of say so, but I was so bullied by colleagues "offering help" by rejecting my changes so often, that I landed in a massive burnout, and am still not over the PTSD related to the code reviews, which went mostly about spaces vs. tabs and code formatting. I'd love to try pair programming, though I'm not sure it'll work for me taking into account that I'm on the autistic spectrum, and I get my best work done alone and in silence. Also I want to add that too much communication and collaboration is overrated, or at least not for everyone. Seeing for example the extensive threads on Swift forum, for example, I can't help but wonder when people have time to think, code and live in addition to writing all these messages. Seeing your great video I'd love to get your feedback on the above, to hear your perspective.

Code reviews are awesome. It just depends on leadership, and I guess some times leadership is awful. I'm lucky to have a great lead, and learning a lot with each CR.

Why aren’t people more concerned with design skills rather than coding skills. Good design will always help with coding. There should be such a thing as design reviews rather than coding reviews. If you get the design right then the coding is dramatically simplified and you’re less likely to make bad decisions. But in the advent of agile which most companies are abusing and getting it wrong, the idea of upfront design has become anathema.

Why should you have shared code ownership?

right, but also wrong. We rely deeply on PRs and code reviews, but if this is the answer for staffing or training you have asked the wrong question. There are additional techniques you can use, but all/most of them dont make code reviews unecessary

i'm working on a startup as a solo developer , it's my first experience and i wish if some senior could review my code , i think it's a matter if someone is open for critics and want to improve and don't take other opinions personally

Code Reviews are also extra sets of eyes on the code; and precious due to that. Developers are people and make mistakes. We catch small mistakes or omissions in code reviews all the time. Also, during code reviews someone may point out a corner case the original developer has not considered.

LGTM: Let's gamble, try merging 👍

Great topic. I was thinking recently about how the team i'm in lacks cohesion and technical leadership. Every dev writes code in his own way. I try to follow what the senior most dev does, but he changes his mind from project to project and doesn't share his thinking easily 😄

Outside of work, I like to do projects in new languages or using different libraries... you know the sort of thing. And the one thing I really wish I had that I do have at work is a nice code review. When you're deep in the sea of "what the hell am I doing?" there's nothing like a team mate saying either "yeah, you're on the right path" or even "what the hell is this guk?!" it's all better than trying to draw my own map as I go.

Pair programming is great but many devs dont like to share the process with a colleague.

Honestly. CR are great tool to communicate. If it doesn't work is because the people misusing it. in my experience when CR goes wrong is because of ego. Some people very often can argument about the feature but instead decide to make it personal because of antipathy towards the other or because they want to establish some authority. Let's face it. Is not about CR it is about a toxic culture enable by management.

I mean you can but it requires dedication and talent to do it right

I hate code review. So few opportunities for alignment and check ins. I prefer pairing.

Couldn’t a team push back on ensemble programming by saying that they won’t get as much work done because everyone will be working on the same thing, meanwhile all of the other tasks that need to be done will be sitting there idle? How would you respond to this?

Code review is good for situations when there’s outside contributions coming in. Open source projects or PR’s from outside of the team. It’s not great for team-internal collab. They should know each other better than that.

Do you have a link to the study you mentioned at minute 3? :)

Wow, I found those refactoring tips pretty unique, and the way everything falls naturally into place near the end was so satisfying. I also had some fun trying to replicate this in Java although initially in a kind of not-Java way that would look as similar as possible to what you showed. You did a great job as always, I can't wait for the next part and eventually any new kata you manage to find.

Thank you for share!

I still don't get it. I get that with characterisation testing you just accept whatever the code does and nail it down by writing a test for it. Then I understand that with approval testing you think of what the code should do and write a test and then make the code do it. But what is the difference between that and regular TDD/BDD? Also, you didn't even precisely do that. You had a PNG of the result but the executed test didn't check against the PNG, instead you changed the implementation first to produce a red test and then adjusted the text files from your printer to make the test green, comparing it with your own eyes to the PNG. So, what in all this is the crucial part that makes it Approval Testing and sets it apart from other things?

I think you bring more unique and clear content than just about anyone out there. This is great

Too bad, I had to pause this vid. Will return later. But what I've seen so far was awesome. :) You're awesome, Emily!

Good session. Gonna use that with a team I'm coaching. From the content, we here in my dev group (The Guild from Spain) do like how maaany names in early stages of its naming process end up vanished, like inlined or the whatnot. That's why we came up with the most satisfying and writing-pleasant alternative to appleasauce: jitanjaphores!

ever find yourself moving words out of the function name and into a parameter with a default value you'd never change e.g. `fn SendTpsReport_WithCoverSheet(TpsData)` becomes `fn SendTpsReport(TpsData, CoverSheet = true)` (or could be into a parameters object with a default value)

I kinda feel this video should've been sponsored by NamedTuple. (Congrats on the sponsorship!)

Really useful video thanks Emily !

As an exercise, I used an approval test with the Leaderboard Kata in Python. I pretty much did what you did in this video, in my case implementing __str__ on the Leaderboard class. The main issue I had was the lack of integration with PyCharm. I had to manually approve files. Not a deal breaker though.

Thank you for bringing Fowler's book to life. Bravo!

Hi Emily, can you provide a link to the commit message notation you're using? Specifically, I want to know what the difference between "R" and "r" is when you're doing a refactoring commiit. I vaguely remember reading an article about this but can't remember enough to search for it. TIA

Hi Emily. In jetbrains products you can use ctrl+shift+arrows to move a function up and down without "jank-and-paste". Pretty sure Fleet and most other editors have similar features.

Well that was a lot of fun. I finished all five katas, not including the paged HTML excercise. The two that tripped me up were the ISP and LSP. I really liked the way the katas lead you to the solution.

I'm so glad to learn that you've got your first sponsor. Will definitely have a look at their product. Huge congratulations! Your videos offer real value whilst being inspiring as well. Please keep going!

I use LLMs to analyze a large class or very large function and tell me what refactoring could be used and how the end result may look like. Then I use a real refactor tool to do the actual work

0:38 😊

Great video. I'm only a hobbyist these days and generally use Python. I'm already thinking about how to speed up my tests, especially faking interaction with Elasticsearch. I also just got a copy of "Working Effectively with Legacy Code" and note that you were included in the acknowledgements!

Well done, Emily. Good old classic content.