Amateur Tip

[amateurtip]

Enable SOCKS proxy on macOS from command line

It is pretty common to use your VPS as a proxy server when necessary with a command like the following:

ssh -ND <port> <username>@<address>

Then you normally would click on your Wi-Fi icon, then "Open Network Preferences", then "Advanced...", then "Proxies" tab, then enable "SOCKS Proxy" and type the port.

Although it is not the most difficult process, it requires too many clicks for my taste, especially since I am setting up the ssh tunnel on terminal anyway.

Good news is you can do it vith a one-liner:

sudo networksetup -setsocksfirewallproxy 'Wi-Fi' localhost <port> off

This is literally all you need. If you're too lazy to memorise this or you'd like to combine connecting and turning proxy on together, I suggest you make an alias in your shell configuration file. One example would be

alias socksproxyon='sudo networksetup -setsocksfirewallproxy 'Wi-Fi' localhost 8080 off && ssh <username>@<address> -ND 8080'

This does the tunneling over port 8080 of your localhost provided that you fill in the username and the server address.

Further laziness leads to a socksproxyoff command like so:

alias socksproxyoff='sudo networksetup -setsocksfirewallproxystate 'Wi-Fi' off'

[amateurtip]

VIM everywhere!

If you like VI, you might developed an impulse for using hjkl with for movement not only in your editor, but everywhere. It might pay off to act on this impulse.

The developers in big companies also seem to be fans of VI and increasingly integrates some navigation functionality into their websites.

When streams of information are present at the very least h and k characters are bound to up and down navigations. Examples include Facebook, Twitter, and Tumblr (not only for your homepage but also in blogs with the default template).

Facebook and Twitter additionally offers other keys for keyboard only usage, such as favouriting/liking a post with l. Facebook uses s for share, and Twitter uses r for retweet. Similarly, the former uses c to open a new comment and the latter uses r to reply.

You might like to consult to the keyboard shortcuts guide of your choice of procrastination. For efficiency?

[amateurtip]

The lesser known ruby option: -n

You have probably used or at least learnt about -e that allows you to execute a string directly as an argument to ruby binary.

$ ruby -e "puts 'Hello, world!'"

You may have also used -c to do syntax check on your script without running them.

$ ruby -c <script>

If you are old enough, you may have also needed to use -r to import rubygems, cleverly named ubygems so that the option becomes -rubygems.

But today I want to show you the almost forgotten -n that reflects Ruby's Perl heritage. If you type ruby -h you will see that -n "assumes 'while gets(); ... end' loop around your script." This reflects Ruby's humble origin as a text processor scripting language. It enables you to use scripts that are written to process a single record to be generalised into many! Let's see an example of this option on a file called ruby_heroes.txt. We will use a simple script called heroify.rb to process and output each line:

ruby_heroes.txt:

Charles Nutter Avdi Grimm Richard Schneeman Kōichi Sasada

heroify.rb:

name = $_.chomp puts "#{name.upcase} is a hero!"

Then when you run

$ ruby -n heroify.rb < ruby_heroes.txt

The output becomes

CHARLES NUTTER is a hero! AVDI GRIMM is a hero! RICHARD SCHNEEMAN is a hero! KŌICHI SASADA is a hero!

If you do not know what $_ is, don't worry. I can't quite remember what most global variables in Ruby stand for either, but that's why we have English library. You can use it for a more meaningful name or you can use ri English to look up what global variables correspond to. $_ is $LAST_READ_LINE.

The only problem I have with $LAST_READ_LINE is that it is not an accurate name. Unlike what most people think gets retrieves a record via some input record seperator (aka. $/, $INPUT_RECORD_SEPARATOR). If you don't believe me execute this line:

echo 'hello(^_^)hi' | ruby -e "\$/ = '(^_^)'; puts gets.chomp"

You can shorten this even further via Kernel#chomp as opposed to String#chomp, which implicitly works on $_ and removes the input record separator as opposed to the newline character, the default values of $/.

Now I think -n is most useful when you combine it with -0 and -e to write powerful one-liners. If you are writing a script in a file, you might as well put the processing loop rather than relying on a bunch of global variables, but for quick processing -0 allows you to enter a field separator using octal character code (consult man ascii on your terminal) and -e lets you quickly specify the processing code. Here's an example:

ruby_heroes_colon.txt

Charles Nutter:Avdi Grimm:Richard Schneeman:Kōichi Sasada

When you use the following line it will separate the heroes, and print the heroified versions.

$ ruby -072 -n -e 'puts "#{chomp.upcase} is a hero!"' < ruby_heroes_colon.txt

Pretty slick, huh?

[amateurtip]

Setting interpreter for your executable script properly

If you have programmed in so called scripting languages such as Ruby or Python, you probably have already realised you can make your scripts executable via chmod +x.

Unlike compiled languages, you need a special comment on top of the file to help the shell find the interpreter for your program. This line is called the shebang or the hashbang. Here is what it might look like for a Ruby file:

#! /usr/bin/ruby

You migth be already using this line and if you are this is probably not the best way of doing things. The problem is that this absolute path calls a specific Ruby version unless the path itself is a symlink that gets modified over time. On different systems this path might not even exist.

A better approach is to use env utility. It calls the argument utility supplied to it with respect to the current environment. So the proper shebang is

#! /usr/bin/env ruby

This calls env and supplies ruby as the utility it should call. Since ruby here is not an absolute path, PATH environment variable is used to resolve the location of ruby binary. So if you have a version manager such as rbenv, rvm, or chruby, those can modify either the PATH environment variable or the files directed by PATH to change versions.

