ce înseamnă să dau share la o postare?
inseamnă să distribui postarea mai departe.o poti distribui:
1.pe cronlogia ta
2.pe cronologia unui prieten
3.intr.un grup/pagina
 share(engleza)-a distribui(romana). dupa ce distribui postarea, toți prietenii tai vor putea sa o vada si sa iti dea like.uri, commentarii..iti dau detalii pentru ca vad ca esti incepator
***Viral.*** Cuvîntul acesta e deja... viral, nu mai poate fi împiedicat să se răspîndească (dacă chiar i-a trecut cuiva prin cap să-l împiedice). Sensul din medicină și biologie nu are deloc de suferit, de altfel vorbitorii sînt destul de inteligenți să-și dea seama că sensul legat de virusul biologic e cel propriu, în timp ce sensul legat de internet e metaforic: ceva (un videoclip etc.) este viral dacă se răspîndește rapid, ca virusul unei boli molipsitoare.  

  

 E interesant că propuneți să spunem *popular* în loc de *viral*. În primul rînd, există o diferență de nuanță: *popular* înseamnă „îndrăgit de mulți”, iar *viral* înseamnă că se împrăștie ca o molimă, nu neapărat pentru că ar fi îndrăgit. În al doilea rînd, *popular* cu sensul „îndrăgit de mulți” aproape că dispăruse din română acum cîteva zeci de ani. Lumea nu mai spunea *un om popular*, ca pe vremuri. Dar sensul a reînviat recent, ca traducere pentru englezescul *popular*. Eu unul îl percep ca pe un barbarism, pentru că în copilăria și tinerețea mea nu vorbea nimeni așa, iar acum e din ce în ce mai frecvent, în exact aceleași contexte în care se folosește *popular* în engleză (vorbesc de acest sens particular, nu de toate). Ca urmare am fost surprins că propuneți un barbarism în locul altuia. E drept totuși că nu poate fi clasificat ca barbarism propriu-zis, pentru că sensul acesta a existat ca atare în română și a luat doar o pauză, deci e în același timp barbarism și arhaism.  

  

***Sit.*** Cei mai mulți spun într-adevăr *site* (citit *sait*, că sitele sînt altceva...), dar există și o proporție semnificativă de vorbitori care spun *sit*, eventual *sit de internet* ca să fie și mai clar. Explicația e simplă: anglicismul *site* are de fapt aceeași origine și a avut inițial același sens ca situl nostru. Ei l-au luat pe *site* din franceză (cuvîntul *site*, citit *sit*, de origine latină), iar noi l-am luat pe *sit* tot de acolo și l-am adaptat grafic. Ambele au avut la început sensul „loc”, dar specializat puțin altfel în cele trei limbi. Ce rost are să reîmprumutăm pe ocoliș un cuvînt pe care l-am împrumutat deja o dată? Nu e mai simplu să ne folosim propriul nostru cuvînt, care în plus mai are și avantajul major că e total adaptat fonetic și grafic la limbă? E nevoie doar să-i mai adăugăm un sens, exact cum au făcut de altfel și anglofonii cînd au început să-l folosească pe *site* pentru a denota un loc de pe internet. Dacă ei pot, sigur putem și noi, nu? Eu spun *sit*.  

  

 Grafia *sait* nu e greșită, cum greșit spune Ciprian Constantin, ci doar adaptată la limbă. Dacă adaptarea e o greșeală, atunci și următoarele anglicisme ar fi la fel de greșite: *meci, fotbal, dispecer, gem, pulover, interviu, trening, lider, miting, tramvai, stres*.  

  

***Downloada.*** Mie mi se pare un monstru, atît fonetic cît și grafic, încît nu-l folosesc niciodată. Presupun că lumea îl folosește doar din comoditate sau snobism. Nu cred că dorința de precizie a exprimării poate fi atît de puternică încît să ducă la folosirea unui cuvînt care-ți limbă plimba-n gură. *A descărca* e un termen suficient de precis, mai ales dacă avem și un context. La fel *a încărca* sau *a trimite* pentru *upload*. da eu am , cum doriti asocierea Answer for you my friend: <https://www.duolingo.com/comment/4272531> :P **UPDATE**


