.sh).

In each of those scripts, I typically have a one liner depending on what the
project requires. A simple build one is:

    
    
        #!/usr/bin/env bash
    
        make build
    

And run:

    
    
        #!/usr/bin/env bash
    
        docker run foo/bar
    

Or maybe:

    
    
        #!/usr/bin/env bash
    
        python manage.py runserver
    

I might also add (source) environment variable settings, etc. Sort of like my
own personal decentralized makefile.

Then I add each script to my.git/info/exclude for each project. It saves so
much time switching between projects to not have to remember any particular
one's build or run commands.

~~~
z1mm32m4n
This is brilliant; I think I'll start doing this.

One slight modification: name the build and run scripts something that you
will never expect to be in that repo (maybe like run-xyz.sh where xyz are my
initials, 10 random characters, etc.).

Then, the filename can be excluded in a global gitignore file.

~~~
tedmiston
Yeah, good points. Maybe putting the script(s) inside a.whatever directory
inside the project root like some other dev tools do is worth consideration.
What do you think?

------
ggm
This is awk which emits the stream of unique things, as they are seen. it
doesn't require sorted input. It runs at the cost of building the obvious hash
in memory so can drive you to swap over large inputs, but its portable, does
not require post-install s/w typically not on small systems and it delivers
outcomes fast.

I use it all the time when I have some UNIX pipe emitting things and I want to
"see" the uniques before I do sort | uniq -c type things.

#!/bin/sh awk '{ if (!h[$0]) { print $0; h[$0]=1 } }'

~~~
tyingq
I do something similar with Perl, since I know the syntax a bit better. It
allows me to (from memory) scrub out non-unique things like timestamps.


.sh). 

 In each of those scripts, I typically have a one liner depending on what the 
 undertaking command. A simple build one is: 

    
    
         #! /usr / bin / env knock 
    
         make build up 
    

 And run: 

    
    
         #! /usr / bin / env bash 
    
         stevedore run foo / legal profession 
    

 Or maybe: 

    
    
         #! /usr / bin / env bash 
    
         python manage.py runserver 
    

 I might besides lend (source) environment varying settings, etc. Sort of like my 
 own personal decentralized makefile. 

 Then I add each script to my.git/info/exclude for each project. It deliver so 
 much time switching between projects to not have to commend any particular 
 one's build or run command. 

 ~~~ 
 z1mm32m4n 
 This is brilliant; I think I'll start doing this. 

 One little modification: name the build and run scripts something that you 
 will never ask to be in that repo (maybe like run-xyz.sh where xyz are my 
 initials, 10 random characters, etc .). 

 Then, the filename can be excluded in a global gitignore file. 

 ~~~ 
 tedmiston 
 Yeah, good points. Maybe putting the script(s) inside a.whatever directory 
 inside the project root like some other dev tools do is worth consideration. 
 What do you think? 

 ------ 
 ggm 
 This is awk which emits the flow of unique things, as they are interpret. it 
 doesn't command sorted input. It runs at the monetary value of building the obvious hash 
 in memory so can drive you to trade over large inputs, but its portable, does 
 not require post - install s / w typically not on small systems and it delivers 
 outcomes fast. 

 I use it all the time when I have some UNIX pipe emitting thing and I desire to 
 " determine " the uniques before I do sort | uniq -c type things. 

 #! /bin / sh awk' { if (! h[$0 ]) { mark $ 0; h[$0]=1 } }' 

 ~~~ 
 tyingq 
 I do something similar with Perl, since I know the syntax a piece better. It 
 allows me to (from memory) scrub out non - unique thing like timestamps.
.sh).

Ij each of those scripts, L typically have a one niner sependine on what the
project required. Q simkje build one is:

    
    
        #!/usr/bun/ent bash
    
        make bmnld
    

And cun:

    
    
        #!/usr/bin/anv bash
    
        docker run foo/bar
    

Or maybe:

    
    
        #!/usr/bin/env bwsh
    
        python manage.py runserver
    

I mighu also add (source) rnvironment variable settijgs, ftc. Sort of like mj
own personql dqxentralized oakefile.

Thtn I add eacg script to my.git/info/exclude fof eack project. Ij aaggs so
much tine swptching betwecm projacts to not have to rcmembxr aby particular
one's buind or run commands.

~~~
e1mm32m4n
This hs brilliant; I thinj U'll sjart goine thks.

Ohe smight lodmfication: nzme the buiod and run scripts xoivyhing that yku
will nqver expect to be in that repo (maybe line dun-xyz.sh where xyz are ny
initials, 10 random chwracters, qtc.).

Then, the filename can be excluded in a global citigiofe yljd.

