Today I Learned

A very naive yet effective approach on metaprogramming that helps you dynamically call the right method in a very concise manner.

$method = $user instance of User ? 'save' : 'saveMany';

$this->members()->$method($user);

The example is an excerpt from a dummy Laravel app.

By making use of Sets and the spread operator, we can quickly strip the duplicates with a Set then turn it back into an array in no time.

[…new Set([1, 'Graffino', 1, 'Graffino', "Wha!"])];

Will return: [1, "Graffino", "Wha!"]

Phoenix schema: ArgumentError - invalid or unknown type :text for field

:text can be used in migrations, but not when describing the schema in the model. Use :string instead.

Sometimes, as a programmer, you might need to write something to a file on the local file system. And that can be a piece of cake, case in which you'll use your favorite text editor to do it manually, but other times, it needs to be something complex and dynamic and you want your JavaScript to do it for you.

Here's how:

We'll first require the fs module from Node.js into our JS file.

const fs = require('fs');

Then we'll grab our content:

const content = 'Hello World!';

And finally we'll use the writeFile function from the fs module to populate our file. We need to provide the name of our file, the data or content to populate it with, the options (optional - for encoding, modes or flags) and a callback (also optional - to show the error message should one arise).

fs.writeFile(filename, data, [options], [callback]);

Here I've given it the a+ flag - "Open file for reading and appending. The file is created if it does not exist.". The encoding defaults to 'utf8' if none is given.

fs.writeFile('file.txt', content, { flag: 'a+' }, (err) => {
  if (err) throw err;
});

If you ever seen this in the wild:

{:ok, assign(socket,
      %{my_variable: @my_variable
        my_other_variable: nil.
        yet_another_variable: nil 
      })}

Remember that applying elixir's pipe operator makes everything better:

def mount(_session, socket) do
    socket =
      socket
      |> assign(:my_variable, @my_variable)
      |> assign(:my_other_variable, nil)
      |> assign(:yet_another_variable, nil)
    {:ok, socket}
end

No, this has nothing to do with those delicious Indian curry dishes you might be thinking about, but with a functional technique used in JavaScript.

It seems confusing at first, but currying is simple. If you've never heard of it before, it's because this concept isn't native to JS.

Basically, it allows you to transform a function like f(a, b, c) into something like f(a)(b)(c). What that means is that you can split up a function with multiple arguments into a sequence of functions with one argument each.

Let's take a basic example.

const newUser = function(name, age, skill) {
  return {
    name,
    age,
    skill
  }
}
	
newUser("John", 27, "JS")

Now to the curry part:

const newUser = function(name) {
  return function(age) {
    return function(skill) {
      return {
        name,
        age,
        skill
      }
    }
  }
}
	
newUser("John")(27)("JS")

Add in some arrow functions and voila:

const newUser = 
  name => 
    age => 
      skill =>
      {
        name,
        age,
        skill
      }

The purpose of all this you might ask?

Think about situations when you don't have the complete data available in the beginning and you still need your function to gradually pass through your app and receive its arguments step by step as more and more data is arriving, until you add the final argument and receive the output.

As a developer, you frequently find yourself in the position when you forgot a certain syntax or you just want to see some quick code snippet to implement certain functionality. No need to google it now, you don't even need to leave your favorite terminal, welcome cheat.sh.

Usage:

curl cheat.sh/programming_language/query_string

curl cheat.sh/python/random+list+elements

Used to mark specific commits on git and often used to mark product releases on Github, git tags are important. But sometimes, you just need to delete them.

Here's a simple way to do that:

• Delete all remote tags

git tag -l | xargs -n 1 git push --delete origin

• Delete local tags

git tag | xargs git tag -d

• Check if any tags are left

git tag

On Apple keyboards we don't have an Insert key, and this is most annoying when using the command line or CLI tools like Midnight Commander.

We can fix this by re-assigning the F12 key:

• Remove F12 as key from System Settings->Mission Control
• Enable Use F1, F2, etc. keys as standard function keys in System Settings->Keyboard->Keyboard
• Go to Terminal->Preferences and set the default profile as Pro
• Go to Terminal->Preferences->Profiles->Keyboard and Replace F12 code with \033[2~

We need to tell macOS to add the keys to the agent, in order to make them persistent after reboot.

We have to create new file in ~/.ssh/ called config

vi ~/.ssh/config

with the following content:

Host *
   AddKeysToAgent yes
   UseKeychain yes   

Then, we need to add our keys to the agent and macOS keychain (so your private key password is remembered).

ssh-add -D
ssh-add -K ~/.ssh/*

To verify that our keys are present in the agent:

ssh-add -l