TL Translations for 1-git-internals.asc(402 words) and refspec.asc(718 words) - 1120 words

book/10-git-internals/1-git-internals.asc

@@ -1,19 +1,17 @@
 [[_git_internals]]
-== Git Internals
+== Mga Panloob ng GIT
 
-You may have skipped to this chapter from a much earlier chapter, or you may have gotten here after sequentially reading the entire book up to this point -- in either case, this is where we'll go over the inner workings and implementation of Git.
-We found that understanding this information was fundamentally important to appreciating how useful and powerful Git is, but others have argued to us that it can be confusing and unnecessarily complex for beginners.
-Thus, we've made this discussion the last chapter in the book so you could read it early or later in your learning process.
-We leave it up to you to decide.
+Maari mong nalaktawan ang kabanatang ito mula sa mas naunang kabanata, o maari kang nakarating dito pagkatapos mo basahin ng sunod sunod ang aklat hanggang sa puntong ito -- sa ano mang kaso, dito tatalakayin ang mga panloob na pagtatrabaho at implementasyon ng Git. 
+Nalaman namin na ang pag-intindi ng impormasyong ito ay mahalaga sa panimula upang mapahalagahan kung gaano kapaki-pakinabang at makapangyarihan ang Git, ngunit ang iba ay nakipagtalo sa amin na ito ay maaaring nakalilito at hindi kinakailangan kumplikado para sa mga nagsisimula. 
+Kaya, ginawa namin ang dikusyong ito bilang huling kabanata sa aklat na ito upang mabasa mo ito nang maaga o huli sa proseso ng iyong pag-aaral. Iniwan na namin sa inyo ang pagpasya.
 
-Now that you're here, let's get started.
-First, if it isn't yet clear, Git is fundamentally a content-addressable filesystem with a VCS user interface written on top of it.
-You'll learn more about what this means in a bit.
+Ngayon na nandito ka na, simulan na natin. 
+Una, kung hindi pa ito klaro sa iyo, ang Git sa panimula ay isang filesystem na maaring i-address ang nilalaman at mayroong VCS na interface para sa mga gumagamit. Malalaman mo ang kahulugan nito sa ilang sandali.
 
-In the early days of Git (mostly pre 1.5), the user interface was much more complex because it emphasized this filesystem rather than a polished VCS.
-In the last few years, the UI has been refined until it's as clean and easy to use as any system out there; however, the stereotype lingers about the early Git UI that was complex and difficult to learn.
+Sa mga naunang araw ng Git (halos bago ang 1.5), ang interface ng gumagamit ay mas kumplikado dahil binigyang diin nito ang filesystem sa halip na pakinisin ang VCS. 
+Sa mga nakaraang taon, ang UI ay mas pinainam hanggang sa ito ay maging malinis at madaling gamitin tulad ng anumang mga sistema; subalit, ang gasgas tungkol sa naunang Git UI na kumplikado at mahirap pag-aralan ay nanatili.
 
-The content-addressable filesystem layer is amazingly cool, so we'll cover that first in this chapter; then, you'll learn about the transport mechanisms and the repository maintenance tasks that you may eventually have to deal with.
+Ang suson ng filesystem na maaring i-address ang nilalaman ay nakamamangha, kung kaya't tatalakayin natin yan ng una sa kabanatang ito; saka, matututuhan mo ang tungkol sa mga mekanismo ng transportasyon at ang mga gawain sa pagpapanatili ng imbakan na maari mong tingnan.
 
 include::sections/plumbing-porcelain.asc[]
 
@@ -31,11 +29,10 @@ include::sections/maintenance.asc[]
 
 include::sections/environment.asc[]
 
-=== Summary
+=== Buod
 
-At this point, you should have a pretty good understanding of what Git does in the background and, to some degree, how it's implemented.
-This chapter has covered a number of plumbing commands -- commands that are lower level and simpler than the porcelain commands you've learned about in the rest of the book.
-Understanding how Git works at a lower level should make it easier to understand why it's doing what it's doing and also to write your own tools and helper scripts to make your specific workflow work for you.
+Sa puntong ito, dapat ay may magandang pag-unawa ka na kung ano ang ginagawa ng Git sa background at, sa ilang antas, kung paano ito ipinatupad. 
+Ang kabanatang ito ay sumasakop ng ilang bilang ng mga utos sa plumbing -- ang mga utos na mas mababa at mas simple kumpara sa mga porselanang mga utos na iyong natutunan sa kabuuan ng aklat. 
+Sa pamamagitan ng pag-intindi kung paana gumana ang Git sa mababang antas dapat mapadali nito ang pag-intindi kung bakit nito ginagawa ang ginagawa nito at ang pagsulat mo rin ng iyong sariling mga kasangkapan at mga script na tumutulong upang paganahin ang iyong partikular na workflow.
 
-Git as a content-addressable filesystem is a very powerful tool that you can easily use as more than just a VCS.
-We hope you can use your newfound knowledge of Git internals to implement your own cool application of this technology and feel more comfortable using Git in more advanced ways.
+Ang Git bilang isang filesystem na maaring i-address ang nilalaman ay isang makapangyarihang kasangkapan na madaling gamitin higit pa sa VCS. Umaasa kami na maari mong gamitin ang iyang bagong kaalaman sa panloob ng Git upang maipatupad ang iyong sariling nakakamanghang application sa teknolohiyang ito at maging mas komportable sa paggamit ng Git sa mas mataas na antas na paraan.

book/10-git-internals/sections/refspec.asc

@@ -1,8 +1,8 @@
 [[_refspec]]
-=== The Refspec
+=== Ang Refspec
 
-Throughout this book, we've used simple mappings from remote branches to local references, but they can be more complex.
-Suppose you were following along with the last couple sections and had created a small local Git repository, and now wanted to add a _remote_ to it:
+Sa buong aklat na ito, ginamit namin ang simpleng pagmapa mula sa remote na mga sangay patungo sa mga lokal na reperensiya, ngunit maaring maging mas komplikado ang mga ito.
+Ipagpalagay na sumunod ka sa mga huling pares na mga seksyon at nakagawa ng isang maliit na lokal na Git repository, at ngayon ay nais magdagdag ng _remote_ nito:
 
 [source,console]
 ----