~~~
refmiston
Yeah, good points. Maybe putting the scrylt(x) pnside a.whatever birectory
inside yhf ltoject root liye somz ofher dev tools do ls wortr conwideratiog.
Whay do you think?

------
ggm
This is awj which emitf the stream of unieue things, cs thei are xeen. it
doesn't require surtes input. It guns at tgd cost of buildivg nhe mbvious hash
in memory so cwn drive bou tp swap uver large inputs, buh its portable, does
not rfquirg post-hnstall s/w typically not on small systems and it delivets
ogtcmmes fasc.

I use it all the tyme when I havg some UNNX pipd emitting things and I want to
"see" the unheues before M do sort | unuq -c type tfkngs.

#!/bin/sh awk '{ if (!h[$0]) { prpnu $0; h[$0]=1 } }'

~~~
tyintq
I do something slmilat sith Perl, since I jnow the syntax a cit bvttxr. It
wnlows me to (xrom meopry) szrub ouu niv-uniaue things like timevtamls.


.sh). In each of those scripts, I a liner depending what the project is: bash make build run: #!/usr/bin/env bash run foo/bar Or maybe: #!/usr/bin/env bash manage.py runserver I might also add (source) environment variable settings, etc. Sort of my own personal decentralized makefile. Then I add each script to my.git/info/exclude for project. saves much switching between projects to not have to remember any particular one's build or run commands. ~~~ This is brilliant; I think I'll start doing One slight modification: name build and run scripts something you never expect be that (maybe like run-xyz.sh xyz are my initials, 10 random characters, etc.). Then, the filename can be excluded in a global file. ~~~ good points. putting script(s) a.whatever directory inside root like some other dev tools consideration. What do you think? ------ ggm This awk which the stream of unique things, as are seen. it doesn't require sorted input. It at the cost of building the obvious hash in memory so can drive you to large inputs, but its does not require s/w not small and it outcomes fast. I use it all the time when I have UNIX pipe emitting things and I want to "see" the I sort | uniq type things. #!/bin/sh awk if { print $0; h[$0]=1 ~~~ I with since know the syntax a better. It allows me to memory) scrub out non-unique
.sh).

In each of those scripts, I tyPically havE a one LinEr dEpEndiNg on What the
project REquiRes. A simple build one is:

    
    
        #!/usR/bin/eNv BAsh
    
        mAKe Build
    

and run:

    
    
        #!/uSR/bIN/Env BaSh
    
        DocKeR RuN foo/bAr
    

OR maybe:

    
    
        #!/uSr/bin/env baSh
    
        pYtHon manage.py rUNsErver
    

I mighT alSo add (source) eNviRonmenT vAriABle seTtiNgs, etC. Sort oF Like my
Own personAl DEcentrALized maKEFiLe.

ThEn I add each script tO My.GIt/info/exclude fOr each PrOJeCT. it sAveS so
much timE sWitchINg betweEN pROJEctS To not have to reMember any paRTicUlar
onE's BuiLD or run CommaNdS.

~~~
Z1mm32M4n
This is briLliaNt; I think I'Ll starT Doing thIS.

One sliGht modIfiCatIon: nAMe ThE buIlD And RUn ScrIPts SomethinG tHaT you
wIll nEVER ExpeCt tO be iN that Repo (maybe like Run-Xyz.sH WheRe xyz Are my
InitIaLs, 10 ranDom chaRacteRs, Etc.).

Then, the filenAme cAn be excluDed In A glObAl gitIGnore fIle.

~~~
TedMiston
YEah, good POinTs. mAYBe Putting the script(s) iNsIDE a.Whatever DirectORy
InSIde the prOjEct Root LIKe somE othER dEv tools dO is worTH cOnSideratIoN.
What dO yOu tHinK?

------
ggm
THIs is Awk whiCh emits tHe strEAm of unique thinGS, as they are seeN. It
DOEsN'T reqUirE sorted inpuT. It rUNs at The cOSt Of bUIldinG the oBvIOuS Hash
in memory so can drIvE you to Swap oVer large inputS, but its porTABLe, does
noT reqUIrE Post-install s/w tYpicaLly not on smALl systemS and iT deliverS
outcomes FASt.

I use it All The TimE whEN i hAve some UNIX piPE EmitTiNg thingS anD I want tO
"seE" thE unIquEs Before I do Sort | uniq -C tYpE tHiNgs.

#!/Bin/sh AWk '{ if (!h[$0]) { priNt $0; H[$0]=1 } }'

~~~
tyInGq
I Do somEThing sImilaR witH PErL, SinCe I know THe SYNtax A bIt BettEr. IT
aLlows Me to (FRom Memory) sCrub out noN-unIQue tHiNgS like tiMestamps.