Acest răspuns este destul de vechi, și așa descrie ceea ce a fost 'bine' la momentul respectiv, care a fost inteligent indicii furnizate de Impuls bibliotecă. Deoarece C++11, biblioteca standard a furnizat suficiente smart pointeri de tipuri, și așa ar trebui să favorizeze utilizarea [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr), [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr) și [`std::weak_ptr`](http://en.cppreference.com/w/cpp/memory/weak_ptr). 


Acolo a fost, de asemenea, [`std::auto_ptr`](http://en.cppreference.com/w/cpp/memory/auto_ptr). A fost foarte mult ca o luneta pointer, cu excepția faptului că a avut, de asemenea, "speciale" periculoase capacitatea de a fi copiate — care, de asemenea, în mod neașteptat transferă dreptul de proprietate.
**S-a depreciat în C++11 și eliminate în C++17**, deci nu ar trebui't-l folosească.



```
std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
```






**RĂSPUNS VECHI**


Un smart pointer este o clasa care se infasoara un 'prime' (sau 'gol') C++ pointer, pentru a gestiona durata de viață a obiectului de a fi subliniat. Nu există nici un singur inteligente de tip pointer, dar toate dintre ele încerca să rezumat o primă pointer într-un mod practic.


Smart pointeri ar trebui să fie de preferat peste prime indicii. Dacă simțiți că aveți nevoie pentru a utiliza pointeri (ia în considerare mai întâi dacă într-adevăr ** face), ar fi normal să doriți să utilizați un smart pointer deoarece acest lucru poate atenua multe dintre problemele cu prime indicii, în principal, uitând să ștergeți obiectul și scurgeri de memorie.


Cu prime indicii, programatorul trebuie să specifice în mod explicit distruge obiectul atunci când acesta nu mai este util.



```
// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?
```

Un smart pointer prin comparație definește o politică ca atunci când obiectul este distrus. Tu încă mai au pentru a crea un obiect, dar nu mai trebuie să vă faceți griji despre distrugerea ei.



```
SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception
```

Cea mai simplă politica de utilizare implică domeniul de aplicare de smart pointer obiect înveliș, cum ar fi puse în aplicare până la [`boost::scoped_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/scoped_ptr.htm) sau [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr). 



```
void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}
```

Notă: std::unique\_ptr` cazuri nu pot fi copiate. Acest lucru previne pointer de a fi șterse de mai multe ori (în mod incorect). Cu toate acestea, puteți trece referiri la aceasta în jurul valorii de la alte funcții-ai sunat.


`std::unique\_ptr sunt utile atunci când doriți pentru a lega de viata a obiectului la un anumit bloc de cod, sau dacă încorporat ca date membre în interiorul altui obiect, durata de viata de care alt obiect. Obiectul există până conțin bloc de cod este ieșit, sau până la obiect este distrus.


Mai complex smart pointer politică implică numărare de referință indicatorul. Acest lucru permite ca indicatorul să fie copiate. Când ultima "de referință" la obiectul este distrus, obiectul este șters. Această politică este implementată de [`boost::shared_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm) și [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr).



```
void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.
```

Referință numărat indicii sunt foarte utile atunci când durata de viață a obiectului este mult mai complicat, și nu este legat direct la o anumită secțiune de cod sau de la un alt obiect.


Există un dezavantaj de referință numărat pointer — posibilitatea de a crea o marionetă de referință:



```
// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!
```

O altă posibilitate este crearea de referințe circulare:



```
struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!
```

Pentru a rezolva această problemă, atât Stimula și C++11 au definit o `weak_ptr` pentru a defini un slab (nenumărate) de referință la un `shared_ptr`. propagarea dns este un termen folosit pentru a descrie intervalul de timp până modificările aduse domeniului sau al informațiilor din zona dns devin vizibile indiferent de unde se fac interogările.acest proces este unul automat de sincronizare a datelor dns la nivel global și nu poate fi influențat. va trebui să așteptați propagarea dns atunci când : - faceți modificări ale nameservere-lor setate pe domeniu.o propagare completă poate dura până în 48 de ore. în general, propagarea are loc în câteva ore. - faceți modificări în zona dns. pentru a mări timpul de execuție al interogărilor dns, se crează cache-uri atât locale , pe dispozitivul folosit pentru accesare cât și cache-uri create pe servere externe și ale furnizorului de internet. fiecare înregistrare dns are o valoare ttl (time to live), care se referă la timpul de stocare a informațiilor dns în cache. o dată ce acest timp expiră, la următoarea interogare dns, informațiile se vor reîmprospăta. o propagare completă a informațiilor dns poate dura până la 48 de ore. în general, propagarea are loc în câteva ore. pentru toate cazurile de mai sus este recomandată golirea cache-ului browser-ului înainte de a verifica dacă propagarea s-a finalizat. 1. Aveți posibilitatea de a vinde software-ul.
2. Nu, nu sunteți obligat să furnizați codul sursă.
3. Oricine primește *codul sursă* poate face ca permis de licență. Aceasta nu se extinde la binar distribuții.


Citiți licența MIT. Citește totul și înțelege totul. Acesta a fost menit să fie citit de către oameni obișnuiți, spre deosebire de alte licențe care sunt foarte complexe:



> 
> Copyright (c) *an* *titularii de drepturi de autor*
> 
> 
> Permisiunea se acordă, gratuit, de
> gratuit, oricărei persoane care obține o copie
> a acestui software și asociate
> fișierele de documentație ("Software"),
> pentru a face față în Software-ul fără
> restricție, inclusiv, dar fără
> limitare la drepturile de utilizare, copiere,
> modifica, uni, publica, distribui,
> sublicenția, și/sau vinde copii ale
> Software-ul, și pentru a permite persoanelor
> care Software-ul este mobilat să facă
> deci, sub rezerva următoarelor
> condiții:
> 
> 
> de copyright de mai sus și acest
> notificare de permisiune vor fi incluse în
> toate copiile sau porțiunile substanțiale ale
> Software-ul.
> 
> 
> SOFTWARE-ul ESTE FURNIZAT "CA ESTE",
> FĂRĂ NICIUN FEL DE GARANȚIE, EXPRESĂ
> SAU IMPLICITE, INCLUSIV, DAR NU LIMITAT
> LA GARANȚIILE DE VANDABILITATE,
> potrivire PENTRU UN ANUMIT SCOP ȘI
> NEÎNCĂLCARE. IN NICI UN CAZ
> AUTORII SAU DEȚINĂTORII drepturilor de AUTOR FI RESPONSABIL
> PENTRU ORICE REVENDICARE, DAUNE SAU ALTE
> RĂSPUNDEREA, FIE ÎN ACȚIUNE DE
> CONTRACT, PREJUDICIU SAU ALTFEL, rezulta
> din, DIN SAU ÎN LEGĂTURĂ CU
> SOFTWARE-ul SAU UTILIZAREA SAU ALTE TRANZACȚII
> ÎN SOFTWARE-ul.
> 
> 
> când spuneți că vreți sa vă ajute cineva să vindeți, vă referiți la servicii gratuite? ca un fel de serviciu voluntar în folosul comunității? e bine. sunt sigur că veți găsi mulți voluntari. mult noroc! Apasa [aici](https://www.duolingo.com/comment/14346584) pentru mai multe informatii. este o idee foarte buna, puteti incepe sa mentionati aici experientele dvs. si sa le postati si pe alte forumuri/bloguri, ca de exemplu: http://www.vision-imobiliare.ro/blog/postati-aici-intrebarileopiniile-dvs Începând cu Git versiunea 2.5+ (Q2 2015), preluarea-un singur comite (fără clonare complet repo) este de fapt posibil.
A se vedea [comite 68ee628](https://github.com/git/git/commit/68ee628932c2196742b77d2961c5e16360734a62) de [Fredrik Medley (`moroten`)](https://github.com/moroten), 21 Mai 2015.
(Fuzionat cu [Junio C Hamano -- `gitster` --](https://github.com/gitster) în [comite a9d3493](https://github.com/git/git/commit/a9d34933803198f89ad721ee17f138b046131090), 01 Jun 2015)
Acum aveți un nou config (pe partea de server) 



```
uploadpack.allowReachableSHA1InWant
```


> 
> Permite upload-pack`pentru a accepta o aduce cerere prin care se solicită un obiect care este accesibil din orice sfat ref. Cu toate acestea, rețineți că calcularea obiect de accesibilitate este de calcul scumpe. Implicit la "false". Dacă ai combina configurare server-side cu un superficial clona ([`git fetch --depth=1`][1]), puteți cere pentru un singur comite (a se vedea [`t/t5516-fetch-push.sh`][2]: 
> 
> 
> 



```
git fetch --depth=1 ../testrepo/.git $SHA1
```

Puteți utiliza `git pisica-fișier de comandă pentru a vedea că a comis a fost preluat: 



```
git cat-file commit $SHA1
```


> 
> "`git incarca-pack`" care servește "`git fetch`" poate fi spus pentru a servi
> se angajează ca nu sunt la vârful orice arbitru, atâta timp cât acestea sunt
> află de la un arbitru, cu uploadpack.allowReachableSHA1InWant`
> configurație variabilă.
> 
> 
> 
> Documentația completă este: 
> 
> 
> `upload-pack`: opțional permite preluarea accesibil sha1
> 
> 
> 
> Cu `uploadpack.allowReachableSHA1InWant` opțiune de configurare a stabilit pe partea de server, "`git fetch`" se poate face o cerere cu o "vreau" linie care numele unui obiect care nu a fost promovat (posibil să fi fost obținut de trupa sau de la un submodul pointer).
> Numai obiecte accesibile din ramura sfaturi, adică unirea a promovat sucursale și filiale ascunse de transfer.hideRefs`, vor fi procesate.
> Rețineți că există un cost asociat de a avea pentru a merge înapoi în istorie pentru a verifica accesibilitatea.
> **Această caracteristică poate fi utilizată pentru obținerea conținutului de la o anumită comis-o,
> pentru care sha1 se știe, fără a fi nevoie de clonare tot
> repository, mai ales dacă o superficial aduce este folosit**.
> cazuri Utile sunt, de exemplu 
> 
> 
> * centrale de tranzacții care conțin fișiere mari în istorie,
> * preluarea numai datele necesare pentru un submodul de verificare,
> * atunci când schimbul de un sha1 fără a spune exact care filiala îi aparține și în Gerrit, dacă te gândești în termeni de comite în loc de a schimba numerele.
> (Gerrit caz a fost deja rezolvată prin `allowTipSHA1InWant` ca fiecare Gerrit schimbare are un ref.)
> 
> 
> 
> Git 2.6 (T3 2015) va îmbunătăți acest model.
> A se vedea [comite 2bc31d1](https://github.com/git/git/commit/2bc31d1631229d863376d48ef84eb846fea1df02), [comite cc118a6](https://github.com/git/git/commit/cc118a65b4590cc2d669679260bad7ca627f2a30) (28 Iulie 2015) de [Jeff King (`peff`)](https://github.com/peff).
> (Fuzionat cu [Junio C Hamano -- `gitster` --](https://github.com/gitster) în [comite 824a0be](https://github.com/git/git/commit/824a0be6be8d6c3323003bae65b3df98387e575b), 19 Aug 2015) 
> 
> 
> `ref`: suport negativ **** `de transfer.hideRefs`
> 
> 
> 
> Dacă te-ai ascunde o ierarhie de arbitrii folosind transfer.hideRefs`config, nu există nici o modalitate de a mai târziu a trece peste acel config pentru a "anulați" nu. Acest patch implementează un "negativ" ascunde-care provoacă meciuri pentru a fi imediat marcat ca unhidden, chiar dacă un alt meci s-ar ascunde. Avem grijă să aplice meciuri în sens invers-comanda de la modul în care acestea sunt alimentate la noi prin config mașini, după care vă permite noastre obișnuite "ultimul castiga" config prioritate de muncă (și intrările în`.git/config`, de exemplu, va trece peste`/etc/gitconfig`).
> Astfel încât să puteți face acum:
> 
> 
> 



```
git config --system transfer.hideRefs refs/secret
git config transfer.hideRefs '!refs/secret/not-so-secret'
```


> 
> pentru a ascunde `ref/secret în toate operațiunile repo, cu excepția pentru unul publice pic
> într-un anumit repo.
> 
> 
> 
> Git 2.7 (Nov/Dec 2015) va îmbunătăți din nou:
> A se vedea [comite 948bfa2](https://github.com/git/git/commit/948bfa2c0f40a97d670c6a3fc22c05ceb2ec2c3f), [comite 00b293e](https://github.com/git/git/commit/00b293e519d1aa0c5b57ae9359ec5306d7023b3f) (05 Nov 2015), [comite 78a766a](https://github.com/git/git/commit/78a766ab6eaaa91c2638158bd4fda06a93291da0), [comite 92cab49](https://github.com/git/git/commit/92cab492ba988ffd3e3edf040f19ba820306c833), [comite 92cab49](https://github.com/git/git/commit/92cab492ba988ffd3e3edf040f19ba820306c833), [comite 92cab49](https://github.com/git/git/commit/92cab492ba988ffd3e3edf040f19ba820306c833) (03 Nov 2015), [comite 00b293e](https://github.com/git/git/commit/00b293e519d1aa0c5b57ae9359ec5306d7023b3f), [comite 00b293e](https://github.com/git/git/commit/00b293e519d1aa0c5b57ae9359ec5306d7023b3f) (05 Nov 2015), și [comite 92cab49](https://github.com/git/git/commit/92cab492ba988ffd3e3edf040f19ba820306c833), [comite 92cab49](https://github.com/git/git/commit/92cab492ba988ffd3e3edf040f19ba820306c833), [comite 92cab49](https://github.com/git/git/commit/92cab492ba988ffd3e3edf040f19ba820306c833), [comite 92cab49](https://github.com/git/git/commit/92cab492ba988ffd3e3edf040f19ba820306c833) (03 Nov 2015) by [Lukas Fleischer (`lfo`)](https://github.com/lfos).
> Ajutat de: [Eric Soare (`sunshineco`)](https://github.com/sunshineco).
> (Fuzionat cu [Jeff King -- `peff` --](https://github.com/peff) în [comite dbba85e](https://github.com/git/git/commit/dbba85e46b9c7450710a23208ca1868179330e1e), 20 Nov 2015) 
> 
> 
> `config.txt`: document semantica `hideRefs cu spații de nume
> 
> 
> 
> acum, nu există o definiție clară a modului de transfer.hideRefs`ar trebui să se comporte atunci când un nume este setat. Explicați că`hideRefs`prefixe meci dezbrăcat nume în acest caz. Acesta este modul`hideRefs` modele sunt în prezent
> manipulate în primi-pack. 
> 
> 
> hideRefs: adauga suport pentru potrivire complet ref
> 
> 
> 
> În plus față de potrivire dezbrăcat ref, se poate adăuga acum `hideRefs` modele complet (unstripped) ref este compensată.
> Pentru a distinge între dezbrăcat și plin de meciuri, noile modele trebuie să fie prefixate cu un circumflex (`^`).
> Prin urmare [new documentația][3]: 
> 
> 
> 



```
transfer.hideRefs:
```


> 
> Dacă un nume este în uz, namespace prefix este deposedat de fiecare referință înainte de a este compensată de transfer.hiderefs`modele. De exemplu, dacă`ref/capete/master este specificat în transfer.hideRefs`și actualul nume este`foo", apoi " ref/nume/foo/ref/capete/master
> este omis din reclame dar `ref/capete/master și` ref/nume/bar/ref/capete/master sunt încă anunțate și așa-numita
> "trebuie" linii.
> În scopul de a se potrivi ref înainte de separare, se adaugă un `^` in fata
> arbitrul numele. Dacă combina `!` și `^`, `!` trebuie să fie specificată în primul rând.
> 
> 
> 
> [R..](https://stackoverflow.com/users/379897/r) menționează [în comentarii](https://stackoverflow.com/questions/14872486/retrieve-specific-commit-from-a-remote-git-repository/30701724#comment89086774_30701724) config [`uploadpack.allowAnySHA1InWant`](https://git-scm.com/docs/git-config#git-config-uploadpackallowAnySHA1InWant), care permite `upload-pack` de a accepta un "aport" cererea prin care se solicită orice obiect, la toate. (Implicit este "false").
> A se vedea [comite f8edeaa](https://github.com/git/git/commit/f8edeaa05d8623a9f6dad408237496c51101aad8) (Nov. 2016, Git v2.11.1) până la [David "novalis" Turner (`novalis`)](https://github.com/novalis): 
> 
> 
> `upload-pack`: opțional permite preluarea orice sha1
> 
> 
> 
> Se pare o prostie sa faci un reachabilty a verifica în cazul în care ne-am
> încrederea utilizatorului de a accesa absolut tot ce e în depozit.
> de Asemenea, l's democrației într-un sistem distribuit poate una server
> reclamă un arbitru, dar altul a avut de atunci o forță de apăsare la ref,
> și, probabil, cele două cereri HTTP ajung îndreptate spre aceste diferite
> serverele. 
> 
> 
>