You might be wondering why go through env to search the executable using PATH since that is what happens when you type ruby in your shell anyway. The reason is executables are executed using execve (good alliteration, isn't it?), which either requires a binary, or a file with a shebang. If it is a shebang, then it demands that the interpreter location is a valid path in the file system. Since ruby on its own is not a valid path unless you are in the directory of ruby executable, we go through env.

[amateurtip]

Use VI key bindings in your terminal

By default your terminal probably uses Emacs bindings. Such as CTRL-A to go to the beginning of the shell command you are writing, or CTRL-Z to go to the end.

If you are a VIM lover like myself you might as well put your hard-earned VI key binding usage into good use. The following commands will immediately change these bindings by appending a shell option to your shell configuration file:

echo "set -o vi" >> ~/.bashrc source ~/.bashrc

If you are using a different shell you might have a different configuration file in your HOME such as .zshrc for ZSH.

Now you can start typing press ESC to enter normal mode and use all your loving key bindings. It even allows you to enter visual mode, which I find particularly useful for replacing and cutting parts of commands.

[amateurtip]

Locate most segmentation faults with a one-liner

If you write C programs, you probably have already used GDB or at least heard of it. Even if you feel attached to it, I suggest you to give LLDB a go. In my experience, it is much more stable (remember that time you lost all your debugging progress because your session got messed up or GDB outright crashed... yeah...) and consistent in its functionality. Obviously, it has about 30 years of hindsight to help!

The following general syntax when used with a program compiled with at least -g option on your favorite compiler, prints out where it thinks the error happens and a stack trace with meaningful names, then exits.

$ lldb -b <program_name> [<arg>..] -o "r" -k "bt" -k "q"

The caveat is there are bugs living in deeper circles of hell that corrupt your memory in ways so unimaginable that the stack frames are corrupted and you don't get a legible output back. Yet, it will work most of the time!

Here's a simple example that dereferences the NULL pointer, crashes, and burns.

// crash_and_burn.c #include <stdio.h> void crash(char *str); void burn(char *str); int main(int argc, char *argv[]) { char *null_str = 0; printf("%s\n",argv[1]); printf("%s\n",argv[2]); crash(null_str); return 0; } void crash(char *str) { burn(str); } void burn(char *str) { *str = 'M'; }

It is compiled with the following:

$ gcc -g crash_and_burn.c -o crash_and_burn

and debugged with the following:

$ lldb -b crash_and_burn HELLO! HI! -o "r" -k "bt" -k "q"

Here's the full output:

(lldb) target create "crash_and_burn" Current executable set to 'crash_and_burn' (x86_64). (lldb) settings set -- target.run-args "HELLO!" "HI!" (lldb) r HELLO! HI! Process 77826 stopped * thread #1: tid = 0x6cc3c3, 0x0000000100000f8c crash_and_burn`burn(str=0x0000000000000000) + 12 at crash_and_burn.c:22, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=1, address=0x0) frame #0: 0x0000000100000f8c crash_and_burn`burn(str=0x0000000000000000) + 12 at crash_and_burn.c:22 19 } 20 21 void burn(char *str) { -> 22 *str = 'M'; 23 } Process 77826 launched: '/Users/mistralcontrastin/p/c/playground/crash_and_burn' (x86_64) (lldb) bt * thread #1: tid = 0x6cc3c3, 0x0000000100000f8c crash_and_burn`burn(str=0x0000000000000000) + 12 at crash_and_burn.c:22, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=1, address=0x0) * frame #0: 0x0000000100000f8c crash_and_burn`burn(str=0x0000000000000000) + 12 at crash_and_burn.c:22 frame #1: 0x0000000100000f75 crash_and_burn`crash(str=0x0000000000000000) + 21 at crash_and_burn.c:18 frame #2: 0x0000000100000f4c crash_and_burn`main(argc=3, argv=0x00007fff5fbff678) + 92 at crash_and_burn.c:12 frame #3: 0x00007fff95fb15ad libdyld.dylib`start + 1 frame #4: 0x00007fff95fb15ad libdyld.dylib`start + 1 (lldb) q

As you can see you have everything from the source line that crashed it to the function calls leading to it with their arguments at the time!

If you're interested in dissecting the one-liner, check lldb --help for options and [0] for their arguments (the link is especially useful for GDB afficionados).

[0] http://lldb.llvm.org/lldb-gdb.html

[amateurtip]

Deleting a temporary file while still maintaining access

/tmp directory is useful and popular location for intermediate files and most programming languages provide standard libraries to access it. However, it is infamous for many security vulnerabilities due to public nature of the directory.

One way to reduce the chance of the file getting modified by a malicious entity is... wait for it... deleting it! Well, you got me wrong. I mean deleting it right after creating the temporary file. This is allowed on POSIX systems through unlink system call. The downside is that you won't be able to use the pathname of the temporary file and be left with a file descriptor. It is still possible to share file descriptors with other processes but that is a story for another day.

Here's an example of how it might work in Ruby:

require 'tempfile' tmp = Tempfile.new # Delete the file but do not close it tmp.unlink tmp.write "Hello, world!" tmp.rewind tmp.read #=> "Hello, world!" # Now relinquish the file descriptor and truly close the file. tmp.close

[amateurtip]

Work around Twitter app not showing favourites on iPhone

This is only a temporary solution that works until you close the app. Hopefully, Twitter will fix it soon. It also gets rid of hanging push notifications due to non-mention interactions.

Go to “Notifications” tab

Click on settings (gear on top left)

Toggle “Quality filter” back and forth

Click done