How to declutter your Quarto repo with Git submodules

🔗 Git Submodules demystified! Repos inside repos? Yes, and it's powerful for managing shared code across projects. I cover: ✅ When to use them (and when NOT to) ✅ Complete workflow from A to Z ✅ What I wish I knew from day one 👉 Check it out, save for later, and let me know : what's been your biggest challenge with managing shared code?

Why you should rebase (and squash) before merging — and why your team and future self will thank you. Every “fix typo”, “attempt 3”, and “add console.log” commit you push is a breadcrumb trail someone will have to follow later — and that someone is probably you. Six months from now, when a bug appears in production, the difference between a clean commit history and a messy one is the difference between a 5-minute fix and a day of painful archaeology. Rebasing rewrites history into a linear story: one commit flows into the next, with no confusing merge bubbles or criss-crossed branches. Squashing takes all those noisy WIP commits and turns them into clear, meaningful milestones. Together, they make your git history something you want to read — and something tools like git bisect can work with efficiently. A clean history makes it easier to: ✅ Understand why a change happened. ✅ Cherry-pick or revert specific features. ✅ Trace bugs to their source quickly. ✅ Keep your main branch readable and reviewable. And yes — you can, and should, automate a lot of this with merge strategies in GitHub or Bitbucket. But understanding how and why to do it manually will make you a better collaborator and a better engineer. I wrote a compact guide on how to rebase, squash, and write great commit messages here 👇 https://lnkd.in/exPpVhbn

Think Git is some dark magic? Wrong. The "don't touch the .git folder" rule is for newbies. It’s just text files! Your whole history is in there, readable. Dare to `cat .git/HEAD`. See? It just points to your branch. But edit one thing and your repo is toast. Is hiding internals genius design or a crutch for devs? #GaboTips

The Beauty of Simple, Clear Thinking 💭 Recently went down a rabbit hole and read through the very first Git commit by Linus Torvalds. What struck me wasn't just the technical brilliance—it was the absolute clarity of thought. 🤯 In that initial README, Linus calls Git "the stupid content tracker" and breaks down complex version control concepts into their purest form: objects, trees, blobs, and changesets. No overengineering. No unnecessary abstractions. Just elegant solutions to real problems. ✨ There's something humbling about reading code and documentation from someone who saw through the complexity and built something that would fundamentally change how millions of developers work. 🌍 It's a reminder that great engineering isn't about making things complicated—it's about making complex things simple. 💡 Worth a read if you haven't seen it: https://lnkd.in/gTbu6P9E 📖 #SoftwareEngineering #Git #TechHistory #Learning

🍒 Git Cherry Pick when you only need that one fix 💻 Part 6 of my #Git series You’re on another branch, minding your own business, and suddenly think, “That one commit I made earlier... kinda need it here too.” Happens all the time. You don’t wanna merge the whole branch, just that one tiny fix. That’s where #cherrypick helps. git cherry-pick <commit-hash> And boom, that exact commit shows up in your current branch. Suppose you fixed a bug in feature/login, but you need it in main as well. git checkout main git cherry-pick a1b2c3d Now main has that one fix. No messy merges. No unwanted commits. Just that clean cherry 🍒 A few things I’ve learned: Keep commits small. #GitTips Double check the hash before picking If conflicts show up, fix them and run git cherry-pick --continue I use it a lot when I mess up branches or just want to move a quick patch around. 👉 Next up: Part 7 – Git Reset vs Git Revert https://lnkd.in/dmRvq7F3 #Git #DeveloperLife #SoftwareEngineering #Productivity

Ever started coding a new feature… — then realized you were editing main directly? Here’s a quick refresher on the right Git workflow most dev teams use 👇 Always branch off main (or dev) so your work stays isolated. Create a new branch git checkout -b feature/new-feature Push your branch to the remote repo git push -u origin feature/new-feature This sets the upstream so future pushes are easier. Develop & Test your New Feature Make a Pull Request (PR) Head to GitHub/GitLab → click “Compare & pull request.” Add a clear title and description — reviewers will thank you. Merge back into main Once approved, merge via the PR interface or: git checkout main git merge feature/new-feature Sync your local main git checkout main git pull origin main This pulls all new updates so you’re ready for the next feature. 💡 Pro tip: Keep branches short-lived. Smaller PRs = faster reviews + fewer merge conflicts. #Git #DevTips #WebDevelopment #VersionControl

𝐓𝐡𝐞 𝐂𝐨𝐬𝐭 𝐨𝐟 𝐍𝐞𝐠𝐥𝐞𝐜𝐭𝐢𝐧𝐠 𝐃𝐨𝐜𝐮𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 It’s easy to postpone writing documentation when deadlines loom. The feature works, the code is merged, and the deployment is live - mission accomplished. Until months later… a bug surfaces, the original developer has moved on, and the why behind the logic is lost somewhere deep in Git history. That’s when it hits - The real cost of skipping documentation isn’t confusion. It’s time lost, context forgotten, and trust eroded between teams trying to decode intent instead of delivering value. Over the years, I’ve learned that great documentation isn’t about being verbose - it’s about continuity. A well-documented system is a gift to your future self and your future team. Because clarity doesn’t slow teams down - it compounds their speed over time. If your codebase needs a quiet hero, sometimes… it’s a well-written README.md. #Documentation #SoftwareEngineering #TeamEfficiency #DeveloperExperience #TechLeadership #CleanCode #SystemDesign #EngineeringCulture #KnowledgeSharing #FullstackDeveloper

I've been using git worktree for at least five years now. Say I work on the short_ruby project and set up the following structure: - `short_ruby/main`: Main branch. - `short_ruby/pairing`: For code reviews, exploring changes, or sharing drafts. - `short_ruby/feature_<id>`: A temporary worktree for each feature, deleted when complete. Why these folders: I always maintain a local copy of the current main branch. This helps me review changes or start something new, as I can quickly verify how production functions if the main branch is what's deployed. The pairing one because I want to access any branch quickly I'm reviewing while still seeing the main branch. Having separate folders makes switching between them easy. Additionally, I use folders for each feature or bug I'm working on. https://lnkd.in/dMCmDXmW

Voyage 57 — Part 4: Shipping Fast with a Clean Git Workflow Before writing any feature code, our team aligned on a simple, battle-tested workflow. We didn’t reinvent the wheel — we adopted Chingu’s recommended process and tailored it to our needs. Branch strategy (3 levels): ▸ Working branches — per task with clear prefixes: feature/..., fix/..., refactor/... (e.g., feature/course-review). ▸ development — integration for the next release; PRs only after tests + peer review. ▸ master — production; updated from development via PR. Team habits we agreed on: ✓ Clone the skeleton, create task-scoped branches, commit early & often (atomic, descriptive). ↑ Push frequently to keep work safe and visible; ↓ pull teammates’ branches when pairing/unblocking. ⇄ Open a PR to development once unit-tested; require a second pair of eyes for quality. ⇢ Batch-test features; promote to master via PR; release. My part: I created the development branch and set branch naming conventions so everyone could start shipping confidently from day one. Next up: our first feature PR and how we’re wiring @octokit/rest for GitHub API integration. #FrontendDeveloper #ReactJS #JavaScript #Web3 #Git #AgileDevelopment #ChinguVoyage57Series