| #!/bin/bash | |
| # Configuration for the script | |
| POSTFIX_CONFIG=/etc/postfix/main.cf | |
| POSTFIX_SASL=/etc/postfix/sasl_passwd | |
| function confirm () { | |
| read -r -p "${1:-Are you sure? [Y/n]} " response | |
| if [[ $response == "" || $response == "y" || $response == "Y" ]]; then | |
| echo 0; |
| package main | |
| import ( | |
| "testing" | |
| "github.com/stretchr/testify/assert" | |
| ) | |
| func TestMain(m *testing.M) { | |
| // before spec | |
| err := m.Run() |
| # Go parameters | |
| GOCMD=go | |
| GOBUILD=$(GOCMD) build | |
| GOCLEAN=$(GOCMD) clean | |
| GOTEST=$(GOCMD) test | |
| GOGET=$(GOCMD) get | |
| BINARY_NAME=mybinary | |
| BINARY_UNIX=$(BINARY_NAME)_unix |
This is a story about how I tried to use Go for scripting. In this story, I’ll discuss the need for a Go script, how we would expect it to behave and the possible implementations; During the discussion I’ll deep dive to scripts, shells, and shebangs. Finally, we’ll discuss solutions that will make Go scripts work.
While python and bash are popular scripting languages, C, C++ and Java are not used for scripts at all, and some languages are somewhere in between.
You may want a linter plugin to lint your code in Vim but you probably don't need it. At least try the built-in way before jumping on the plugin bandwagon.
autocmd FileType <filetype> setlocal makeprg=<external command>
This autocommand tells Vim to use <external command> when invoking :make % in a <filetype> buffer. You can add as many similar lines as needed for other languages.
Past August 2024, Authy stopped supported the desktop version of their apps:
See Authy is shutting down its desktop app | The 2FA app Authy will only be available on Android and iOS starting in August for details.
And indeed, after a while, Authy changed something in their backend which now prevents the old desktop app from logging in. If you are already logged in, then you are in luck, and you can follow the instructions below to export your tokens.
If you are not logged in anymore, but can find a backup of the necessary files, then restore those files, and re-install Authy 2.2.3 following the instructions below, and it should work as expected.
| org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines=2147483647 | |
| org.eclipse.jdt.core.formatter.align_type_members_on_columns=false | |
| org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16 | |
| org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0 | |
| org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=16 | |
| org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16 | |
| org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16 | |
| org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16 | |
| org.eclipse.jdt.core.formatter.alignment_for_assignment=0 | |
| org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16 |
The following are examples of the four types rate limiters discussed in the accompanying blog post. In the examples below I've used pseudocode-like Ruby, so if you're unfamiliar with Ruby you should be able to easily translate this approach to other languages. Complete examples in Ruby are also provided later in this gist.
In most cases you'll want all these examples to be classes, but I've used simple functions here to keep the code samples brief.
This uses a basic token bucket algorithm and relies on the fact that Redis scripts execute atomically. No other operations can run between fetching the count and writing the new count.
| #!/bin/bash | |
| git clone [email protected]:BVLC/caffe.git | |
| cd caffe | |
| brew install -vd snappy leveldb gflags glog szip lmdb | |
| brew install --build-from-source --with-python3 -vd protobuf | |
| brew install --build-from-source --with-python3 -vd boost159 boost-python159 | |
| curl https://gist.githubusercontent.com/jpgehrig/92e38396f855cd1f1c911a0da07f8aef/raw/ > Makefile.config |
Go has excellent build tools that mitigate the need for using make.
For example, go install won't update the target unless it's older
than the source files.
However, a Makefile can be convenient for wrapping Go commands with
specific build targets that simplify usage on the command line.
Since most of the targets are "phony", it's up to you to weigh the
pros and cons of having a dependency on make versus using a shell
script. For the simplicity of being able to specify targets that
can be chained and can take advantage of make's chained targets,