Andrey Bazhin

This time I promise not to code anything until someone is willing to pay for it

When are we going to start building? As soon as we get a "strong signal" (repeated pain point) we will build a PoC polished enough to start a round of presales.

Recently, we have started a new idea. I've been building "products" for the last 3 years, but this one we decided to start from the other end: reach customers first. #buildingpublic

Lately, I started a list of blog posts on time management and other productivity tips for developers. As usual, posting on andreybazhin.com My main goal for now is to learn how to choose good ideas and write good posts.

#indiehackers is anyone building something for #gemini? Just enabled it for Gmail and the native UI sucks, as usual, wish someone would create a prompt manager for it

@damasDev So we're never merging develop to master right? Instead, we're merging features to both

@webholt They are never merging back😁

Gitflow в дикой природе

@NikkiSiapno How about Stacked Diffs? Or it doesn't count as a Git flow strategy? :)

Explaining Git branching strategies: A well-planned Git branching strategy helps coordinate the development team’s work and keeps the development process consistent. When formulating your branching strategy, it's important to take into account the project’s complexity, the team’s size, and the release cycle. Let's take a look at some common approaches to branching: Feature branching is a popular approach as development tasks are usually revolved around a feature. It involves having a branch for every feature being developed to keep the changes isolated from the main branch. Code reviews are simplified as all changes are contained in one branch. Gitflow has two permanent branches — a production and a pre-production branch, often referred to as the “prod” and “dev” branches. There are additional temporary branches for each feature, scheduled releases, and urgent bug fixes. All changes other than urgent bug fixes are merged into the dev branch. Before a scheduled release, a release branch is created for further cleaning and testing. Once ready for production, the release branch is merged into the prod branch. This is a great approach for projects with scheduled release cycles & multiple production versions. GitLab flow combines feature-branching and environment-based branching. Changes are merged into a main branch which is then merged into subsequent branches that correlate to an environment in the CI/CD pipeline; such as staging and production. This strategy offers a more flexible alternative to Gitflow and better facilitates continuous development. GitHub flow takes a simplified process that is similar to feature branching. The key difference is that GitHub flow incorporates deployment into its approach. The main branch is always production-ready, and changes to this branch trigger the CI/CD process; this isn't the case with feature branching. With trunk-based development, branches are very short-lived. Changes are merged into the main branch within a day or two. Feature flags are used for changes that require more time to complete. This strategy requires very disciplined processes & excellent testing. It's become a popular approach for very large teams who have the capacity to implement these processes, & where large merge conflicts can often occur. When formulating your branching strategy, take the most relevant features from the above strategies and apply your own set of tweaks. Every project and team has its own unique needs and boundaries, which should be reflected in their Git branching strategy. ~~ A big thank you to our partner Postman who keeps our content free to the community. The importance of APIs in software development has grown so much and will continue to grow. Here's a great piece to learn about API design: drp.li/api-design-pos…

#developers, do you know how to work on 2 git branches at once without stashing/committing? Do I need to have 2 repos at once?

How to get your refactoring idea never approved. -> andreybazhin.com/how-to-sell-yo… And how to make it right as well. #refactoring #techdebt

@JoshJosephB One more - make sure it makes sense for the future of the app and you're not refactoring a dead horse 😄

The 2 laws of code refactoring: - Make sure the code you're refactoring has test coverage. - Read that again. You're welcome :)

@ayushtweetshere You can ask a friend to pre-pay you if he likes the idea though 😀 “People stop lying when you ask them to pay”

I used to think my product ideas were amazing. Then I started asking potential customers and got a reality check. You only learn the truth by speaking to users, not friends. Your friends will tell you your idea is great because they're being nice. But nice isn't useful.

@aakashgupta A-team at day C-team at night

What team are you on?

Personal experience and insights in grokking crazy-hard tasks with simple tools Test-Driven Development beats debugging 👇 #devex #tdd andreybazhin.com/debug-no-more

Getting back to my lovely Tech Advisor blog after half a year of silence. Decided to post at least one post a week for the next 30 weeks, follow the journey of mine on andreybazhin.com And for sure I'll re-post everything on X #challenge

@jitterted Diff between expected and actual is quite useful when figuring out the reason for the fail. Love the "fails with useful information" point, got to be elaborated on implementation though :)

This is an often ignored part of Test-Driven Development (also applies to Test-First): since you must see the test fail, you can ensure that: * It fails when expected * It fails in the way you expected * It fails with _useful_ information about WHY it failed

@worldofprasanna The newsletter by @bentossell for a general overview. @DeepLearningAI for free courses on whatever seems important/promising

Just curious !! How are you keeping up with the LLM trend? 🤔 which source are you following ?!!