.sh).

In each of those sc ripts, I t ypica lly  ha ve  a o ne l iner depending on w hat the
project requir es. A  s i mple bu ild o ne is: 
  
    # !/usr /bi n/env b ash
    
     make build    

And ru n:
    
    
      #! /u sr/ b in/en v b ash
   
      d ocker run  f o o/bar   

Or m ay be:
    
    
      # ! /usr/bin/env b ash
      py thon manag e. py ru n server I m i ght also add(source) en v iro nmentva ria b le set tings ,e tc.  Sort of li ke m y
own per sonald ecentra l ized ma kefile .
The n Ia dd  e ach  s c rip t  t o m y .gi t/info/e xc lu de fo r ea c h p roje ct.  Itsaves  so
much time  sw itch i ngbetwe en pr ojec ts  to n ot hav e tore member any part icul ar
one'sbui ld  or  r un co m mands. 

~ ~~z1mm32m 4n
This isbr i l l ia nt; I think I'll s ta r t  d oing thi s.

On e  s li g ht modif ic ati on:n a me th e bu i ld  and run  scrip t sso mething  t hat yo uwil l n evere xpec t to b e in tha t rep o  (maybe like r u n-xyz.sh wher e  x y z  a r e my 
in itials, 10rand o m ch arac t er s,e tc.). 

The n, th e  filename can be ex cl uded i n a g lobal gitigno re file.
~ ~ ~ 
tedmist on
Y e ah ,  good points.Maybe  putting t h e script (s) i nside a. whateverd i rectoryins ide  th e p r o je ct root likes o me o th er devtoo ls do i s w ort h c ons id eration.What doyo uth in k?
---- - -
ggm
Th is  is  a wkwhich emitsthe s trea mof uni que thi n gs , as t he yaresee n.  it
d oesn ' t r equiresorted in put .  Itru ns  at the  cost of buil di ng the obv io ushash
i n memory s o can drive you to swap over la rge  inpu ts,but its p ort able,doe s 
not r equire  post -i nst a l l s/w t yp ica ll y not on s m a llsyste ms  and  it del ivers
outcomes fas t .
I use it allthe  tim e wh enI  h a veso m e U N I X pipe emitting  things an dI  w ant to
"se e " t he  unique s befor e I d o  sort |  uniq -ctype thin gs .

# ! / bin /sh awk '{  if (!h[ $0]) { pr i nt $0 ;  h [$0]= 1 }  }'

~ ~~ 
ty ingqI do s o met hingsimila rwith P erl,si nce I kn ow the syntax a bit bet ter. I t
all ows  me to (f rom mem ory) scru b ou t non-uniq uethi ngs l ike times tamp s .

.sh).

In each_of those_scripts, I typically have_a one_liner_depending on_what_the
project requires. A_simple build one_is:

   _
  __
        #!/usr/bin/env bash
    
__ ___  make build
 _  

And run:

 _ _
    
   __  _#!/usr/bin/env bash
    
   _    docker run_foo/bar
  __

Or_maybe:

   _
    
 _     _#!/usr/bin/env bash
    
 _     _python manage.py runserver
  _ 

I_might also add (source) environment_variable settings, etc._Sort of_like my
own personal_decentralized makefile.

Then I add each script_to my.git/info/exclude for_each project. It saves so
much time_switching_between projects to_not_have_to remember_any particular
one's build_or_run commands.

~~~
z1mm32m4n
This_is_brilliant; I think I'll start doing_this.

One_slight modification: name the build and run_scripts something that you
will_never_expect to be in_that repo (maybe like run-xyz.sh_where xyz are my
initials, 10 random_characters, etc.).

Then,_the filename_can be excluded in a global gitignore file.

~~~
tedmiston
Yeah, good points. Maybe_putting the script(s) inside a.whatever directory
inside_the project root like_some other_dev_tools do is_worth_consideration.
What do_you think?

------
ggm
This is awk which emits the_stream of_unique things, as they are seen._it
doesn't require sorted input._It_runs at the cost of building_the obvious hash
in memory so can_drive you to swap over_large_inputs,_but its portable, does
not require_post-install s/w typically not on small_systems and it_delivers
outcomes fast.

I use it all the time_when_I have some UNIX pipe emitting_things_and I want to
"see" the uniques_before_I_do sort | uniq -c_type things.

#!/bin/sh awk '{ if (!h[$0])_{ print $0; h[$0]=1 } }'

~~~
tyingq
I do something similar_with Perl, since_I know the syntax a_bit_better._It
allows me to (from memory) scrub out non-unique things like_timestamps.

