Problems with Go Get

Yes, you absolutely could. You wouldn't even need to fork the dependencies.

Take a look at https://github.com/skelterjohn/wgo - it's vendoring in a way that 'go build' (and 'go get') still work :)

Yes, I know about GNU make. The point is not GNU make, the point is needing to find out how to install third-party program on my OS of choice to build an app that should be as easy as "go build" because of the Programming Language used.

Maybe once that new fancy OneGet is on Windows (and maybe even becomes as good as brew looks on OSX, which I've never used) it will no longer bother me.

I really like the OP's structure and makefile, but it looks like a pain to work against Golang's grain here, even though the methodology makes a lot more sense to me.

Maybe I have misunderstood the documentation, but what I truly, truly don't get about Go's $GOPATH is that it wants (1) my project directory to have some kind of canonical path, and (2) to pollute my project directory with dependencies. I have done a bunch of Go development and I still don't get it.

So for example, I have myproject, which I naturally want to organize in this way:

    $HOME
      Projects
        foo
          .git
          src
            main.go
            stuff.go
          assets
            photo.png
            something.xml
          scripts
            setup_database.sh
          config
            config.sample.json
          Dockerfile
          Makefile

Go wants me to throw this away and structure it like this:

    $HOME
      go
        bin
          [...]
        src
          github.com
            BurntSushi
              toml
                [...]
            zenazn
              goji
                [...]
            myaccount
              myproject
                .git
                main.go
                stuff.go
                assets
                  photo.png
                  something.xml
                scripts
                  setup_database.sh
                config
                  config.sample.json
                Dockerfile
                Makefile

I'm supposed to work within this jungle of dependencies and generated files, in the middle of which sits my project. At least Java, for all its many faults, has the good sense to let you store dependencies nested as JAR files in a subfolder, as opposed to turning your own project into a dependency.

I have tried fixing this by symlinking my project into $GOPATH/src/whatever, but Go doesn't let me to run "go" commands on things outside the $GOPATH, which makes this rather painful to do in a shell.

Adding to the general confusion, Go doesn't manage canonical package paths, so github.com/zenazn/goji/main.go is in the package "goji" and github.com/zenazn/goji/graceful/[asterisk].go are in the package "graceful", but those package names only mean something to the importer. When "goji" wants to use the package "graceful", it imports "github.com/zenazn/goji/graceful", which, being a full URL, must be resolved from a root folder in GOPATH/src.

At least Java (for all its... etc.) had the good sense to make dotted package names mirror the folder structure of a project, not URL, thus being internally consistent. Go wants everything to live in the same sea of things. Vendoring is just half the problem.

At work we have a monolithic repo containing Java, Go, Python, etc, organized like this:

  Java //src/com/yext/..     
  Go   //gocode/src/yext/...

GOPATH is set //gocode. .gitignore allows us to track only our code under the GOPATH using this snippet:

  /gocode/bin/
  /gocode/pkg/
  /gocode/src/*/
  !/gocode/src/yext/

We use glock[1] to sync dependencies across the team, without having to check them in.

The whole thing works very well at 50 developers and ~100 dependencies.

[1] https://github.com/robfig/glock