├── 2shortplanks └── main.go ├── Ch3ck └── main.go ├── LICENSE ├── PumpkinSeed └── main.go ├── README.md ├── SJC └── main.go ├── ShortJohn └── main.go ├── Southclaws └── main.go ├── SpeedyCoder └── main.go ├── aashishkarki └── main.go ├── abdul └── main.go ├── abhi-go └── main.go ├── acabanas └── main.go ├── adamkisala └── main.go ├── adamo └── main.go ├── adamryman └── main.go ├── alex1x └── main.go ├── aman └── main.go ├── andrestc └── main.go ├── andybons ├── another-file.txt ├── cat.txt ├── coffee.txt ├── gopher.txt ├── hello.txt └── quotes.txt ├── anton-vorobiev └── main.go ├── apatzer99 └── main.go ├── arl └── main.go ├── arudd └── main.go ├── aschlesener └── main.go ├── asgaines └── main.go ├── audrey └── main.go ├── avelino └── main.go ├── baylee └── main.go ├── bdowns └── main.go ├── bflad └── main.go ├── bflanigan └── main.go ├── blainsmith └── main.go ├── bmoix └── main.go ├── bogdanjsx └── main.go ├── bontequero └── main.go ├── bracewell └── testing.txt ├── brainsnail └── main.go ├── brandondyck └── main.go ├── bschoch └── main.go ├── btracey └── main.go ├── buro9 └── main.go ├── calerogers └── hello.go ├── calvinbehling └── main.go ├── calvn └── main.go ├── carlisia ├── hello.txt └── main.go ├── carmen └── main.go ├── cassandraoid └── main.go ├── cbro └── main.go ├── cherry ├── codesign.go ├── testtiming │ ├── go.mod │ ├── go.sum │ └── luci.go └── wasmtest │ ├── go.mod │ ├── go.sum │ ├── testprog │ └── x.go │ └── w.go ├── chimeracoder └── main.go ├── cixel └── main.go ├── clairew └── main.go ├── cmcguinness └── main.go ├── codyoss └── main.go ├── conradwt └── main.go ├── corylanou └── main.go ├── cpallares └── main.go ├── csduarte └── main.go ├── cyacco └── main.go ├── danicat └── main.go ├── danmrichards └── main.go ├── dark5un └── main.go ├── darron └── main.go ├── davidgood └── main.go ├── davidsbond └── main.go ├── dechensherpa └── main.go ├── delioda └── main.go ├── dertseha └── main.go ├── devalshah88 └── main.go ├── dfinkel └── main.go ├── dgrmsh └── main.go ├── dicaormu └── main.go ├── dirbaio └── main.go ├── dlsniper └── main.go ├── doc.go ├── domgreen └── main.go ├── draina └── main.go ├── drewvanstone └── main.go ├── drichelson └── main.go ├── dtimm └── main.go ├── emasatsugu └── main.go ├── enocom └── main.go ├── epkann └── main.go ├── esellblah └── main.go ├── evanh └── main.go ├── fenos └── main.go ├── fexolm └── main.go ├── filippo └── github.txt ├── fmstephe └── main.go ├── frojasg └── main.go ├── fuzz └── main.go ├── gangleri └── main.go ├── garrmcnu └── main.go ├── gasteig └── main.go ├── gautamdey └── main.go ├── geototti21 └── main.go ├── ghchinoy └── main.go ├── ghoil └── main.go ├── gk └── main.go ├── gmarik └── main.go ├── gmichelo └── main.go ├── gonzaloserrano └── main.go ├── gopherbot ├── a.go └── b.go ├── goyalankit └── main.go ├── grantseltzer └── main.go ├── grepory └── main.go ├── gsg └── main.go ├── guyfedwards └── main.go ├── h0lyalg0rithm └── main.go ├── hakim ├── greeting.go └── main.go ├── hanwen └── test.txt ├── hawazine └── main.go ├── hearot └── main.go ├── herbie └── main.go ├── huadcu └── main.go ├── hugorut └── main.go ├── ianzapolsky └── main.go ├── iccha └── main.go ├── ilanpillemer └── main.go ├── iliasb └── main.go ├── irbekrm └── main.go ├── itch └── main.go ├── ivan3bx └── main.go ├── jackdbd └── main.go ├── jakobernik └── main.go ├── jamesfcarter └── main.go ├── jamiebarnett └── main.go ├── jaskamante └── main.go ├── jasonkeene └── main.go ├── jbd └── main.go ├── jboursiquot └── main.go ├── jcbwlkr └── main.go ├── jda └── main.go ├── jgimeno └── main.go ├── jhewes └── main.go ├── jkerr123 └── main.go ├── jlloyd └── main.go ├── jmaeso └── main.go ├── jms └── main.go ├── joanlopez └── main.go ├── joeshaw └── main.go ├── johnnyluo └── main.go ├── jonogould └── main.go ├── joshroppo └── main.go ├── jouderianjr └── main.go ├── jtblakeley └── main.go ├── jurgendecommer └── main.go ├── jwangsadinata └── main.go ├── jwilder └── main.go ├── kasperlewau └── main.go ├── katemanson └── main.go ├── kentakudo └── main.go ├── kevinburke └── main.go ├── kiivihal └── main.go ├── kinbiko └── main.go ├── kirooha └── main.go ├── ladydascalie └── main.go ├── lagimenez └── main.go ├── landonbjones └── main.go ├── laurenceusas └── main.go ├── leighcapili └── main.go ├── leighmcculloch └── main.go ├── liam └── main.go ├── light └── main.go ├── lineufelipe └── main.go ├── lizrice └── main.go ├── ljfranklin └── main.go ├── lucas └── main.go ├── ludweeg └── main.go ├── luigiDB └── main.go ├── lukmdo └── main.go ├── mabu └── main.go ├── maerf0x0 └── main.go ├── maitesin └── main.go ├── makhan └── main.go ├── manzan_46 └── main.go ├── marioarranzr └── main.go ├── martisch └── main.go ├── matloob └── main.go ├── matthewrudy └── main.go ├── matzhouse └── main.go ├── mayra-cabrera └── main.go ├── mbbroberg └── main.go ├── mchoube └── main.go ├── mdhender └── main.go ├── mec07 └── main.go ├── mennis └── main.go ├── merovius └── main.go ├── mfrw └── main.go ├── mgarton └── main.go ├── mh └── main.go ├── miguelbernadi └── main.go ├── mlasala └── main.go ├── mmcloughlin └── main.go ├── mohan08p └── main.go ├── morfeo8marc └── main.go ├── morrisio └── main.go ├── mperez └── main.go ├── msd └── main.go ├── msiggy └── main.go ├── myles-mcdonnell-package └── main.go ├── nathany ├── greeting.go └── greeting_test.go ├── nathj07 └── main.go ├── natx └── main.go ├── nd └── main.go ├── neilowen └── main.go ├── neosimsim └── main.go ├── nickng └── main.go ├── nikhita └── main.go ├── nlindblad └── main.go ├── nodo └── main.go ├── ordishs └── main.go ├── oskanberg └── main.go ├── ottogiron └── main.go ├── pamelin └── main.go ├── pbathala └── main.go ├── pbnjay └── main.go ├── pedrosland └── main.go ├── philpearl └── main.go ├── pierreprinetti └── main.go ├── pkch └── main.go ├── pmoroney └── main.go ├── prutswonder └── main.go ├── pteichman └── main.go ├── pwok └── main.go ├── r ├── greeting.go └── main.go ├── rabellamy └── main.go ├── ram535ii └── main.go ├── rautelap └── main.go ├── rhettg └── main.go ├── rkuska └── main.go ├── robHertz └── main.go ├── robbawebba └── main.go ├── robclap8 └── main.go ├── rogersimms └── main.go ├── rogpeppe └── main.go ├── ronang └── main.go ├── rowanf └── main.go ├── rprimus └── main.go ├── rrey └── main.go ├── rsc ├── greeting.go ├── hello └── main.go ├── sameer ├── greeting.go └── main.go ├── sandipb └── main.go ├── sauvaget └── main.go ├── sbramin └── main.go ├── sbuss └── main.go ├── scorphus └── main.go ├── senekis └── main.go ├── sepetrov └── main.go ├── seubert └── main.go ├── sfrancia └── main.go ├── shwsun └── main.go ├── skolodyazhnyy └── main.go ├── sm └── main.go ├── smoya └── main.go ├── srburnham └── main.go ├── sselph └── main.go ├── stanchan └── main.go ├── stegro └── main.go ├── steveazz └── main.go ├── sukrithanda └── main.go ├── suttonjesse └── main.go ├── telecoda └── main.go ├── telliott └── main.go ├── tengufromsky └── main.go ├── teodorst └── main.go ├── tessr └── main.go ├── tetff └── main.go ├── thanm ├── first.go ├── main.go └── second.go ├── thoeni └── main.go ├── tiago └── main.go ├── timburks └── main.go ├── tomasbasham └── main.go ├── tommie └── main.go ├── towerthousand └── main.go ├── vanesa └── main.go ├── vdemario └── main.go ├── venilnoronha └── main.go ├── vickiniu └── main.go ├── virtualsue └── asterisk.go ├── vishen └── main.go ├── vivaperu └── main.go ├── vsayer └── main.go ├── waits └── main.go ├── walkert └── main.go ├── wallyqs └── main.go ├── waltzofpearls └── main.go ├── wayneashleyberry └── main.go ├── weeellz └── main.go ├── wes └── main.go ├── wfernandes └── main.go ├── whill └── main.go ├── willmadison └── main.go ├── wrrn └── main.go ├── wselwood └── main.go ├── wvides └── main.go ├── xiam └── main.go ├── ymotongpoo └── main.go ├── zaquestion ├── main.go └── vendor │ └── github.com │ └── adamryman │ └── gophersay │ ├── LICENSE.md │ ├── gopher │ └── say.go │ └── gopherart │ ├── gopher.ascii │ └── gopherart.go └── zombispormedio └── main.go /2shortplanks/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Hello Gophercon UK 2019") 13 | } 14 | -------------------------------------------------------------------------------- /Ch3ck/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Ch3ck command states its opinion on containers. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("containers rule!") 12 | } 13 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2009 The Go Authors. 2 | 3 | Redistribution and use in source and binary forms, with or without 4 | modification, are permitted provided that the following conditions are 5 | met: 6 | 7 | * Redistributions of source code must retain the above copyright 8 | notice, this list of conditions and the following disclaimer. 9 | * Redistributions in binary form must reproduce the above 10 | copyright notice, this list of conditions and the following disclaimer 11 | in the documentation and/or other materials provided with the 12 | distribution. 13 | * Neither the name of Google LLC nor the names of its 14 | contributors may be used to endorse or promote products derived from 15 | this software without specific prior written permission. 16 | 17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 | -------------------------------------------------------------------------------- /PumpkinSeed/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Scratch Repository 2 | 3 | This repository is mainly for use by people learning how to use Gerrit and 4 | contribute to Go. 5 | 6 | [Click here for a tutorial][gophercon-tutorial] on how to get started with a 7 | contribution to this repository. 8 | 9 | A fuller, text-based tutorial based around the [core Go project can be found 10 | here][core-go-tutorial]. 11 | 12 | ## What should I add? 13 | 14 | Add a folder with your username, and put a main function in there. You can 15 | put whatever you want in your main function; see the existing directories for 16 | examples. 17 | 18 | All files should have the standard licensing header, and add appropriate 19 | documentation see the other files in this repository for an example. 20 | 21 | ## Notes about Gerrit 22 | 23 | If you have needed to change a Github pull request, you probably just added a 24 | second commit with the requested changes and pushed it. By contrast, all changes 25 | opened in Gerrit are a single commit, which means you need to [amend your 26 | commit][amend] if the reviewer requests feedback. 27 | 28 | [amend]: http://www.joinfu.com/2013/06/pushing-revisions-to-a-gerrit-code-review/ 29 | 30 | To amend a previous commit, run `git add (list of files you changed)` to add 31 | your changes, then run `git commit --amend` to amend the commit to add new 32 | data. Your commit message should still summarize the entire commit ("Add 33 | kevinburke/main.go"), not just the change a reviewer asked for ("Fix typo"). 34 | 35 | After you amend the commit, re-run `git codereview mail` to push that change 36 | to the server. Then in the Gerrit UI, find the in-line comments left by your 37 | reviewer, click "Done", go back to the main PR page, and click "Reply" => "Send" 38 | to tell your reviewer that you've addressed your feedback. 39 | 40 | Once you get a "Code-Review: +2" from a Go contributor, your change will be 41 | merged! 42 | 43 | ## Need help? 44 | 45 | Gerrit is not easy to get started with, and we want to help you out. If you are 46 | having trouble with Gerrit, contact the [golang-devexp][devexp] mailing list for 47 | help! 48 | 49 | [gophercon-tutorial]: https://golang.org/s/gophercon2017 50 | [core-go-tutorial]: https://golang.org/doc/contribute.html 51 | [devexp]: https://groups.google.com/forum/#!forum/golang-devexp 52 | -------------------------------------------------------------------------------- /SJC/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /ShortJohn/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /Southclaws/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Southclaws says hello!") 11 | } 12 | -------------------------------------------------------------------------------- /SpeedyCoder/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /aashishkarki/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hey there! This is Aashish!") 11 | } 12 | -------------------------------------------------------------------------------- /abdul/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello world!") 11 | } 12 | -------------------------------------------------------------------------------- /abhi-go/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Awesome GO!!!") 11 | fmt.Println("Awesome GO workshop!!!") 12 | } 13 | -------------------------------------------------------------------------------- /acabanas/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("who even needs fmt?") 13 | } 14 | -------------------------------------------------------------------------------- /adamkisala/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Gophercon is awesome!!! (btw Ioannis love PHP)") 11 | } 12 | -------------------------------------------------------------------------------- /adamo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /adamryman/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { grave := string(96); print(p, grave, p, grave, "\n") } 8 | 9 | const p = `// Copyright 2018 The Go Authors. All rights reserved. 10 | // Use of this source code is governed by a BSD-style 11 | // license that can be found in the LICENSE file. 12 | 13 | package main 14 | 15 | func main() { grave := string(96); print(p, grave, p, grave, "\n") } 16 | 17 | const p = ` 18 | -------------------------------------------------------------------------------- /alex1x/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /aman/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("containers rule!") 11 | 12 | } 13 | -------------------------------------------------------------------------------- /andrestc/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("tsuru.io rules a lot!") 11 | } 12 | -------------------------------------------------------------------------------- /andybons/another-file.txt: -------------------------------------------------------------------------------- 1 | this is another file that is cool. 2 | it has very important text in it. 3 | super important text. 4 | -------------------------------------------------------------------------------- /andybons/cat.txt: -------------------------------------------------------------------------------- 1 | ( \ 2 | \ \ 3 | / / |\\ 4 | / / .-`````-. / ^`-. 5 | \ \ / \_/ {|} `o 6 | \ \ / .---. \\ _ ,--' 7 | \ \/ / \, \( `^^^ 8 | \ \/\ (\ ) 9 | \ ) \ ) \ \ 10 | jgs ) /__ \__ ) (\ \___ 11 | (___)))__))(__))(__))) 12 | -------------------------------------------------------------------------------- /andybons/coffee.txt: -------------------------------------------------------------------------------- 1 | { 2 | { } 3 | }_{ __{ 4 | .-{ } }-. 5 | ( } { ) 6 | |`-.._____..-'| 7 | | ;--. 8 | | (__ \ 9 | | | ) ) 10 | | |/ / 11 | | / / -Felix Lee- 12 | | ( / 13 | \ y' 14 | `-.._____..-' 15 | -------------------------------------------------------------------------------- /andybons/gopher.txt: -------------------------------------------------------------------------------- 1 | := <-- it’s a gopher! 2 | That's not a gopher, this is a Gopher: https://golang.org/doc/gopher/frontpage.png 3 | -------------------------------------------------------------------------------- /andybons/hello.txt: -------------------------------------------------------------------------------- 1 | Hello, Gophers! How are you!? 2 | -------------------------------------------------------------------------------- /andybons/quotes.txt: -------------------------------------------------------------------------------- 1 | “The two most important days in your life are the day you are born and the day you find out why.” 2 | “Computers are useless. They can only give you answers.” Pablo Picasso 3 | “You're missing the point Morty. Why would he drive a smaller toaster with wheels? I mean, does your car look like a smaller version of your house? No.” Rick Sanchez 4 | “No, this is Patrick.” Patrick Starr 5 | -------------------------------------------------------------------------------- /anton-vorobiev/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("fmt FTW !!!11") 11 | } 12 | -------------------------------------------------------------------------------- /apatzer99/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello world!") 11 | } 12 | -------------------------------------------------------------------------------- /arl/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /arudd/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /aschlesener/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The aschlesener command prints something amazing. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("my first Go contribution :D") 12 | } 13 | -------------------------------------------------------------------------------- /asgaines/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Print(` 11 | ____ ___ 12 | / ___|/ _ \ 13 | | | _| | | | 14 | | |_| | |_| | 15 | \____|\___/ 16 | 17 | ! 18 | ,_---~~~~~----._ 19 | _,,_,*^____ _____''*g*\"*, 20 | / __/ /' ^. / \ ^@q f 21 | [ @f | @)) | | @)) l 0 _/ 22 | \'/ \~____ / __ \_____/ \ 23 | | _l__l_ I 24 | } [______] I 25 | ] | | | | 26 | ] ~ ~ | 27 | | | 28 | | | 29 | 30 | Credit: https://gist.github.com/belbomemo/b5e7dad10fa567a5fe8a 31 | `) 32 | } 33 | -------------------------------------------------------------------------------- /audrey/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello audrey amend commit") 11 | } 12 | -------------------------------------------------------------------------------- /avelino/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Avelino add initial contribute") 11 | } 12 | -------------------------------------------------------------------------------- /baylee/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("baylee is the master of the universe!") 11 | } 12 | -------------------------------------------------------------------------------- /bdowns/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("😊") 11 | } 12 | -------------------------------------------------------------------------------- /bflad/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /bflanigan/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Thank you Go team for helping me to get my job done faster!") 11 | } 12 | -------------------------------------------------------------------------------- /blainsmith/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 Google Inc. All rights reserved. 2 | // Use of this source code is governed by the Apache 2.0 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println(`\m/`) 11 | } 12 | -------------------------------------------------------------------------------- /bmoix/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, gophers :)") 11 | } 12 | -------------------------------------------------------------------------------- /bogdanjsx/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /bontequero/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | println("Go is awesome") 9 | } 10 | -------------------------------------------------------------------------------- /bracewell/testing.txt: -------------------------------------------------------------------------------- 1 | nope 2 | -------------------------------------------------------------------------------- /brainsnail/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Now it's really happening.") 11 | } 12 | -------------------------------------------------------------------------------- /brandondyck/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hey.") 11 | } 12 | -------------------------------------------------------------------------------- /bschoch/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2010 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello") 11 | } 12 | -------------------------------------------------------------------------------- /btracey/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, Brad!") 11 | } 12 | -------------------------------------------------------------------------------- /buro9/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /calerogers/hello.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello Go team!") 11 | fmt.Println("P.S. Thanks for an awesome first Gophercon! ") 12 | } 13 | -------------------------------------------------------------------------------- /calvinbehling/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Testing go contrib at gophercon! 6 | // This file is a "Hello, World" for code review 7 | package main 8 | 9 | import "fmt" 10 | 11 | func main() { 12 | fmt.Println("this is the year of linux on the _laptop_!") 13 | } 14 | -------------------------------------------------------------------------------- /calvn/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello go!") 11 | } 12 | -------------------------------------------------------------------------------- /carlisia/hello.txt: -------------------------------------------------------------------------------- 1 | Good morning! -------------------------------------------------------------------------------- /carlisia/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | const greeting = "Today is a great day!" 9 | 10 | func main() { 11 | fmt.Println("What's happening?", greeting) 12 | } 13 | -------------------------------------------------------------------------------- /carmen/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("WASSUP NERDS") 11 | } 12 | -------------------------------------------------------------------------------- /cassandraoid/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("holy crap, contributing is freaking awesome!") 11 | } 12 | -------------------------------------------------------------------------------- /cbro/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Print(` 11 | ____ ___ 12 | / ___|/ _ \ 13 | | | _| | | | 14 | | |_| | |_| | 15 | \____|\___/ 16 | 17 | ,_---~~~~~----._ 18 | _,,_,*^____ _____''*g*\"*, 19 | / __/ /' ^. / \ ^@q f 20 | [ @f | @)) | | @)) l 0 _/ 21 | \'/ \~____ / __ \_____/ \ 22 | | _l__l_ I 23 | } [______] I 24 | ] | | | | 25 | ] ~ ~ | 26 | | | 27 | | | 28 | 29 | Credit: https://gist.github.com/belbomemo/b5e7dad10fa567a5fe8a 30 | `) 31 | } 32 | -------------------------------------------------------------------------------- /cherry/codesign.go: -------------------------------------------------------------------------------- 1 | // Copyright 2020 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This programs does ad-hoc code signing fo Mach-O files. 6 | // It tries to do what darwin linker does. 7 | 8 | package main 9 | 10 | import ( 11 | "crypto/sha256" 12 | "debug/macho" 13 | "encoding/binary" 14 | "fmt" 15 | "io" 16 | "os" 17 | "unsafe" 18 | ) 19 | 20 | const ( 21 | pageSizeBits = 12 22 | pageSize = 1 << pageSizeBits 23 | ) 24 | 25 | const LC_CODE_SIGNATURE = 0x1d 26 | 27 | const fileHeaderSize64 = 8 * 4 28 | 29 | const ( 30 | CSMAGIC_REQUIREMENT = 0xfade0c00 // single Requirement blob 31 | CSMAGIC_REQUIREMENTS = 0xfade0c01 // Requirements vector (internal requirements) 32 | CSMAGIC_CODEDIRECTORY = 0xfade0c02 // CodeDirectory blob 33 | CSMAGIC_EMBEDDED_SIGNATURE = 0xfade0cc0 // embedded form of signature data 34 | CSMAGIC_DETACHED_SIGNATURE = 0xfade0cc1 // multi-arch collection of embedded signatures 35 | 36 | CSSLOT_CODEDIRECTORY = 0 // slot index for CodeDirectory 37 | ) 38 | 39 | const ( 40 | kSecCodeSignatureNoHash = 0 // null value 41 | kSecCodeSignatureHashSHA1 = 1 // SHA-1 42 | kSecCodeSignatureHashSHA256 = 2 // SHA-256 43 | kSecCodeSignatureHashSHA256Truncated = 3 // SHA-256 truncated to first 20 bytes 44 | kSecCodeSignatureHashSHA384 = 4 // SHA-384 45 | kSecCodeSignatureHashSHA512 = 5 // SHA-512 46 | ) 47 | 48 | const ( 49 | CS_EXECSEG_MAIN_BINARY = 0x1 // executable segment denotes main binary 50 | CS_EXECSEG_ALLOW_UNSIGNED = 0x10 // allow unsigned pages (for debugging) 51 | CS_EXECSEG_DEBUGGER = 0x20 // main binary is debugger 52 | CS_EXECSEG_JIT = 0x40 // JIT enabled 53 | CS_EXECSEG_SKIP_LV = 0x80 // skip library validation 54 | CS_EXECSEG_CAN_LOAD_CDHASH = 0x100 // can bless cdhash for execution 55 | CS_EXECSEG_CAN_EXEC_CDHASH = 0x200 // can execute blessed cdhash 56 | ) 57 | 58 | type Blob struct { 59 | typ uint32 // type of entry 60 | offset uint32 // offset of entry 61 | // data follows 62 | } 63 | 64 | func (b *Blob) put(out []byte) []byte { 65 | out = put32be(out, b.typ) 66 | out = put32be(out, b.offset) 67 | return out 68 | } 69 | 70 | type SuperBlob struct { 71 | magic uint32 // magic number 72 | length uint32 // total length of SuperBlob 73 | count uint32 // number of index entries following 74 | // blobs []Blob 75 | } 76 | 77 | func (s *SuperBlob) put(out []byte) []byte { 78 | out = put32be(out, s.magic) 79 | out = put32be(out, s.length) 80 | out = put32be(out, s.count) 81 | return out 82 | } 83 | 84 | type CodeDirectory struct { 85 | magic uint32 // magic number (CSMAGIC_CODEDIRECTORY) 86 | length uint32 // total length of CodeDirectory blob 87 | version uint32 // compatibility version 88 | flags uint32 // setup and mode flags 89 | hashOffset uint32 // offset of hash slot element at index zero 90 | identOffset uint32 // offset of identifier string 91 | nSpecialSlots uint32 // number of special hash slots 92 | nCodeSlots uint32 // number of ordinary (code) hash slots 93 | codeLimit uint32 // limit to main image signature range 94 | hashSize uint8 // size of each hash in bytes 95 | hashType uint8 // type of hash (cdHashType* constants) 96 | _pad1 uint8 // unused (must be zero) 97 | pageSize uint8 // log2(page size in bytes); 0 => infinite 98 | _pad2 uint32 // unused (must be zero) 99 | scatterOffset uint32 100 | teamOffset uint32 101 | _pad3 uint32 102 | codeLimit64 uint64 103 | execSegBase uint64 104 | execSegLimit uint64 105 | execSegFlags uint64 106 | // data follows 107 | } 108 | 109 | func (c *CodeDirectory) put(out []byte) []byte { 110 | out = put32be(out, c.magic) 111 | out = put32be(out, c.length) 112 | out = put32be(out, c.version) 113 | out = put32be(out, c.flags) 114 | out = put32be(out, c.hashOffset) 115 | out = put32be(out, c.identOffset) 116 | out = put32be(out, c.nSpecialSlots) 117 | out = put32be(out, c.nCodeSlots) 118 | out = put32be(out, c.codeLimit) 119 | out = put8(out, c.hashSize) 120 | out = put8(out, c.hashType) 121 | out = put8(out, c._pad1) 122 | out = put8(out, c.pageSize) 123 | out = put32be(out, c._pad2) 124 | out = put32be(out, c.scatterOffset) 125 | out = put32be(out, c.teamOffset) 126 | out = put32be(out, c._pad3) 127 | out = put64be(out, c.codeLimit64) 128 | out = put64be(out, c.execSegBase) 129 | out = put64be(out, c.execSegLimit) 130 | out = put64be(out, c.execSegFlags) 131 | return out 132 | } 133 | 134 | type linkeditDataCmd struct { 135 | cmd uint32 136 | cmdsize uint32 // sizeof(struct linkedit_data_command) 137 | dataoff uint32 // file offset of data in __LINKEDIT segment 138 | datasize uint32 // file size of data in __LINKEDIT segment 139 | } 140 | 141 | func (l *linkeditDataCmd) put(out []byte) []byte { 142 | // load command is little endian 143 | out = put32le(out, l.cmd) 144 | out = put32le(out, l.cmdsize) 145 | out = put32le(out, l.dataoff) 146 | out = put32le(out, l.datasize) 147 | return out 148 | } 149 | 150 | func get32le(b []byte) uint32 { return binary.LittleEndian.Uint32(b) } 151 | func put32le(b []byte, x uint32) []byte { binary.LittleEndian.PutUint32(b, x); return b[4:] } 152 | func put32be(b []byte, x uint32) []byte { binary.BigEndian.PutUint32(b, x); return b[4:] } 153 | func put64le(b []byte, x uint64) []byte { binary.LittleEndian.PutUint64(b, x); return b[8:] } 154 | func put64be(b []byte, x uint64) []byte { binary.BigEndian.PutUint64(b, x); return b[8:] } 155 | func put8(b []byte, x uint8) []byte { b[0] = x; return b[1:] } 156 | func puts(b, s []byte) []byte { n := copy(b, s); return b[n:] } 157 | 158 | // round x up to a multiple of n. n must be a power of 2. 159 | func roundUp(x, n int) int { return (x + n - 1) &^ (n - 1) } 160 | 161 | const verbose = false 162 | 163 | func main() { 164 | if len(os.Args) != 2 { 165 | fmt.Println("usage: codesign ") 166 | os.Exit(1) 167 | } 168 | 169 | fname := os.Args[1] 170 | f, err := os.OpenFile(fname, os.O_RDWR, 0) 171 | if err != nil { 172 | panic(err) 173 | } 174 | defer f.Close() 175 | 176 | mf, err := macho.NewFile(f) 177 | if err != nil { 178 | panic(err) 179 | } 180 | if mf.Magic != macho.Magic64 { 181 | panic("not 64-bit") 182 | } 183 | if mf.ByteOrder != binary.LittleEndian { 184 | panic("not little endian") 185 | } 186 | 187 | // find existing LC_CODE_SIGNATURE and __LINKEDIT segment 188 | var sigOff, sigSz, linkeditOff int 189 | var linkeditSeg, textSeg *macho.Segment 190 | loadOff := fileHeaderSize64 191 | for _, l := range mf.Loads { 192 | data := l.Raw() 193 | cmd, sz := get32le(data), get32le(data[4:]) 194 | if cmd == LC_CODE_SIGNATURE { 195 | sigOff = int(get32le(data[8:])) 196 | sigSz = int(get32le(data[12:])) 197 | } 198 | if seg, ok := l.(*macho.Segment); ok { 199 | switch seg.Name { 200 | case "__LINKEDIT": 201 | linkeditSeg = seg 202 | linkeditOff = loadOff 203 | case "__TEXT": 204 | textSeg = seg 205 | } 206 | } 207 | loadOff += int(sz) 208 | } 209 | 210 | if sigOff == 0 { 211 | st, err := f.Stat() 212 | if err != nil { 213 | panic(err) 214 | } 215 | sigOff = int(st.Size()) 216 | sigOff = roundUp(sigOff, 16) // round up to 16 bytes ??? 217 | err = f.Truncate(int64(sigOff)) 218 | if err != nil { 219 | panic(err) 220 | } 221 | } 222 | 223 | // compute sizes 224 | id := "a.out\000" 225 | nhashes := (sigOff + pageSize - 1) / pageSize 226 | idOff := int(unsafe.Sizeof(CodeDirectory{})) 227 | hashOff := idOff + len(id) 228 | cdirSz := hashOff + nhashes*sha256.Size 229 | sz := int(unsafe.Sizeof(SuperBlob{})+unsafe.Sizeof(Blob{})) + cdirSz 230 | if sigSz != 0 && sz != sigSz { 231 | println(sz, sigSz) 232 | panic("LC_CODE_SIGNATURE exists but with a different size. already signed?") 233 | } 234 | 235 | if sigSz == 0 { // LC_CODE_SIGNATURE does not exist. Add one. 236 | csCmdSz := int(unsafe.Sizeof(linkeditDataCmd{})) 237 | csCmd := linkeditDataCmd{ 238 | cmd: LC_CODE_SIGNATURE, 239 | cmdsize: uint32(csCmdSz), 240 | dataoff: uint32(sigOff), 241 | datasize: uint32(sz), 242 | } 243 | if loadOff+csCmdSz > int(mf.Sections[0].Offset) { 244 | panic("no space for adding LC_CODE_SIGNATURE") 245 | } 246 | out := make([]byte, csCmdSz) 247 | csCmd.put(out) 248 | _, err = f.WriteAt(out, int64(loadOff)) 249 | if err != nil { 250 | panic(err) 251 | } 252 | 253 | // fix up header: update Ncmd and Cmdsz 254 | var tmp [8]byte 255 | put32le(tmp[:4], mf.FileHeader.Ncmd+1) 256 | _, err = f.WriteAt(tmp[:4], int64(unsafe.Offsetof(mf.FileHeader.Ncmd))) 257 | if err != nil { 258 | panic(err) 259 | } 260 | put32le(tmp[:4], mf.FileHeader.Cmdsz+uint32(csCmdSz)) 261 | _, err = f.WriteAt(tmp[:4], int64(unsafe.Offsetof(mf.FileHeader.Cmdsz))) 262 | if err != nil { 263 | panic(err) 264 | } 265 | 266 | // fix up LINKEDIT segment: update Memsz and Filesz 267 | segSz := sigOff + sz - int(linkeditSeg.Offset) 268 | put64le(tmp[:8], uint64(roundUp(segSz, 0x4000))) // round up to physical page size 269 | _, err = f.WriteAt(tmp[:8], int64(linkeditOff)+int64(unsafe.Offsetof(macho.Segment64{}.Memsz))) 270 | if err != nil { 271 | panic(err) 272 | } 273 | put64le(tmp[:8], uint64(segSz)) 274 | _, err = f.WriteAt(tmp[:8], int64(linkeditOff)+int64(unsafe.Offsetof(macho.Segment64{}.Filesz))) 275 | if err != nil { 276 | panic(err) 277 | } 278 | } 279 | 280 | // emit blob headers 281 | sb := SuperBlob{ 282 | magic: CSMAGIC_EMBEDDED_SIGNATURE, 283 | length: uint32(sz), 284 | count: 1, 285 | } 286 | blob := Blob{ 287 | typ: CSSLOT_CODEDIRECTORY, 288 | offset: uint32(unsafe.Sizeof(SuperBlob{}) + unsafe.Sizeof(Blob{})), 289 | } 290 | cdir := CodeDirectory{ 291 | magic: CSMAGIC_CODEDIRECTORY, 292 | length: uint32(sz) - uint32(unsafe.Sizeof(SuperBlob{})+unsafe.Sizeof(Blob{})), 293 | version: 0x20400, 294 | flags: 0x20002, // adhoc | linkerSigned 295 | hashOffset: uint32(hashOff), 296 | identOffset: uint32(idOff), 297 | nCodeSlots: uint32(nhashes), 298 | codeLimit: uint32(sigOff), 299 | hashSize: sha256.Size, 300 | hashType: kSecCodeSignatureHashSHA256, 301 | pageSize: uint8(pageSizeBits), 302 | execSegBase: textSeg.Offset, 303 | execSegLimit: textSeg.Filesz, 304 | } 305 | if mf.Type == macho.TypeExec { 306 | cdir.execSegFlags = CS_EXECSEG_MAIN_BINARY 307 | } 308 | 309 | out := make([]byte, sz) 310 | outp := out 311 | 312 | outp = sb.put(outp) 313 | outp = blob.put(outp) 314 | outp = cdir.put(outp) 315 | outp = puts(outp, []byte(id)) 316 | 317 | // emit hashes 318 | _, err = f.Seek(0, os.SEEK_SET) 319 | if err != nil { 320 | panic(err) 321 | } 322 | var buf [pageSize]byte 323 | fileOff := 0 324 | for fileOff < sigOff { 325 | n, err := io.ReadFull(f, buf[:]) 326 | if err == io.EOF { 327 | break 328 | } 329 | if err != nil && err != io.ErrUnexpectedEOF { 330 | panic(err) 331 | } 332 | if fileOff+n > sigOff { 333 | n = sigOff - fileOff 334 | } 335 | h := sha256.New() 336 | h.Write(buf[:n]) 337 | b := h.Sum(nil) 338 | outp = puts(outp, b[:]) 339 | fileOff += n 340 | } 341 | 342 | if verbose { 343 | for i := 0; i < len(out); i += 16 { 344 | end := i + 16 345 | if end > len(out) { 346 | end = len(out) 347 | } 348 | fmt.Printf("% x\n", out[i:end]) 349 | } 350 | } 351 | 352 | _, err = f.WriteAt(out, int64(sigOff)) 353 | if err != nil { 354 | panic(err) 355 | } 356 | } 357 | -------------------------------------------------------------------------------- /cherry/testtiming/go.mod: -------------------------------------------------------------------------------- 1 | module golang.org/x/scratch/cherry/testtiming 2 | 3 | go 1.22 4 | 5 | require ( 6 | go.chromium.org/luci v0.0.0-20240716011143-b5eb7a221b66 7 | golang.org/x/sync v0.7.0 8 | google.golang.org/protobuf v1.34.2 9 | ) 10 | 11 | require ( 12 | github.com/golang/mock v1.6.0 // indirect 13 | github.com/golang/protobuf v1.5.4 // indirect 14 | github.com/julienschmidt/httprouter v1.3.0 // indirect 15 | github.com/klauspost/compress v1.17.8 // indirect 16 | golang.org/x/net v0.23.0 // indirect 17 | golang.org/x/sys v0.18.0 // indirect 18 | golang.org/x/text v0.14.0 // indirect 19 | google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 // indirect 20 | google.golang.org/genproto/googleapis/api v0.0.0-20240213162025-012b6fc9bca9 // indirect 21 | google.golang.org/genproto/googleapis/rpc v0.0.0-20240213162025-012b6fc9bca9 // indirect 22 | google.golang.org/grpc v1.61.0 // indirect 23 | ) 24 | -------------------------------------------------------------------------------- /cherry/testtiming/go.sum: -------------------------------------------------------------------------------- 1 | github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= 2 | github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= 3 | github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= 4 | github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= 5 | github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= 6 | github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= 7 | github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g= 8 | github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k= 9 | github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= 10 | github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= 11 | github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U= 12 | github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= 13 | github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU= 14 | github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= 15 | github.com/smarty/assertions v1.15.1 h1:812oFiXI+G55vxsFf+8bIZ1ux30qtkdqzKbEFwyX3Tk= 16 | github.com/smarty/assertions v1.15.1/go.mod h1:yABtdzeQs6l1brC900WlRNwj6ZR55d7B+E8C6HtKdec= 17 | github.com/smartystreets/goconvey v1.8.1 h1:qGjIddxOk4grTu9JPOU31tVfq3cNdBlNa5sSznIX1xY= 18 | github.com/smartystreets/goconvey v1.8.1/go.mod h1:+/u4qLyY6x1jReYOp7GOM2FSt8aP9CzCZL03bI28W60= 19 | github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= 20 | go.chromium.org/luci v0.0.0-20240716011143-b5eb7a221b66 h1:7M08VAaHGjcRE9gonYdmvUL8PKKek9NUZ7mFSjZyJA4= 21 | go.chromium.org/luci v0.0.0-20240716011143-b5eb7a221b66/go.mod h1:VKWpjBb/iM+b62Tkkvb8Fs6bKxixITrPUpuImWvecvY= 22 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= 23 | golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= 24 | golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= 25 | golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= 26 | golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= 27 | golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= 28 | golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= 29 | golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= 30 | golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 31 | golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 32 | golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= 33 | golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= 34 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= 35 | golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 36 | golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 37 | golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 38 | golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 39 | golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= 40 | golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 41 | golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= 42 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= 43 | golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= 44 | golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= 45 | golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= 46 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= 47 | golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= 48 | golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= 49 | golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= 50 | golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= 51 | golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= 52 | google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9 h1:9+tzLLstTlPTRyJTh+ah5wIMsBW5c4tQwGTN3thOW9Y= 53 | google.golang.org/genproto v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:mqHbVIp48Muh7Ywss/AD6I5kNVKZMmAa/QEW58Gxp2s= 54 | google.golang.org/genproto/googleapis/api v0.0.0-20240213162025-012b6fc9bca9 h1:4++qSzdWBUy9/2x8L5KZgwZw+mjJZ2yDSCGMVM0YzRs= 55 | google.golang.org/genproto/googleapis/api v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:PVreiBMirk8ypES6aw9d4p6iiBNSIfZEBqr3UGoAi2E= 56 | google.golang.org/genproto/googleapis/rpc v0.0.0-20240213162025-012b6fc9bca9 h1:hZB7eLIaYlW9qXRfCq/qDaPdbeY3757uARz5Vvfv+cY= 57 | google.golang.org/genproto/googleapis/rpc v0.0.0-20240213162025-012b6fc9bca9/go.mod h1:YUWgXUFRPfoYK1IHMuxH5K6nPEXSCzIMljnQ59lLRCk= 58 | google.golang.org/grpc v1.61.0 h1:TOvOcuXn30kRao+gfcvsebNEa5iZIiLkisYEkf7R7o0= 59 | google.golang.org/grpc v1.61.0/go.mod h1:VUbo7IFqmF1QtCAstipjG0GIoq49KvMe9+h1jFLBNJs= 60 | google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= 61 | google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= 62 | -------------------------------------------------------------------------------- /cherry/testtiming/luci.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // An ad-hoc tool to query test timing data from LUCI. 6 | // 7 | // Output CSV with the following columns: 8 | // 9 | // commit hash, commit time, [builder,] status, pass duration, fail duration 10 | // 11 | // The "builder" column is omitted if only one builder 12 | // is queried (the -builder flag). 13 | package main 14 | 15 | import ( 16 | "context" 17 | "encoding/json" 18 | "flag" 19 | "fmt" 20 | "log" 21 | "net/http" 22 | "regexp" 23 | "slices" 24 | "strings" 25 | "time" 26 | 27 | bbpb "go.chromium.org/luci/buildbucket/proto" 28 | "go.chromium.org/luci/common/api/gitiles" 29 | gpb "go.chromium.org/luci/common/proto/gitiles" 30 | "go.chromium.org/luci/grpc/prpc" 31 | rdbpb "go.chromium.org/luci/resultdb/proto/v1" 32 | "golang.org/x/sync/errgroup" 33 | "google.golang.org/protobuf/types/known/fieldmaskpb" 34 | "google.golang.org/protobuf/types/known/timestamppb" 35 | ) 36 | 37 | const resultDBHost = "results.api.cr.dev" 38 | const crBuildBucketHost = "cr-buildbucket.appspot.com" 39 | const gitilesHost = "go.googlesource.com" 40 | 41 | // LUCIClient is a LUCI client. 42 | type LUCIClient struct { 43 | HTTPClient *http.Client 44 | GitilesClient gpb.GitilesClient 45 | BuildsClient bbpb.BuildsClient 46 | BuildersClient bbpb.BuildersClient 47 | ResultDBClient rdbpb.ResultDBClient 48 | 49 | // TraceSteps controls whether to log each step name as it's executed. 50 | TraceSteps bool 51 | 52 | nProc int 53 | } 54 | 55 | // NewLUCIClient creates a LUCI client. 56 | // nProc controls concurrency. NewLUCIClient panics if nProc is non-positive. 57 | func NewLUCIClient(nProc int) *LUCIClient { 58 | if nProc < 1 { 59 | panic(fmt.Errorf("nProc is %d, want 1 or higher", nProc)) 60 | } 61 | c := new(http.Client) 62 | gitilesClient, err := gitiles.NewRESTClient(c, gitilesHost, false) 63 | if err != nil { 64 | log.Fatal(err) 65 | } 66 | buildsClient := bbpb.NewBuildsClient(&prpc.Client{ 67 | C: c, 68 | Host: crBuildBucketHost, 69 | }) 70 | buildersClient := bbpb.NewBuildersClient(&prpc.Client{ 71 | C: c, 72 | Host: crBuildBucketHost, 73 | }) 74 | resultDBClient := rdbpb.NewResultDBClient(&prpc.Client{ 75 | C: c, 76 | Host: resultDBHost, 77 | }) 78 | return &LUCIClient{ 79 | HTTPClient: c, 80 | GitilesClient: gitilesClient, 81 | BuildsClient: buildsClient, 82 | BuildersClient: buildersClient, 83 | ResultDBClient: resultDBClient, 84 | nProc: nProc, 85 | } 86 | } 87 | 88 | type BuilderConfigProperties struct { 89 | Repo string `json:"project,omitempty"` 90 | GoBranch string `json:"go_branch,omitempty"` 91 | Target struct { 92 | GOARCH string `json:"goarch,omitempty"` 93 | GOOS string `json:"goos,omitempty"` 94 | } `json:"target"` 95 | KnownIssue int `json:"known_issue,omitempty"` 96 | } 97 | 98 | type Builder struct { 99 | Name string 100 | *BuilderConfigProperties 101 | } 102 | 103 | type BuildResult struct { 104 | ID int64 105 | Status bbpb.Status 106 | Commit string // commit hash 107 | Time time.Time // commit time 108 | GoCommit string // for subrepo build, go commit hash 109 | BuildTime time.Time // build end time 110 | Builder string 111 | *BuilderConfigProperties 112 | InvocationID string // ResultDB invocation ID 113 | LogURL string // textual log of the whole run 114 | LogText string 115 | StepLogURL string // textual log of the (last) failed step, if any 116 | StepLogText string 117 | Failures []*Failure 118 | } 119 | 120 | type Commit struct { 121 | Hash string 122 | Time time.Time 123 | } 124 | 125 | type Project struct { 126 | Repo string 127 | GoBranch string 128 | } 129 | 130 | type Dashboard struct { 131 | Project 132 | Builders []Builder 133 | Commits []Commit 134 | Results [][]*BuildResult // indexed by builder, then by commit 135 | } 136 | 137 | type Failure struct { 138 | TestID string 139 | Status rdbpb.TestStatus 140 | LogURL string 141 | LogText string 142 | } 143 | 144 | // ListCommits fetches the list of commits from Gerrit. 145 | func (c *LUCIClient) ListCommits(ctx context.Context, repo, goBranch string, since time.Time) []Commit { 146 | if c.TraceSteps { 147 | log.Println("ListCommits", repo, goBranch) 148 | } 149 | branch := "master" 150 | if repo == "go" { 151 | branch = goBranch 152 | } 153 | var commits []Commit 154 | var pageToken string 155 | nextPage: 156 | resp, err := c.GitilesClient.Log(ctx, &gpb.LogRequest{ 157 | Project: repo, 158 | Committish: "refs/heads/" + branch, 159 | PageSize: 1000, 160 | PageToken: pageToken, 161 | }) 162 | if err != nil { 163 | log.Fatal(err) 164 | } 165 | for _, c := range resp.GetLog() { 166 | commitTime := c.GetCommitter().GetTime().AsTime() 167 | if commitTime.Before(since) { 168 | goto done 169 | } 170 | commits = append(commits, Commit{ 171 | Hash: c.GetId(), 172 | Time: commitTime, 173 | }) 174 | } 175 | if resp.GetNextPageToken() != "" { 176 | pageToken = resp.GetNextPageToken() 177 | goto nextPage 178 | } 179 | done: 180 | return commits 181 | } 182 | 183 | // ListBuilders fetches the list of builders, on the given repo and goBranch. 184 | // If repo and goBranch are empty, it fetches all builders. 185 | func (c *LUCIClient) ListBuilders(ctx context.Context, repo, goBranch, builder string) ([]Builder, error) { 186 | if c.TraceSteps { 187 | log.Println("ListBuilders", repo, goBranch) 188 | } 189 | all := repo == "" && goBranch == "" 190 | var builders []Builder 191 | var pageToken string 192 | nextPage: 193 | resp, err := c.BuildersClient.ListBuilders(ctx, &bbpb.ListBuildersRequest{ 194 | Project: "golang", 195 | Bucket: "ci", 196 | PageSize: 1000, 197 | PageToken: pageToken, 198 | }) 199 | if err != nil { 200 | return nil, err 201 | } 202 | for _, b := range resp.GetBuilders() { 203 | var p BuilderConfigProperties 204 | json.Unmarshal([]byte(b.GetConfig().GetProperties()), &p) 205 | if all || (p.Repo == repo && p.GoBranch == goBranch) { 206 | bName := b.GetId().GetBuilder() 207 | if builder != "" && bName != builder { // just want one builder, skip others 208 | continue 209 | } 210 | builders = append(builders, Builder{bName, &p}) 211 | } 212 | } 213 | if resp.GetNextPageToken() != "" { 214 | pageToken = resp.GetNextPageToken() 215 | goto nextPage 216 | } 217 | slices.SortFunc(builders, func(a, b Builder) int { 218 | return strings.Compare(a.Name, b.Name) 219 | }) 220 | return builders, nil 221 | } 222 | 223 | // GetBuilds fetches builds from one builder. 224 | func (c *LUCIClient) GetBuilds(ctx context.Context, builder string, since time.Time) ([]*bbpb.Build, error) { 225 | if c.TraceSteps { 226 | log.Println("GetBuilds", builder) 227 | } 228 | pred := &bbpb.BuildPredicate{ 229 | Builder: &bbpb.BuilderID{Project: "golang", Bucket: "ci", Builder: builder}, 230 | CreateTime: &bbpb.TimeRange{StartTime: timestamppb.New(since)}, 231 | } 232 | mask, err := fieldmaskpb.New((*bbpb.Build)(nil), "id", "builder", "output", "status", "steps", "infra", "end_time") 233 | if err != nil { 234 | return nil, err 235 | } 236 | var builds []*bbpb.Build 237 | var pageToken string 238 | nextPage: 239 | resp, err := c.BuildsClient.SearchBuilds(ctx, &bbpb.SearchBuildsRequest{ 240 | Predicate: pred, 241 | Mask: &bbpb.BuildMask{Fields: mask}, 242 | PageSize: 1000, 243 | PageToken: pageToken, 244 | }) 245 | if err != nil { 246 | return nil, err 247 | } 248 | builds = append(builds, resp.GetBuilds()...) 249 | if resp.GetNextPageToken() != "" { 250 | pageToken = resp.GetNextPageToken() 251 | goto nextPage 252 | } 253 | return builds, nil 254 | } 255 | 256 | // ReadBoard reads the build dashboard dash, then fills in the content. 257 | func (c *LUCIClient) ReadBoard(ctx context.Context, dash *Dashboard, builder string, since time.Time) error { 258 | if c.TraceSteps { 259 | log.Println("ReadBoard", dash.Repo, dash.GoBranch) 260 | } 261 | dash.Commits = c.ListCommits(ctx, dash.Repo, dash.GoBranch, since) 262 | var err error 263 | dash.Builders, err = c.ListBuilders(ctx, dash.Repo, dash.GoBranch, builder) 264 | if err != nil { 265 | return err 266 | } 267 | 268 | dashMap := make([]map[string]*BuildResult, len(dash.Builders)) // indexed by builder, then keyed by commit hash 269 | 270 | // Get builds from builders. 271 | g, groupContext := errgroup.WithContext(ctx) 272 | g.SetLimit(c.nProc) 273 | for i, builder := range dash.Builders { 274 | builder := builder 275 | buildMap := make(map[string]*BuildResult) 276 | dashMap[i] = buildMap 277 | g.Go(func() error { 278 | bName := builder.Name 279 | builds, err := c.GetBuilds(groupContext, bName, since) 280 | if err != nil { 281 | return err 282 | } 283 | for _, b := range builds { 284 | id := b.GetId() 285 | var commit, goCommit string 286 | prop := b.GetOutput().GetProperties().GetFields() 287 | for _, s := range prop["sources"].GetListValue().GetValues() { 288 | x := s.GetStructValue().GetFields()["gitilesCommit"].GetStructValue().GetFields() 289 | c := x["id"].GetStringValue() 290 | switch repo := x["project"].GetStringValue(); repo { 291 | case dash.Repo: 292 | commit = c 293 | case "go": 294 | goCommit = c 295 | default: 296 | log.Fatalf("repo mismatch: %s %s %s", repo, dash.Repo, buildURL(id)) 297 | } 298 | } 299 | if commit == "" { 300 | switch b.GetStatus() { 301 | case bbpb.Status_SUCCESS: 302 | log.Fatalf("empty commit: %s", buildURL(id)) 303 | default: 304 | // unfinished build, or infra failure, ignore 305 | continue 306 | } 307 | } 308 | buildTime := b.GetEndTime().AsTime() 309 | if r0 := buildMap[commit]; r0 != nil { 310 | // A build already exists for the same builder and commit. 311 | // Maybe manually retried, or different go commits on same subrepo commit. 312 | // Pick the one ended at later time. 313 | const printDup = false 314 | if printDup { 315 | fmt.Printf("skip duplicate build: %s %s %d %d\n", bName, shortHash(commit), id, r0.ID) 316 | } 317 | if buildTime.Before(r0.BuildTime) { 318 | continue 319 | } 320 | } 321 | rdb := b.GetInfra().GetResultdb() 322 | if rdb.GetHostname() != resultDBHost { 323 | log.Fatalf("ResultDB host mismatch: %s %s %s", rdb.GetHostname(), resultDBHost, buildURL(id)) 324 | } 325 | if b.GetBuilder().GetBuilder() != bName { // sanity check 326 | log.Fatalf("builder mismatch: %s %s %s", b.GetBuilder().GetBuilder(), bName, buildURL(id)) 327 | } 328 | r := &BuildResult{ 329 | ID: id, 330 | Status: b.GetStatus(), 331 | Commit: commit, 332 | GoCommit: goCommit, 333 | BuildTime: buildTime, 334 | Builder: bName, 335 | BuilderConfigProperties: builder.BuilderConfigProperties, 336 | InvocationID: rdb.GetInvocation(), 337 | } 338 | if r.Status == bbpb.Status_FAILURE { 339 | links := prop["failure"].GetStructValue().GetFields()["links"].GetListValue().GetValues() 340 | for _, l := range links { 341 | m := l.GetStructValue().GetFields() 342 | if strings.Contains(m["name"].GetStringValue(), "(combined output)") { 343 | r.LogURL = m["url"].GetStringValue() 344 | break 345 | } 346 | } 347 | if r.LogURL == "" { 348 | // No log URL, Probably a build failure. 349 | // E.g. https://ci.chromium.org/ui/b/8759448820419452721 350 | // Use the build's stderr instead. 351 | for _, l := range b.GetOutput().GetLogs() { 352 | if l.GetName() == "stderr" { 353 | r.LogURL = l.GetViewUrl() 354 | break 355 | } 356 | } 357 | } 358 | 359 | // Fetch the stderr of the failed step. 360 | steps := b.GetSteps() 361 | stepLoop: 362 | for i := len(steps) - 1; i >= 0; i-- { 363 | s := steps[i] 364 | if s.GetStatus() == bbpb.Status_FAILURE { 365 | for _, l := range s.GetLogs() { 366 | if l.GetName() == "stderr" || l.GetName() == "output" { 367 | r.StepLogURL = l.GetViewUrl() 368 | break stepLoop 369 | } 370 | } 371 | } 372 | } 373 | } 374 | buildMap[commit] = r 375 | } 376 | return nil 377 | }) 378 | } 379 | if err := g.Wait(); err != nil { 380 | return err 381 | } 382 | 383 | // Gather into dashboard. 384 | dash.Results = make([][]*BuildResult, len(dash.Builders)) 385 | for i, m := range dashMap { 386 | dash.Results[i] = make([]*BuildResult, len(dash.Commits)) 387 | for j, c := range dash.Commits { 388 | r := m[c.Hash] 389 | if r == nil { 390 | continue 391 | } 392 | r.Time = c.Time // fill in commit time 393 | dash.Results[i][j] = r 394 | } 395 | } 396 | 397 | return nil 398 | } 399 | 400 | func buildURL(buildID int64) string { // keep in sync with buildUrlRE in github.go 401 | return fmt.Sprintf("https://ci.chromium.org/b/%d", buildID) 402 | } 403 | 404 | func shortHash(s string) string { 405 | if len(s) > 8 { 406 | return s[:8] 407 | } 408 | return s 409 | } 410 | 411 | var ( 412 | repo = flag.String("repo", "go", "repo name (defualt: \"go\")") 413 | branch = flag.String("branch", "master", "branch (defualt: \"master\")") 414 | builder = flag.String("builder", "", "builder to query, if unset, query all builders") 415 | test = flag.String("test", "", "test name") 416 | ) 417 | 418 | func main() { 419 | flag.Parse() 420 | if *test == "" { 421 | flag.Usage() 422 | log.Fatal("test name unset") 423 | } 424 | 425 | ctx := context.Background() 426 | c := NewLUCIClient(1) 427 | c.TraceSteps = true 428 | 429 | // LUCI keeps data up to 60 days, so there is no point to go back farther 430 | startTime := time.Now().Add(-60 * 24 * time.Hour) 431 | dash := &Dashboard{Project: Project{*repo, *branch}} 432 | c.ReadBoard(ctx, dash, *builder, startTime) 433 | 434 | printBuilder := func(string) {} 435 | if len(dash.Builders) > 1 { 436 | printBuilder = func(s string) { fmt.Print(s, ",") } 437 | } 438 | for i, b := range dash.Builders { 439 | for _, r := range dash.Results[i] { 440 | if r == nil { 441 | continue 442 | } 443 | if c.TraceSteps { 444 | log.Println("QueryTestResultsRequest", b.Name, shortHash(r.Commit), r.Time) 445 | } 446 | req := &rdbpb.QueryTestResultsRequest{ 447 | Invocations: []string{r.InvocationID}, 448 | Predicate: &rdbpb.TestResultPredicate{ 449 | TestIdRegexp: regexp.QuoteMeta(*test), 450 | }, 451 | } 452 | resp, err := c.ResultDBClient.QueryTestResults(ctx, req) 453 | if err != nil { 454 | log.Fatal(err) 455 | } 456 | 457 | for _, rr := range resp.GetTestResults() { 458 | status := rr.GetStatus() 459 | if status == rdbpb.TestStatus_SKIP { 460 | continue 461 | } 462 | dur := rr.GetDuration().AsDuration() 463 | fmt.Print(shortHash(r.Commit), ",", r.Time, ",") 464 | printBuilder(b.Name) 465 | fmt.Print(status, ",") 466 | // Split pass and fail results so it is easy to plot them in 467 | // different colors. 468 | if status == rdbpb.TestStatus_PASS { 469 | fmt.Print(dur.Seconds(), ",") 470 | } else { 471 | fmt.Print(",", dur.Seconds()) 472 | } 473 | fmt.Println() 474 | } 475 | } 476 | } 477 | } 478 | -------------------------------------------------------------------------------- /cherry/wasmtest/go.mod: -------------------------------------------------------------------------------- 1 | module golang.org/x/scratch/cherry/wasmtest 2 | 3 | go 1.22 4 | 5 | require github.com/tetratelabs/wazero v1.7.3 6 | -------------------------------------------------------------------------------- /cherry/wasmtest/go.sum: -------------------------------------------------------------------------------- 1 | github.com/tetratelabs/wazero v1.7.3 h1:PBH5KVahrt3S2AHgEjKu4u+LlDbbk+nsGE3KLucy6Rw= 2 | github.com/tetratelabs/wazero v1.7.3/go.mod h1:ytl6Zuh20R/eROuyDaGPkp82O9C/DJfXAwJfQ3X6/7Y= 3 | -------------------------------------------------------------------------------- /cherry/wasmtest/testprog/x.go: -------------------------------------------------------------------------------- 1 | //go:build wasm 2 | 3 | package main 4 | 5 | import ( 6 | "runtime" 7 | "runtime/debug" 8 | ) 9 | 10 | func init() { 11 | println("init function called") 12 | } 13 | 14 | var ch = make(chan float64) 15 | 16 | //go:wasmexport E 17 | func E(a int64, b int32, c float64, d float32) { // various types of args, no result 18 | println("=== E ===") 19 | // goroutine 20 | go func() { ch <- float64(a) + float64(b) + c + float64(d) + 100 }() 21 | debug.PrintStack() // traceback 22 | grow([100]int{10}) // stack growth 23 | runtime.GC() // GC 24 | println("=== E end ===") 25 | } 26 | 27 | //go:wasmexport F 28 | func F() int64 { // no arg, has result 29 | f := int64(<-ch * 100) // force a goroutine switch 30 | println("F =", f) 31 | return f 32 | } 33 | 34 | //go:wasmexport G 35 | func G(x int32) { 36 | println("G", x) 37 | if x%2 == 0 { 38 | G(x - 1) // simple recursion within this module 39 | } else { 40 | J(x - 1) // mutual recursion between host and this module 41 | } 42 | println("G", x, "end") 43 | } 44 | 45 | //go:wasmimport test I 46 | func I() int64 47 | 48 | //go:wasmimport test J 49 | func J(int32) 50 | 51 | func main() { 52 | println("hello") 53 | println("main: I =", I()) 54 | } 55 | 56 | func grow(x [100]int) { 57 | if x[0] == 0 { 58 | println("=== grow ===") 59 | debug.PrintStack() 60 | return 61 | } 62 | x[0]-- 63 | grow(x) 64 | } 65 | -------------------------------------------------------------------------------- /cherry/wasmtest/w.go: -------------------------------------------------------------------------------- 1 | // Copyright 2024 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // A program for testing wasmexport. 6 | // This is the driver/host program, which provides the imports 7 | // and calls the exports. testprog is the source of the Wasm 8 | // module, which can be compiled to either an executable or a 9 | // library. 10 | // 11 | // To build it as executable: 12 | // GOARCH=wasm GOOS=wasip1 go build -o /tmp/x.wasm ./testprog 13 | // 14 | // To build it as a library: 15 | // GOARCH=wasm GOOS=wasip1 go build -buildmode=c-shared -o /tmp/x.wasm ./testprog 16 | // 17 | // Then run the driver (which works for both modes): 18 | // go run w.go /tmp/x.wasm 19 | package main 20 | 21 | import ( 22 | "bytes" 23 | "context" 24 | "fmt" 25 | "io" 26 | "os" 27 | 28 | "github.com/tetratelabs/wazero" 29 | "github.com/tetratelabs/wazero/api" 30 | "github.com/tetratelabs/wazero/imports/wasi_snapshot_preview1" 31 | ) 32 | 33 | // exported from wasm 34 | var E func(a int64, b int32, c float64, d float32) 35 | var F func() int64 36 | var G func(int32) 37 | 38 | func I() int64 { 39 | println("I start") 40 | E(20, 3, 0.4, 0.05) 41 | r := F() * 2 42 | G(4) 43 | println("I end =", r) 44 | return r 45 | } 46 | 47 | func J(x int32) { 48 | println("J", x) 49 | if x > 0 { 50 | G(x) 51 | } 52 | println("J", x, "end") 53 | } 54 | 55 | var errbuf bytes.Buffer 56 | var stderr = io.MultiWriter(os.Stderr, &errbuf) 57 | 58 | func main() { 59 | ctx := context.Background() 60 | 61 | r := wazero.NewRuntime(ctx) 62 | defer r.Close(ctx) 63 | 64 | // provide import functions from host 65 | _, err := r.NewHostModuleBuilder("test"). 66 | NewFunctionBuilder().WithFunc(I).Export("I"). 67 | NewFunctionBuilder().WithFunc(J).Export("J"). 68 | Instantiate(ctx) 69 | if err != nil { 70 | panic(err) 71 | } 72 | 73 | buf, err := os.ReadFile(os.Args[1]) 74 | if err != nil { 75 | panic(err) 76 | } 77 | 78 | config := wazero.NewModuleConfig(). 79 | WithStdout(os.Stdout).WithStderr(stderr). 80 | WithStartFunctions() // don't call _start 81 | 82 | wasi_snapshot_preview1.MustInstantiate(ctx, r) 83 | 84 | m, err := r.InstantiateWithConfig(ctx, buf, config) 85 | if err != nil { 86 | panic(err) 87 | } 88 | 89 | // get export functions from the module 90 | E = func(a int64, b int32, c float64, d float32) { 91 | exp := m.ExportedFunction("E") 92 | _, err := exp.Call(ctx, api.EncodeI64(a), api.EncodeI32(b), api.EncodeF64(c), api.EncodeF32(d)) 93 | if err != nil { 94 | panic(err) 95 | } 96 | } 97 | F = func() int64 { 98 | exp := m.ExportedFunction("F") 99 | r, err := exp.Call(ctx) 100 | if err != nil { 101 | panic(err) 102 | } 103 | rr := int64(r[0]) 104 | println("host: F =", rr) 105 | return rr 106 | } 107 | G = func(x int32) { 108 | exp := m.ExportedFunction("G") 109 | _, err := exp.Call(ctx, api.EncodeI32(x)) 110 | if err != nil { 111 | panic(err) 112 | } 113 | } 114 | 115 | entry := m.ExportedFunction("_start") 116 | if entry != nil { 117 | // Executable mode. 118 | fmt.Println("Executable mode: start") 119 | _, err := entry.Call(ctx) 120 | fmt.Println(err) 121 | return 122 | } 123 | 124 | // Library mode. 125 | fmt.Println("Libaray mode: call export before initialization") 126 | shouldPanic(func() { I() }) 127 | // reset module 128 | m, err = r.InstantiateWithConfig(ctx, buf, config) 129 | if err != nil { 130 | panic(err) 131 | } 132 | fmt.Println("Library mode: initialize") 133 | entry = m.ExportedFunction("_initialize") 134 | _, err = entry.Call(ctx) 135 | if err != nil { 136 | panic(err) 137 | } 138 | fmt.Println("\nLibrary mode: call export functions") 139 | I() 140 | } 141 | 142 | func shouldPanic(f func()) { 143 | defer func() { 144 | e := recover() 145 | if e == nil { 146 | panic("did not panic") 147 | } 148 | if !bytes.Contains(errbuf.Bytes(), []byte("runtime: wasmexport function called before runtime initialization")) { 149 | panic("expected error message missing") 150 | } 151 | }() 152 | f() 153 | } 154 | -------------------------------------------------------------------------------- /chimeracoder/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Hello, world!") 13 | fmt.Println(" - Sent from my XPS 13 running Debian") 14 | } 15 | -------------------------------------------------------------------------------- /cixel/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("change") 11 | } 12 | -------------------------------------------------------------------------------- /clairew/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("vim-go") 11 | } 12 | -------------------------------------------------------------------------------- /cmcguinness/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The cmcguinness tool displays a random number. 6 | package main 7 | 8 | import "fmt" 9 | 10 | // randomNumber implementation sourced from https://xkcd.com/221/. 11 | // chosen by a fair dice roll. 12 | // guaranteed to be random 13 | const randomNumber = 4 14 | 15 | func main() { 16 | fmt.Printf("Your random number of the day is: %v", randomNumber) 17 | } 18 | -------------------------------------------------------------------------------- /codyoss/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("I did it!") 11 | } 12 | -------------------------------------------------------------------------------- /conradwt/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello GopherCon 2018 Community Workshops") 11 | } 12 | -------------------------------------------------------------------------------- /corylanou/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("we need fmt duh?") 11 | } 12 | -------------------------------------------------------------------------------- /cpallares/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hola mundo!") 11 | } 12 | -------------------------------------------------------------------------------- /csduarte/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("containers rule!") 11 | } 12 | -------------------------------------------------------------------------------- /cyacco/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello from gohpercon") 11 | } 12 | -------------------------------------------------------------------------------- /danicat/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("Hello Gophers!!!") 10 | } 11 | -------------------------------------------------------------------------------- /danmrichards/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /dark5un/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("vim-go") 11 | } 12 | -------------------------------------------------------------------------------- /darron/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Golang is not Go.") 11 | } 12 | -------------------------------------------------------------------------------- /davidgood/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Slainte!") 11 | } 12 | -------------------------------------------------------------------------------- /davidsbond/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello world") 11 | } 12 | -------------------------------------------------------------------------------- /dechensherpa/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("Hello World!") 7 | } 8 | -------------------------------------------------------------------------------- /delioda/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /dertseha/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /devalshah88/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("gophercon!") 11 | } 12 | -------------------------------------------------------------------------------- /dfinkel/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Live from GopherCon, it's Thursday something!") 11 | fmt.Println("Or, maybe not live anymore") 12 | } 13 | -------------------------------------------------------------------------------- /dgrmsh/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Which flavor of cookies is the best?") 11 | } 12 | -------------------------------------------------------------------------------- /dicaormu/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | /*Package main has the main code of the example 6 | for contributing to go, in the gophercon 7 | */ 8 | package main 9 | 10 | import "fmt" 11 | 12 | func main() { 13 | fmt.Println("containers rule!") 14 | } 15 | -------------------------------------------------------------------------------- /dirbaio/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("200 OK") 11 | } 12 | -------------------------------------------------------------------------------- /dlsniper/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Greetings from GopherCon!") 11 | } 12 | -------------------------------------------------------------------------------- /doc.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Package scratch exists mainly for people to learn how to use Gerrit 6 | // and contribute to Go. 7 | // 8 | // Read the README.md to access the tutorial. 9 | package scratch 10 | -------------------------------------------------------------------------------- /domgreen/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Scratching ... Like a DJ! 😎") 11 | } 12 | -------------------------------------------------------------------------------- /draina/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The main package states how awesome Deepali is. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("Deepali is awesomeeeee :-)") 12 | } 13 | -------------------------------------------------------------------------------- /drewvanstone/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This tool proclaims the ruliness of tools. 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | fmt.Println("Hello Gophercon2018") 14 | } 15 | -------------------------------------------------------------------------------- /drichelson/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // It is important for everyone to know that gophers are rodents. 6 | 7 | func main() { 8 | fmt.Println("Gophers are burrowing rodents.....") 9 | } 10 | -------------------------------------------------------------------------------- /dtimm/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // dtimm command hosts a friendly message on port :8080. 6 | package main 7 | 8 | import ( 9 | "io" 10 | "log" 11 | "net/http" 12 | ) 13 | 14 | func main() { 15 | http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { 16 | io.WriteString(w, "Hello from GopherCon 2018!") 17 | }) 18 | 19 | log.Fatal(http.ListenAndServe(":8080", nil)) 20 | } 21 | -------------------------------------------------------------------------------- /emasatsugu/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // emasatsugu prints the author's username. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("emasatsugu") 12 | } 13 | -------------------------------------------------------------------------------- /enocom/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | // Meng Haoran 孟浩然 (689-740), "Chun xiao" 春曉 10 | var poem = `春眠不覺曉 11 | 處處聞啼鳥 12 | 夜來風雨聲 13 | 花落知多少` 14 | 15 | func main() { 16 | fmt.Println(poem) 17 | } 18 | -------------------------------------------------------------------------------- /epkann/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // It is important for everyone to know that gophers are rodents. 6 | 7 | func main() { 8 | fmt.Println("Gophers are burrowing rodents.") 9 | } 10 | -------------------------------------------------------------------------------- /esellblah/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("this is a test") 11 | fmt.Println("this is another test") 12 | } 13 | -------------------------------------------------------------------------------- /evanh/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Fear leads to anger. Anger leads to hate. Hate leads to suffering.") 11 | fmt.Println("Do or do not. There is no try.") 12 | } 13 | -------------------------------------------------------------------------------- /fenos/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /fexolm/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | println("Go is awesome") 9 | } 10 | -------------------------------------------------------------------------------- /filippo/github.txt: -------------------------------------------------------------------------------- 1 | Straight from the GitHub web editor! 2 | 3 | This will be awesome for occasional contributors, thanks @andybons and team! 4 | -------------------------------------------------------------------------------- /fmstephe/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /frojasg/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello World!") 11 | } 12 | -------------------------------------------------------------------------------- /fuzz/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The fuzz program is a simple scratch program for review purposes 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("containers rule!") 12 | } 13 | -------------------------------------------------------------------------------- /gangleri/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /garrmcnu/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello World!") 11 | } 12 | -------------------------------------------------------------------------------- /gasteig/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Go knows I need fmt, right?") 11 | } 12 | -------------------------------------------------------------------------------- /gautamdey/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Tegola.io -- Number 22625 is number two two six two five") 11 | } 12 | -------------------------------------------------------------------------------- /geototti21/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Works????!!") 11 | } 12 | -------------------------------------------------------------------------------- /ghchinoy/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("I'm totally contributing to Go! (well, kinda :)") 11 | } 12 | -------------------------------------------------------------------------------- /ghoil/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Command ghoil just prints a message. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("containers rule!") 12 | } 13 | -------------------------------------------------------------------------------- /gk/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Meh Linux doesn't have its year on the desktop, but it does power the Internet!") 11 | } 12 | -------------------------------------------------------------------------------- /gmarik/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello gophercon2017😀👀🎉") 11 | } 12 | -------------------------------------------------------------------------------- /gmichelo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt? by gmichelo") 11 | } 12 | -------------------------------------------------------------------------------- /gonzaloserrano/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | println("(╯°. °）╯︵ ┻buıɯɯɐɹboɹd┻") 9 | } 10 | -------------------------------------------------------------------------------- /gopherbot/a.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package gopherbot 6 | 7 | // This is file a.go. 8 | -------------------------------------------------------------------------------- /gopherbot/b.go: -------------------------------------------------------------------------------- 1 | // Copyright 2021 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package gopherbot 6 | 7 | // This is file b.go. 8 | -------------------------------------------------------------------------------- /goyalankit/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("beep beep boop.") 11 | } 12 | -------------------------------------------------------------------------------- /grantseltzer/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | "time" 10 | ) 11 | 12 | func main() { 13 | fmt.Printf("%d is the year of linux on the desktop\n", time.Now().Year()) 14 | } 15 | -------------------------------------------------------------------------------- /grepory/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("this is a fantastic contributor workflow.") 11 | } 12 | -------------------------------------------------------------------------------- /gsg/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file 4 | 5 | // main prints silly things 6 | 7 | package main 8 | 9 | import "fmt" 10 | 11 | func main() { 12 | fmt.Println("👌") 13 | } 14 | -------------------------------------------------------------------------------- /guyfedwards/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /h0lyalg0rithm/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello world!") 11 | } 12 | -------------------------------------------------------------------------------- /hakim/greeting.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func greeting() { 10 | fmt.Println("hello, git") 11 | } 12 | -------------------------------------------------------------------------------- /hakim/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | greeting() 9 | } 10 | -------------------------------------------------------------------------------- /hanwen/test.txt: -------------------------------------------------------------------------------- 1 | 2 | bla bla 3 | -------------------------------------------------------------------------------- /hawazine/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, gophercon!") 11 | } 12 | -------------------------------------------------------------------------------- /hearot/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /herbie/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("Go Go Gophercon!!!") 10 | } 11 | -------------------------------------------------------------------------------- /huadcu/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("I'm in!") 11 | } 12 | -------------------------------------------------------------------------------- /hugorut/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /ianzapolsky/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // ianzapolsky is a simple hello world program for review purposes. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("Hello scratch!") 12 | fmt.Println("this is a change!") 13 | } 14 | -------------------------------------------------------------------------------- /iccha/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello Universe") 11 | } 12 | -------------------------------------------------------------------------------- /ilanpillemer/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /iliasb/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /irbekrm/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /itch/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("gopher scratched!") 11 | } 12 | -------------------------------------------------------------------------------- /ivan3bx/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file.package main 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("This output is even better") 13 | } 14 | -------------------------------------------------------------------------------- /jackdbd/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | "math/rand" 10 | "time" 11 | ) 12 | 13 | func main() { 14 | rand.Seed(time.Now().UTC().UnixNano()) 15 | digit := rand.Intn(123) 16 | fmt.Printf("What's up %d \n", digit) 17 | } 18 | -------------------------------------------------------------------------------- /jakobernik/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("into orbit!") 11 | fmt.Println("Now with legality!") 12 | fmt.Println("time doesn't matter...") 13 | } 14 | -------------------------------------------------------------------------------- /jamesfcarter/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println(`jamesfcarter says "GO!"`) 11 | } 12 | -------------------------------------------------------------------------------- /jamiebarnett/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | fmt.Println("who even needs fmt?") 9 | } 10 | -------------------------------------------------------------------------------- /jaskamante/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /jasonkeene/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("I don't always block my goroutines, but when I do I use select{}") 11 | select {} 12 | } 13 | -------------------------------------------------------------------------------- /jbd/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("goodbye world") 11 | } 12 | -------------------------------------------------------------------------------- /jboursiquot/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("The Go Community is Da Bomb!") 11 | } 12 | -------------------------------------------------------------------------------- /jcbwlkr/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | for i := 0; i < 11; i++ { 11 | fmt.Println("Hello, Gerrit!") 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /jda/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello from Jade!") 11 | fmt.Println("Gophercon was/is/will be amazing.") 12 | } 13 | -------------------------------------------------------------------------------- /jgimeno/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("vim-go") 11 | } 12 | -------------------------------------------------------------------------------- /jhewes/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The jhewes program prints an amazing message. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("this is a change!") 12 | } 13 | -------------------------------------------------------------------------------- /jkerr123/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("new change to my file") 7 | } 8 | -------------------------------------------------------------------------------- /jlloyd/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /jmaeso/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Lol. No creativity here...") 11 | } 12 | -------------------------------------------------------------------------------- /jms/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /joanlopez/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /joeshaw/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println(`\ʕ◔ϖ◔ʔ/ I'm a Go contributor! \ʕ◔ϖ◔ʔ/`) 11 | } 12 | -------------------------------------------------------------------------------- /johnnyluo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Johnny Luo in gophercon, make a change") 11 | } 12 | -------------------------------------------------------------------------------- /jonogould/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Hello, from London 🇬🇧") 13 | } 14 | -------------------------------------------------------------------------------- /joshroppo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Greetings from People's Republic of Portland!") 11 | } 12 | -------------------------------------------------------------------------------- /jouderianjr/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("🍕🍕🍕 🚀 🖥 🐕 🤡") 11 | 12 | } 13 | -------------------------------------------------------------------------------- /jtblakeley/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("こんにちは!") 10 | 11 | } 12 | -------------------------------------------------------------------------------- /jurgendecommer/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello from Belgium!") 11 | } 12 | -------------------------------------------------------------------------------- /jwangsadinata/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("You can tune a guitar, but you can't tuna fish") 11 | fmt.Println("Unless of course, you play bass") 12 | } 13 | -------------------------------------------------------------------------------- /jwilder/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello from Denver & Gophercon!") 11 | } 12 | -------------------------------------------------------------------------------- /kasperlewau/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("vim-go") 11 | } 12 | -------------------------------------------------------------------------------- /katemanson/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Footering about some more...") 11 | } 12 | -------------------------------------------------------------------------------- /kentakudo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /kevinburke/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "crypto/rand" 9 | "fmt" 10 | "math/big" 11 | mrand "math/rand" 12 | ) 13 | 14 | var quotes = []string{ 15 | "This here’s a gun powder activated, 27 caliber, full auto, no kickback, nail-throwing mayhem man", 16 | "You come at the king, you best not miss.", 17 | "A life. A life, Jimmy, you know what that is? It's the stuff that happens while you're waiting for moments that never come.", 18 | } 19 | 20 | func main() { 21 | n, err := rand.Int(rand.Reader, big.NewInt(2<<32-1)) 22 | if err != nil { 23 | panic(err) 24 | } 25 | r := mrand.New(mrand.NewSource(n.Int64())) 26 | choice := r.Intn(len(quotes)) 27 | fmt.Println(quotes[choice]) 28 | } 29 | -------------------------------------------------------------------------------- /kiivihal/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /kinbiko/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello 世界") 11 | } 12 | -------------------------------------------------------------------------------- /kirooha/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /ladydascalie/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /lagimenez/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt? We do.") 11 | } 12 | -------------------------------------------------------------------------------- /landonbjones/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello GopherCon!") 11 | } 12 | -------------------------------------------------------------------------------- /laurenceusas/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /leighcapili/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // Prints Leigh's views on the world 6 | // tw: @capileigh / gh: stealthybox 7 | package main 8 | 9 | import "fmt" 10 | 11 | func main() { 12 | fmt.Println("life is beautiful because it has dogs.") 13 | } 14 | -------------------------------------------------------------------------------- /leighmcculloch/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("HI! This is my first contribution to a googlesource repo using gerrit.") 11 | fmt.Println("╰(◕ヮ◕)つ¤=[]———") 12 | } 13 | -------------------------------------------------------------------------------- /liam/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /light/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The light program prints an encouraging Go mantra. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("Watch me go func()") 12 | } 13 | -------------------------------------------------------------------------------- /lineufelipe/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, I'm Lineu Felipe") 11 | } 12 | -------------------------------------------------------------------------------- /lizrice/main.go: -------------------------------------------------------------------------------- 1 | // Also I want to see what happens if I miss the copyright 2 | 3 | package main 4 | 5 | import "fmt" 6 | 7 | func main() { 8 | fmt.Printf("I could break this in countless ways like omitting the quote but go-fmt catches that.") 9 | } 10 | -------------------------------------------------------------------------------- /ljfranklin/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("✈ Ship it! ✈") 11 | } 12 | -------------------------------------------------------------------------------- /lucas/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello!") 11 | } 12 | -------------------------------------------------------------------------------- /ludweeg/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | println("Go is awesome") 9 | } 10 | -------------------------------------------------------------------------------- /luigiDB/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("luigi CL") 11 | } 12 | -------------------------------------------------------------------------------- /lukmdo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("CL done!") 11 | } 12 | -------------------------------------------------------------------------------- /mabu/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Sveikas, pasauli!") 11 | } 12 | -------------------------------------------------------------------------------- /maerf0x0/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | license := `Copyright 2018 The Go Authors. All rights reserved. 11 | Use of this source code is governed by a BSD-style 12 | license that can be found in the LICENSE file. 13 | ` 14 | fmt.Println(license) 15 | } 16 | -------------------------------------------------------------------------------- /maitesin/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, Maitesin!") 11 | } 12 | -------------------------------------------------------------------------------- /makhan/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /manzan_46/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, Heetch Team here.") 11 | } 12 | -------------------------------------------------------------------------------- /marioarranzr/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /martisch/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("all contributions rule!") 11 | } 12 | -------------------------------------------------------------------------------- /matloob/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2014 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This tool proclaims the ruliness of tools. 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | fmt.Println("Tools Rule!") 14 | } 15 | -------------------------------------------------------------------------------- /matthewrudy/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, I'm Matthew.") 11 | } 12 | -------------------------------------------------------------------------------- /matzhouse/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Oh hi gerrit!") 13 | } 14 | -------------------------------------------------------------------------------- /mayra-cabrera/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Cats will rule the world!") 11 | fmt.Println("Gophercon: Best conference ever!") 12 | } 13 | -------------------------------------------------------------------------------- /mbbroberg/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("I ❤️ this community") 11 | } 12 | -------------------------------------------------------------------------------- /mchoube/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Go contibution workshop :)") 11 | } 12 | -------------------------------------------------------------------------------- /mdhender/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("This is the year of linux on the desktop!") 10 | } 11 | -------------------------------------------------------------------------------- /mec07/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("hello world") 7 | } 8 | -------------------------------------------------------------------------------- /mennis/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Happy to be at gophercon!") 11 | } 12 | -------------------------------------------------------------------------------- /merovius/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello Gophercon") 11 | } 12 | -------------------------------------------------------------------------------- /mfrw/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("I love to go!") 11 | } 12 | -------------------------------------------------------------------------------- /mgarton/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("Hello") 10 | } 11 | -------------------------------------------------------------------------------- /mh/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /miguelbernadi/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("who even needs fmt?") 13 | } 14 | -------------------------------------------------------------------------------- /mlasala/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /mmcloughlin/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The mmcloughlin command trolls America. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("Make America Great Britain Again!!") 12 | } 13 | -------------------------------------------------------------------------------- /mohan08p/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello Gopher, post Gophercon!!!!!!!!") 11 | } 12 | -------------------------------------------------------------------------------- /morfeo8marc/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /morrisio/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Making my first code contribution to Go... Sort of :)") 11 | } 12 | -------------------------------------------------------------------------------- /mperez/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("containers rule!") 11 | } 12 | -------------------------------------------------------------------------------- /msd/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("containers rule!") 11 | } 12 | -------------------------------------------------------------------------------- /msiggy/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | //Package main is used to print a welcome message 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | fmt.Println("Hello Gophercon!") 14 | } 15 | -------------------------------------------------------------------------------- /myles-mcdonnell-package/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /nathany/greeting.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, Gophers!") 11 | } 12 | -------------------------------------------------------------------------------- /nathany/greeting_test.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "os/exec" 9 | "testing" 10 | ) 11 | 12 | func TestMain(t *testing.T) { 13 | checkOutput(t, "greeting.go", "Hello, Gophers!\n") 14 | } 15 | 16 | // checkOutput from running a program against expectations. 17 | func checkOutput(t *testing.T, file, expected string) { 18 | actual := runCmd(t, file) 19 | if expected != actual { 20 | t.Errorf("Expected output %q, got %q.", expected, actual) 21 | } 22 | } 23 | 24 | // runCmd a program and capture the output. 25 | func runCmd(t *testing.T, file string) string { 26 | out, err := exec.Command("go", "run", file).Output() 27 | if e, ok := err.(*exec.ExitError); ok { 28 | t.Fatalf("unsuccessful exit: %s", e.Stderr) 29 | } else if err != nil { 30 | t.Fatalf("%s", err) 31 | } 32 | return string(out) 33 | } 34 | -------------------------------------------------------------------------------- /nathj07/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /natx/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("who even needs fmt?") 10 | } 11 | -------------------------------------------------------------------------------- /nd/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello world") 11 | } 12 | -------------------------------------------------------------------------------- /neilowen/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs a personalised message? 🤔") 11 | } 12 | -------------------------------------------------------------------------------- /neosimsim/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Hallo Welt!") 13 | } 14 | -------------------------------------------------------------------------------- /nickng/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | const greetingMsg = "你好, 世界!" 10 | 11 | func main() { 12 | fmt.Println(greetingMsg) 13 | } 14 | -------------------------------------------------------------------------------- /nikhita/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("This workshop is awesome!!!!!!!!") 11 | } 12 | -------------------------------------------------------------------------------- /nlindblad/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /nodo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /ordishs/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /oskanberg/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("ppfpffppffffffmt") 11 | } 12 | -------------------------------------------------------------------------------- /ottogiron/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This package contains a contribution for the scratch repository. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("gophercon rule!") 12 | } 13 | -------------------------------------------------------------------------------- /pamelin/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /pbathala/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("This change is for GopherCon 2018") 11 | fmt.Println("More changes for GopherCon") 12 | } 13 | -------------------------------------------------------------------------------- /pbnjay/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("bioinformatics rocks when I can use big memory!") 11 | } 12 | -------------------------------------------------------------------------------- /pedrosland/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /philpearl/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /pierreprinetti/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Thank you jessfraz!") 11 | } 12 | -------------------------------------------------------------------------------- /pkch/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("Gopher!!!") 10 | } 11 | -------------------------------------------------------------------------------- /pmoroney/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("This workshop is awesome!") 11 | } 12 | -------------------------------------------------------------------------------- /prutswonder/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /pteichman/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, Gophers!") 11 | } 12 | -------------------------------------------------------------------------------- /pwok/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /r/greeting.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func greeting() { 10 | fmt.Println("hello, git") 11 | } 12 | -------------------------------------------------------------------------------- /r/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | greeting() 9 | } 10 | -------------------------------------------------------------------------------- /rabellamy/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello!") 11 | } 12 | -------------------------------------------------------------------------------- /ram535ii/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /rautelap/main.go: -------------------------------------------------------------------------------- 1 | // The rautelap tool prints a quote from a famous bending unit. 2 | package main 3 | 4 | import ( 5 | "bufio" 6 | "io" 7 | "os" 8 | ) 9 | 10 | func main() { 11 | 12 | file, err := os.Create("/tmp/hubertJfarnsworth") 13 | 14 | if err != nil { 15 | panic("Error opening file") 16 | } 17 | 18 | w := bufio.NewWriter(file) 19 | io.WriteString(w, "Bite my shiny metal A**") 20 | 21 | err = w.Flush() 22 | 23 | if err != nil { 24 | println("Check file, some data maybe missing") 25 | } 26 | 27 | file.Close() 28 | } 29 | -------------------------------------------------------------------------------- /rhettg/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("It's Go Time") 11 | } 12 | -------------------------------------------------------------------------------- /rkuska/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /robHertz/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("containers rule!") 11 | } 12 | -------------------------------------------------------------------------------- /robbawebba/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This package greets all of the fellow gophers. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("Hello fellow gophers!") 12 | } 13 | -------------------------------------------------------------------------------- /robclap8/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello Go!") 11 | } 12 | -------------------------------------------------------------------------------- /rogersimms/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The rogersimms command is optimistic about Linux on the desktop. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("this is the year of linux on the desktop!") 12 | } 13 | -------------------------------------------------------------------------------- /rogpeppe/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "io" 5 | "log" 6 | "os" 7 | ) 8 | 9 | func main() { 10 | if _, err := io.Copy(os.Stdout, os.Stdin); err != nil { 11 | log.Fatal(err) 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /ronang/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("containers rule!") 11 | } 12 | -------------------------------------------------------------------------------- /rowanf/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /rprimus/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Testing a CL using the scratch repo.") 11 | } 12 | -------------------------------------------------------------------------------- /rrey/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hola Mundo!") 11 | fmt.Println("Hello, World!!!") 12 | } 13 | -------------------------------------------------------------------------------- /rsc/greeting.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func greeting() { 10 | println(1) 11 | fmt.Println("hello, git32 ") 12 | } 13 | -------------------------------------------------------------------------------- /rsc/hello: -------------------------------------------------------------------------------- 1 | hello 2 | -------------------------------------------------------------------------------- /rsc/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | println("ee") 9 | greeting() 10 | } 11 | -------------------------------------------------------------------------------- /sameer/greeting.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func greeting() { 10 | fmt.Println("hello, git") 11 | } 12 | -------------------------------------------------------------------------------- /sameer/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | greeting() 9 | } 10 | -------------------------------------------------------------------------------- /sandipb/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "log" 8 | 9 | func main() { 10 | log.Printf("Hello Gophercon @Denver!\n") 11 | } 12 | -------------------------------------------------------------------------------- /sauvaget/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hi I'm Thomas!") 11 | } 12 | -------------------------------------------------------------------------------- /sbramin/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello go") 11 | fmt.Println("this is a patch") 12 | } 13 | -------------------------------------------------------------------------------- /sbuss/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("GopherCon Best Con") 11 | } 12 | -------------------------------------------------------------------------------- /scorphus/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("GopherCon 2017 has been my best conference ever! By far!") 11 | } 12 | -------------------------------------------------------------------------------- /senekis/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("this is the year of linux on the desktop!") 10 | } 11 | -------------------------------------------------------------------------------- /sepetrov/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /seubert/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("hello from austin, tx") 11 | } 12 | -------------------------------------------------------------------------------- /sfrancia/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Steve is awesome") 11 | } 12 | -------------------------------------------------------------------------------- /shwsun/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Distributed-systems Tracing rules!") 11 | } 12 | -------------------------------------------------------------------------------- /skolodyazhnyy/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /sm/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Go, go, Gophercon 2017!") 11 | } 12 | -------------------------------------------------------------------------------- /smoya/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("The only difference between me and a madman is that I'm not mad. - Salvador Dali") 7 | } 8 | -------------------------------------------------------------------------------- /srburnham/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /sselph/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The sselph command says hello to everyone at gophercon. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("Hello Gophercon!") 12 | } 13 | -------------------------------------------------------------------------------- /stanchan/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("This is the year of Kubernetes!") 11 | } 12 | -------------------------------------------------------------------------------- /stegro/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /steveazz/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2019 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import ( 7 | "fmt" 8 | ) 9 | 10 | func main() { 11 | fmt.Println("who even needs fmt?") 12 | } 13 | -------------------------------------------------------------------------------- /sukrithanda/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("changing things") 11 | } 12 | -------------------------------------------------------------------------------- /suttonjesse/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Konnichi wa, yo!") 11 | } 12 | -------------------------------------------------------------------------------- /telecoda/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /telliott/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("You build everything three times. Once to figure out what you want. Once to figure out how to do it. And once to do it.") 11 | } 12 | -------------------------------------------------------------------------------- /tengufromsky/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("I love Golang!") 11 | } 12 | -------------------------------------------------------------------------------- /teodorst/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /tessr/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "log" 8 | 9 | func main() { 10 | log.Println("hiiiii 😍") 11 | } 12 | -------------------------------------------------------------------------------- /tetff/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /thanm/first.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func quote1() { 8 | println("Obfuscate the pancakes!") 9 | println() 10 | } 11 | 12 | func quote2() { 13 | println("From the label of a secure disk: Nemo me impune accessit") 14 | println() 15 | } 16 | -------------------------------------------------------------------------------- /thanm/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | quote1() 9 | quote2() 10 | quote3() 11 | quote4() 12 | } 13 | -------------------------------------------------------------------------------- /thanm/second.go: -------------------------------------------------------------------------------- 1 | // Copyright 2022 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func quote3() { 8 | println("MY SENSORS INDICATE TRACE AMOUNTS OF CHOCOLATE IN THE PANTRY. PLEASE LOAD") 9 | println("SOME IN MY SCOOP FOR ANALYSIS.") 10 | println("No, you'll spoil your appetite.") 11 | println("MY MISSION MUST NOT FAIL. PREPARE FOR ANNIHILATION, PITIFUL EARTH FEMALE.") 12 | println() 13 | } 14 | 15 | func quote4() { 16 | println("Never send a bunny to do a duck's job.") 17 | println() 18 | } 19 | -------------------------------------------------------------------------------- /thoeni/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package thoeni 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello Go, this should succeed") 11 | } 12 | -------------------------------------------------------------------------------- /tiago/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println(`Tiago says: 'Look! My very first "contribution" to a "proper" free-software project'`) 11 | } 12 | -------------------------------------------------------------------------------- /timburks/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("This is the year of Go on the desktop!") 11 | } 12 | -------------------------------------------------------------------------------- /tomasbasham/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /tommie/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Hello GopherCon UK!") 13 | } 14 | -------------------------------------------------------------------------------- /towerthousand/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("hello, towerthousand") 7 | } 8 | -------------------------------------------------------------------------------- /vanesa/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("GopherCon 2017 is awesome.") 11 | } 12 | -------------------------------------------------------------------------------- /vdemario/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Come to GopherCon Brasil 2018! From Sep 27th to 29th. https://gopherconbr.org/en") 11 | } 12 | -------------------------------------------------------------------------------- /venilnoronha/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello, GopherCon 2018!") 11 | } 12 | -------------------------------------------------------------------------------- /vickiniu/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The vickiniu command says hello! 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("wow wow wow") 12 | } 13 | -------------------------------------------------------------------------------- /virtualsue/asterisk.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | import "math/cmplx" 9 | 10 | func mandelbrot(a complex128) (z complex128) { 11 | for i := 0; i < 50; i++ { 12 | z = z*z + a 13 | } 14 | return 15 | } 16 | 17 | func main() { 18 | for y := 1.0; y >= -1.0; y -= 0.05 { 19 | for x := -2.0; x <= 0.5; x += 0.0315 { 20 | if cmplx.Abs(mandelbrot(complex(x, y))) < 2 { 21 | fmt.Print("*") 22 | } else { 23 | fmt.Print(" ") 24 | } 25 | } 26 | fmt.Println("") 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /vishen/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs correct functions?") 11 | } 12 | -------------------------------------------------------------------------------- /vivaperu/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This tool asserts the existence of the Proud Nation of Peru. 6 | package main 7 | 8 | import ( 9 | "fmt" 10 | ) 11 | 12 | func main() { 13 | fmt.Println("Viva Peru! 🇵🇪") 14 | } 15 | -------------------------------------------------------------------------------- /vsayer/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("this is the year of linux on the desktop!") 11 | } 12 | -------------------------------------------------------------------------------- /waits/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Spaces!") 11 | } 12 | -------------------------------------------------------------------------------- /walkert/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("Hello from walkert!") 13 | fmt.Println("We'll always have Denver..") 14 | } 15 | -------------------------------------------------------------------------------- /wallyqs/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello World!") 11 | } 12 | -------------------------------------------------------------------------------- /waltzofpearls/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // The waltzofpearls program that prints "hello!" to the console. 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("hello!") 12 | } 13 | -------------------------------------------------------------------------------- /wayneashleyberry/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | package main 5 | 6 | import "fmt" 7 | 8 | func main() { 9 | fmt.Println("Hello World!") 10 | } 11 | -------------------------------------------------------------------------------- /weeellz/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All Rights Reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // licence that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | func main() { 8 | println("Go is awesome") 9 | } 10 | -------------------------------------------------------------------------------- /wes/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello fellow Gophers!") 11 | } 12 | -------------------------------------------------------------------------------- /wfernandes/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println(`"A little nonsense now and then, is cherished by the wisest men." 11 | --Roald Dahl`) 12 | } 13 | -------------------------------------------------------------------------------- /whill/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /willmadison/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | // This package is a playground for contribution best practices 6 | package main 7 | 8 | import "fmt" 9 | 10 | func main() { 11 | fmt.Println("Hello, Welcome to scratch Will!") 12 | } 13 | -------------------------------------------------------------------------------- /wrrn/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("These stickers are awesome") 11 | } 12 | -------------------------------------------------------------------------------- /wselwood/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("who even needs fmt?") 11 | } 12 | -------------------------------------------------------------------------------- /wvides/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | ) 10 | 11 | func main() { 12 | fmt.Println("This is awesome, I changed my contribution!") 13 | } 14 | -------------------------------------------------------------------------------- /xiam/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2017 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("Hello world!") 11 | } 12 | -------------------------------------------------------------------------------- /ymotongpoo/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("this is a change!") 11 | } 12 | -------------------------------------------------------------------------------- /zaquestion/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import ( 8 | "fmt" 9 | "os" 10 | 11 | "github.com/adamryman/gophersay/gopher" 12 | ) 13 | 14 | func main() { 15 | fmt.Println("Learning to contribute to your favorite language at Gophercon 2018 is rad!") 16 | fmt.Printf("Heres a proverb:\n\n") 17 | gopher.Proverb(os.Stdout) 18 | } 19 | -------------------------------------------------------------------------------- /zaquestion/vendor/github.com/adamryman/gophersay/LICENSE.md: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /zaquestion/vendor/github.com/adamryman/gophersay/gopher/say.go: -------------------------------------------------------------------------------- 1 | package gopher 2 | 3 | import ( 4 | "fmt" 5 | "io" 6 | "log" 7 | "math/rand" 8 | "time" 9 | 10 | "github.com/adamryman/gophersay/gopherart" 11 | ) 12 | 13 | var ( 14 | sayings []string 15 | gopherArt string 16 | ) 17 | 18 | func init() { 19 | // Load in gopher ascii art from go-bindata 20 | gopherArtBytes, err := gopherart.Asset("gopherart/gopher.ascii") 21 | if err != nil { 22 | log.Fatal(err) 23 | } 24 | gopherArt = string(gopherArtBytes) 25 | sayings = []string{ 26 | "Don't communicate by sharing memory, share memory by communicating.", "Concurrency is not parallelism.", 27 | "Channels orchestrate; mutexes serialize.", 28 | "The bigger the interface, the weaker the abstraction.", 29 | "Make the zero value useful.", 30 | "interface{} says nothing.", 31 | "Gofmt's style is no one's favorite, yet gofmt is everyone's favorite.", 32 | "A little copying is better than a little dependency.", 33 | "Syscall must always be guarded with build tags.", 34 | "Cgo must always be guarded with build tags.", 35 | "Cgo is not Go.", 36 | "With the unsafe package there are no guarantees.", 37 | "Clear is better than clever.", 38 | "Reflection is never clear.", 39 | "Errors are values.", 40 | "Don't just check errors, handle them gracefully.", 41 | "Design the architecture, name the components, document the details.", 42 | "Documentation is for users.", 43 | "Don't panic.", 44 | } 45 | } 46 | 47 | func Proverb(w io.Writer) { 48 | rand.Seed(time.Now().UnixNano()) 49 | saying := sayings[rand.Intn(len(sayings))] 50 | Say(w, saying) 51 | } 52 | 53 | func Say(w io.Writer, saying string) { 54 | fmt.Fprintf(w, " ------------------------\n%s\n%s", 55 | saying, 56 | gopherArt, 57 | ) 58 | } 59 | -------------------------------------------------------------------------------- /zaquestion/vendor/github.com/adamryman/gophersay/gopherart/gopher.ascii: -------------------------------------------------------------------------------- 1 | ------------------------ 2 | \ 3 | \ 4 | \ ,_---~~~~~----._ 5 | _,,_,*^____ _____``*g*\"*, 6 | / __/ /' ^. / \ ^@q f 7 | [ @f | @)) | | @)) l 0 _/ 8 | \`/ \~____ / __ \_____/ \ 9 | | _l__l_ I 10 | } [______] I 11 | ] | | | | 12 | ] ~ ~ | 13 | | | 14 | | | 15 | 16 | -------------------------------------------------------------------------------- /zaquestion/vendor/github.com/adamryman/gophersay/gopherart/gopherart.go: -------------------------------------------------------------------------------- 1 | // Code generated by go-bindata. 2 | // sources: 3 | // gopherart/gopher.ascii 4 | // DO NOT EDIT! 5 | 6 | package gopherart 7 | 8 | import ( 9 | "bytes" 10 | "compress/gzip" 11 | "fmt" 12 | "io" 13 | "io/ioutil" 14 | "os" 15 | "path/filepath" 16 | "strings" 17 | "time" 18 | ) 19 | 20 | func bindataRead(data []byte, name string) ([]byte, error) { 21 | gz, err := gzip.NewReader(bytes.NewBuffer(data)) 22 | if err != nil { 23 | return nil, fmt.Errorf("Read %q: %v", name, err) 24 | } 25 | 26 | var buf bytes.Buffer 27 | _, err = io.Copy(&buf, gz) 28 | clErr := gz.Close() 29 | 30 | if err != nil { 31 | return nil, fmt.Errorf("Read %q: %v", name, err) 32 | } 33 | if clErr != nil { 34 | return nil, err 35 | } 36 | 37 | return buf.Bytes(), nil 38 | } 39 | 40 | type asset struct { 41 | bytes []byte 42 | info os.FileInfo 43 | } 44 | 45 | type bindataFileInfo struct { 46 | name string 47 | size int64 48 | mode os.FileMode 49 | modTime time.Time 50 | } 51 | 52 | func (fi bindataFileInfo) Name() string { 53 | return fi.name 54 | } 55 | func (fi bindataFileInfo) Size() int64 { 56 | return fi.size 57 | } 58 | func (fi bindataFileInfo) Mode() os.FileMode { 59 | return fi.mode 60 | } 61 | func (fi bindataFileInfo) ModTime() time.Time { 62 | return fi.modTime 63 | } 64 | func (fi bindataFileInfo) IsDir() bool { 65 | return false 66 | } 67 | func (fi bindataFileInfo) Sys() interface{} { 68 | return nil 69 | } 70 | 71 | var _gopherartGopherAscii = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x7c\x8e\x3d\x16\x82\x30\x10\x84\xfb\x9c\x62\x9e\x8d\x8f\xbc\x48\x3c\x02\xad\x67\x20\xb2\x54\xd8\xd0\xd8\x47\xce\xee\xec\xf2\x23\xc1\xa7\x03\x84\x64\xf6\xdb\xc9\xe2\xf2\x43\x0e\x40\xd2\x65\x59\x91\xf8\x05\x61\x65\x52\x29\x52\x0b\x56\x11\x91\x10\x24\xf8\x4e\xa8\xd9\xd3\x9d\xf4\xbd\x7f\xf8\x74\xf2\x81\x48\xa4\x15\x11\xcf\x56\xed\x6a\xd0\x58\x92\xbb\xe6\xc9\xff\x00\xd7\x02\xcd\x80\x8c\xa6\xaa\xb4\x92\xb1\xed\x47\xe0\x0a\xb6\x33\x27\xf5\xda\x98\x26\xbb\x4a\x43\x91\xec\xae\xb8\x8e\xe9\xac\x73\x93\x8c\xc2\x77\x67\xdc\x66\xe6\xf5\x71\x5a\x0b\x90\x7b\x09\x91\xd9\x3b\x0c\xcd\x45\xb0\x1e\x8e\x0c\x26\x3e\xdf\x4c\xd1\x76\x54\x9e\xe7\xf9\x0b\x19\xe3\xde\x01\x00\x00\xff\xff\xe9\x5c\x37\x0d\xaf\x01\x00\x00") 72 | 73 | func gopherartGopherAsciiBytes() ([]byte, error) { 74 | return bindataRead( 75 | _gopherartGopherAscii, 76 | "gopherart/gopher.ascii", 77 | ) 78 | } 79 | 80 | func gopherartGopherAscii() (*asset, error) { 81 | bytes, err := gopherartGopherAsciiBytes() 82 | if err != nil { 83 | return nil, err 84 | } 85 | 86 | info := bindataFileInfo{name: "gopherart/gopher.ascii", size: 431, mode: os.FileMode(436), modTime: time.Unix(1468565140, 0)} 87 | a := &asset{bytes: bytes, info: info} 88 | return a, nil 89 | } 90 | 91 | // Asset loads and returns the asset for the given name. 92 | // It returns an error if the asset could not be found or 93 | // could not be loaded. 94 | func Asset(name string) ([]byte, error) { 95 | cannonicalName := strings.Replace(name, "\\", "/", -1) 96 | if f, ok := _bindata[cannonicalName]; ok { 97 | a, err := f() 98 | if err != nil { 99 | return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err) 100 | } 101 | return a.bytes, nil 102 | } 103 | return nil, fmt.Errorf("Asset %s not found", name) 104 | } 105 | 106 | // MustAsset is like Asset but panics when Asset would return an error. 107 | // It simplifies safe initialization of global variables. 108 | func MustAsset(name string) []byte { 109 | a, err := Asset(name) 110 | if err != nil { 111 | panic("asset: Asset(" + name + "): " + err.Error()) 112 | } 113 | 114 | return a 115 | } 116 | 117 | // AssetInfo loads and returns the asset info for the given name. 118 | // It returns an error if the asset could not be found or 119 | // could not be loaded. 120 | func AssetInfo(name string) (os.FileInfo, error) { 121 | cannonicalName := strings.Replace(name, "\\", "/", -1) 122 | if f, ok := _bindata[cannonicalName]; ok { 123 | a, err := f() 124 | if err != nil { 125 | return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err) 126 | } 127 | return a.info, nil 128 | } 129 | return nil, fmt.Errorf("AssetInfo %s not found", name) 130 | } 131 | 132 | // AssetNames returns the names of the assets. 133 | func AssetNames() []string { 134 | names := make([]string, 0, len(_bindata)) 135 | for name := range _bindata { 136 | names = append(names, name) 137 | } 138 | return names 139 | } 140 | 141 | // _bindata is a table, holding each asset generator, mapped to its name. 142 | var _bindata = map[string]func() (*asset, error){ 143 | "gopherart/gopher.ascii": gopherartGopherAscii, 144 | } 145 | 146 | // AssetDir returns the file names below a certain 147 | // directory embedded in the file by go-bindata. 148 | // For example if you run go-bindata on data/... and data contains the 149 | // following hierarchy: 150 | // data/ 151 | // foo.txt 152 | // img/ 153 | // a.png 154 | // b.png 155 | // then AssetDir("data") would return []string{"foo.txt", "img"} 156 | // AssetDir("data/img") would return []string{"a.png", "b.png"} 157 | // AssetDir("foo.txt") and AssetDir("notexist") would return an error 158 | // AssetDir("") will return []string{"data"}. 159 | func AssetDir(name string) ([]string, error) { 160 | node := _bintree 161 | if len(name) != 0 { 162 | cannonicalName := strings.Replace(name, "\\", "/", -1) 163 | pathList := strings.Split(cannonicalName, "/") 164 | for _, p := range pathList { 165 | node = node.Children[p] 166 | if node == nil { 167 | return nil, fmt.Errorf("Asset %s not found", name) 168 | } 169 | } 170 | } 171 | if node.Func != nil { 172 | return nil, fmt.Errorf("Asset %s not found", name) 173 | } 174 | rv := make([]string, 0, len(node.Children)) 175 | for childName := range node.Children { 176 | rv = append(rv, childName) 177 | } 178 | return rv, nil 179 | } 180 | 181 | type bintree struct { 182 | Func func() (*asset, error) 183 | Children map[string]*bintree 184 | } 185 | 186 | var _bintree = &bintree{nil, map[string]*bintree{ 187 | "gopherart": &bintree{nil, map[string]*bintree{ 188 | "gopher.ascii": &bintree{gopherartGopherAscii, map[string]*bintree{}}, 189 | }}, 190 | }} 191 | 192 | // RestoreAsset restores an asset under the given directory 193 | func RestoreAsset(dir, name string) error { 194 | data, err := Asset(name) 195 | if err != nil { 196 | return err 197 | } 198 | info, err := AssetInfo(name) 199 | if err != nil { 200 | return err 201 | } 202 | err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755)) 203 | if err != nil { 204 | return err 205 | } 206 | err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode()) 207 | if err != nil { 208 | return err 209 | } 210 | err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime()) 211 | if err != nil { 212 | return err 213 | } 214 | return nil 215 | } 216 | 217 | // RestoreAssets restores an asset under the given directory recursively 218 | func RestoreAssets(dir, name string) error { 219 | children, err := AssetDir(name) 220 | // File 221 | if err != nil { 222 | return RestoreAsset(dir, name) 223 | } 224 | // Dir 225 | for _, child := range children { 226 | err = RestoreAssets(dir, filepath.Join(name, child)) 227 | if err != nil { 228 | return err 229 | } 230 | } 231 | return nil 232 | } 233 | 234 | func _filePath(dir, name string) string { 235 | cannonicalName := strings.Replace(name, "\\", "/", -1) 236 | return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...) 237 | } 238 | -------------------------------------------------------------------------------- /zombispormedio/main.go: -------------------------------------------------------------------------------- 1 | // Copyright 2018 The Go Authors. All rights reserved. 2 | // Use of this source code is governed by a BSD-style 3 | // license that can be found in the LICENSE file. 4 | 5 | package main 6 | 7 | import "fmt" 8 | 9 | func main() { 10 | fmt.Println("What's up, ladies and gentlemen? This is my github: https://github.com/Zombispormedio") 11 | } 12 | --------------------------------------------------------------------------------