Made a library? Written a blog post? Found a useful tutorial? Share it with the Go community here or just enjoy what everyone else has found!
Ben Johnson wrote Failure is your Domain post that explores the purpose of errors for app developers (error code), operators (stack trace), end users (human-readable message). https://github.com/marselester/ddd-err is an attempt to implement those ideas using Go kit.
New developers who come with Python/Ruby experience look for familiar framework concepts that fit their mental picture of how a web application should be structured. For some reason the same concepts do not resonate with Go. How to structure Go projects blog post shows that DDD (Domain-Driven Design) flavored approach is endorsed according to talks given at GopherCons.
Kafka for Gophers presentation provides an overview of how to achieve reliable data delivery with Apache Kafka in Go. If you've ever felt uneasy about what might happen with your service when a message is lost or written more than once, you should read "Kafka: The Definitive Guide" book. When it comes to choose a Go library to work with Kafka, the decision could be tough. I would recommend to check out https://github.com/segmentio/kafka-go.
Hey there,
If you use Buffalo and would like to deploy it to Google's App Engine, please visit this tutorial to find out more:
Hello,
Just a friendly reminder as the maintainer of this site, that our twitter integration is offline as Google recently discontinued the Google link service. We are transitioning to Firebase Dynamic links later this week. Also, posts will start to be moderated to ensure we deliver relevant and useful content to our Golang readers.
Thank you
Any questions email: feedback @ golangflow.io
Just to inform you that I’ve just released a first version of Generis, a lightweight code preprocessor adding the following features to the Go language :
https://github.com/senselogic/GENERIS
It’s similar in function to both Ego and Genny, but implemented as a free-form C++ like preprocessor.
Sample :
package main;
// -- IMPORTS
import (
"html"
"io"
"log"
"net/http"
"strconv"
);
// -- DEFINITIONS
#define DebugMode
#as true
// ~~
#define HttpPort
#as 8080
// ~~
#define WriteLine( {{text}} )
#as log.Println( {{text}} )
// ~~
#define local {{variable}} : {{type}};
#as var {{variable}} {{type}};
// ~~
#define DeclareStack( {{type}}, {{name}} )
#as
// -- TYPES
type {{name}}Stack struct
{
ElementArray []{{type}};
}
// -- INQUIRIES
func ( stack * {{name}}Stack ) IsEmpty(
) bool
{
return len( stack.ElementArray ) == 0;
}
// -- OPERATIONS
func ( stack * {{name}}Stack ) Push(
element {{type}}
)
{
stack.ElementArray = append( stack.ElementArray, element );
}
// ~~
func ( stack * {{name}}Stack ) Pop(
) {{type}}
{
local
element : {{type}};
element = stack.ElementArray[ len( stack.ElementArray ) - 1 ];
stack.ElementArray = stack.ElementArray[ : len( stack.ElementArray ) - 1 ];
return element;
}
#end
// ~~
#define DeclareStack( {{type}} )
#as DeclareStack( {{type}}, {{type:PascalCase}} )
// -- TYPES
DeclareStack( string )
DeclareStack( int32 )
// -- FUNCTIONS
func HandleRootPage(
response_writer http.ResponseWriter,
request * http.Request
)
{
local
boolean : bool;
local
natural : uint;
local
integer : int;
local
real : float64;
local
escaped_text,
text : string;
local
integer_stack : Int32Stack;
boolean = true;
natural = 10;
integer = 20;
real = 30.0;
text = "text";
escaped_text = "<escaped text/>";
integer_stack.Push( 10 );
integer_stack.Push( 20 );
integer_stack.Push( 30 );
#write response_writer
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title><%= request.URL.Path %></title>
</head>
<body>
<% if ( boolean ) { %>
<%= "URL : " + request.URL.Path %>
<br/>
<%@ natural %>
<%# integer %>
<%& real %>
<br/>
<%~ text %>
<%= escaped_text %>
<%= "<%% ignored %%>" %>
<%% ignored %%>
<% } %>
<br/>
Stack :
<br/>
<% for !integer_stack.IsEmpty() { %>
<%# integer_stack.Pop() %>
<% } %>
</body>
</html>
#end
}
// ~~
func main()
{
http.HandleFunc( "/", HandleRootPage );
#if DebugMode
WriteLine( "Listening on http://localhost:HttpPort" );
#end
log.Fatal(
http.ListenAndServe( ":HttpPort", nil )
);
}
gookit/config - Go config management. support JSON, YAML, TOML, INI, HCL, ENV and Flags. Multi file load, data override merge, parse ENV var.
JSON
(default), INI
, YAML
, TOML
, HCL
JSON
content support comments. will auto clear commentsflags
)map.key
arr.2
envKey: ${SHELL}
-> envKey: /bin/zsh
Get
Int
Uint
Int64
Float
String
Bool
Ints
IntMap
Strings
StringMap
...Provide a sub-package
dotenv
that supports importing data from files (eg.env
) to ENV
txeh is a golang library and command line utility for working with /etc/hosts.
A computer's /etc/hosts file is a powerful utility for developers and system administrators to create localized, custom DNS entries. This small go library and utility were developed to encapsulate the complexity of working with /etc/hosts directly by providing a simple interface for adding and removing entries in a /etc/hosts file.
Analogue to testing that a window can be opened in a house, you don't want to spend time building the house first. Instead you want to say: I need a house with a window and then you test the opening functionality. This is the approach we took with our framework for setting up objects to be tested using recipes, ingredients and special preparation (if needed).
https://developers.redhat.com/blog/2017/09/19/manage-test-dependencies-go/
https://github.com/nitishm/go-rejson
Instead of saving structs as json strings, use redislabs' ReJSON module with Redis Server to interact natively with JSON objects
ReJSON is a Redis module that implements ECMA-404 The JSON Data Interchange Standard as a native data type. It allows storing, updating and fetching JSON values from Redis keys (documents).
Go-ReJSON is the only go client library that supports both redigo and go-redis clients, and plans to support more redis Go clients in the future.
PRs are welcome !
I am looking for contributors to help me out with my latest project.
I am creating an HTTP server implementation, driven by a REST API, for the https://github.com/tsenart/vegeta load testing tool. Currently it is only available as a CLI tool. However, there is an excellent library provided by the author, which is used by the CLI tool.
The idea is to create a tool, using vegeta, which is similar to https://github.com/loadimpact/k6 or https://github.com/locustio/locust complete with a UI (frontend). This makes it possible to use this tool in a more distributed manner, and possibly introduce it as a kubernetes native load-testing tool.
The project is available at https://github.com/nitishm/vegeta-server and currently supports submitting/viewing/canceling attack
s (all options are not implemented, yet) and viewing the attack report
s.
Issues are tagged with appropriate labels.
gookit/color - command-line color library with true color support, universal API methods and Windows support.
Print
, Printf
, Println
, Sprint
, Sprintf
<green>message</>
Bold
, Black
, White
, Gray
, Red
, Green
, Yellow
, Blue
, Magenta
, Cyan
Info
, Note
, Light
, Error
, Danger
, Notice
, Success
, Comment
, Primary
, Warning
, Question
, Secondary
https://github.com/yujiahaol68/captchy
Still in DEV. Any issue and feature request is welcomed! Please star if you think it is helpful.