ALIAS

alias

*nix Aliases We all know how aliases on the *nix system help to create short commands for the long ones. E.g. can stand for or for . Software associates create such aliases and write them in the file. So aliases are available whenever they logged in to their machine. kga kubectl get all gl git log --name-status --decorate ~/.bashrc The Challenge However, associates also need to log in to other *nix machines for various purposes. Say a developer needs to log in to the SV system for live troubleshooting of an issue. Or a DevOps Engineer requires to log in to various cloud VMs. One has become very used to his/her alias s/he has created. It's very difficult to copy/paste the aliases every time s/he logs in to the another machine. The Solution Here is one way to address this challenge. Create your aliases, categorize and put them in different files. Say , , etc. Then create a file. Download it on the machine you have logged in. General Aliases Git Aliases Docker Aliases setaliases.sh wget https://raw.githubusercontent.com/simplyatul/bin/master/setaliases.sh and then source it source setaliases.sh That's it. All your aliases are set. If you are frequently logging in to a particular machine, then just copy the above source command in the file. ~/.bashrc Also published . here

Bash Aliases: Take Them With You

How to Configure Path Aliases in Frontend Projects in the Native Way

নেটিভ উপায়ে ফ্রন্টেন্ড প্রকল্পগুলিতে পথ উপনামগুলি কীভাবে কনফিগার করবেন

So konfigurieren Sie Pfadaliase in Frontend-Projekten auf native Weise

Cómo configurar alias de ruta en proyectos frontend de forma nativa

Comment configurer les alias de chemin dans les projets frontaux de manière native

नेटिव तरीके से फ्रंटएंड प्रोजेक्ट्स में पाथ एलियासेस को कैसे कॉन्फ़िगर करें

ネイティブな方法でフロントエンド プロジェクトのパス エイリアスを構成する方法

기본 방식으로 프런트엔드 프로젝트에서 경로 별칭을 구성하는 방법

Como configurar aliases de caminho em projetos de front-end da maneira nativa

Ön Uç Projelerinde Yol Takma Adlarını Yerel Şekilde Yapılandırma

Cách định cấu hình bí danh đường dẫn trong các dự án giao diện người dùng theo cách bản địa

如何以原生方式在前端项目中配置路径别名

Setting up an Alias Repeating the same git commands over and over again can be such a waste of time! And some of the most powerful ones are usually quite long and impossible to memorize. That’s why aliases have been introduced! Setting up an alias is really simple, just open up a terminal and type git config --global alias.[commandName] [long command] For example: git config --global alias.st 'status' In this case, if I call , it will give me the result of . git st git status Ok, this was easy, but what about long commands such as this one? log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit You don’t want to write it every single time, right? Just run this: git config —global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit" And you never have to remember this long command again! Look at how cool and colorful this log is, by just using : git lg Understanding Aliases If with these two examples, you agree with me that aliases are cool, let me give you some more information you should have, in order to use aliases mindfully. Later on, I’ll also share with you a list of other smart aliases you might find useful. You can find everything in the video down below, where I also show: How to easily edit aliases without setting them from terminal How to use the bang operator (aka exclamation mark) ! How this weird syntax is useful: "!f(){ [some commands here] }; f" A list of cool aliases to set up for you See aliases in action You can watch the video on YouTube, or directly here from the embedded player: https://youtu.be/Uk4GnYoQx_I?embedable=true Also published . here If you have some cool aliases to share, feel free to drop them here in a comment, thank you!

🕵️‍♂️ Learning to Use Git Alias to Boost Your Productivity

Content Introduction Existing versioning Immutable Versions Understanding $LATEST Understanding the Lambda ARN Pros and Cons Static versioning qualified ARN Dynamic versioning $LATEST What Makes AWS Lambda Alias different? Mapping out the AWS compute solutions AWS Lambda Alias Example AWS Lambda Alias IAM Gotcha Advanced deployments Traffic shifting AWS Codedeploy Conclusion Introduction AWS Lambda Alias is a feature that makes it easier to manage your lambda function versions. It works by creating a “container” that points to a published version of your lambda function. There are a few benefits to this: You can have safer deployments in your Software Development Lifecycle (SDLC) You can have dynamic references lambda function versions In this guide, we will talk about the existing versioning strategies used by AWS Lambda, and then look at why AWS Lambda alias is a better choice. Let’s dive right in. Existing versioning Immutable versions By default, when you publish changes on your lambda function, it creates a new version. This new version is considered to be immutable, meaning that you cannot change its identifier (ARN) or the function code once it is published. Understanding $LATEST In addition to the immutability of the versions, AWS Lambda automatically promotes the latest version to a default alias . $LATEST This is important to understand in the later sections when we start to discuss the AWS resource identifier (ARN) used when referencing a lambda resource. Understanding the Lambda ARN Within AWS, each resource can be identified with a unique resource identifier (ARN). With AWS Lambda, it is the same, but it does have some subtle differences. AWS Lambda separates the AWS resource identifier (ARN) into two types: - versioned Qualified ARN - does not include version (points to alias) Unqualified ARN (Default) $LATEST It is important to distinguish between the two because they determine which lambda function version they will reference. When you use a , you are referencing a specific version of the lambda function. ”qualified ARN” While the is a reference to the latest version of lambda (this is done via the alias). ”unqualified ARN” $LATEST The difference is quite subtle, but it is important to make this distinction because you may reference an AWS lambda ARN and then have it changed when someone else makes a new code change. Each of these has its respective pros and cons which we will discuss in the next section. Example (qualified ARN): arn:aws:lambda:aws-region:acct-id:function:myFunction:42 Example (unqualified ARN): arn:aws:lambda:aws-region:acct-id:function:myFunction ⚠️ An will always point to the latest published version via the alias Unqualified Lambda ARN $LATEST Pros and Cons Static versioning (qualified ARN) The biggest pro of static versioning is also its biggest con. With static versioning, you do have more control over which version of the AWS lambda function you will be pointing to. This allows for safer deployments because you decide which versions are promoted in your infrastructure. However, this also locks you in and requires you to make subsequent updates to any resources referencing it (i.e. API gateway, event source integrations). Pros: Safe deployments Cons: Subsequent updates are required for resources Dynamic versioning - $LATEST (unqualified ARN) This is the opposite of static versioning, where you have a lot of flexibility in terms of referencing the Lambda function versions because it always gets updated via . $LATEST However, this workflow may be risky because you are automatically promoting any new version of your Lambda function into a live environment without any testing. Pros: Subsequent updates are not required for resources Cons: Risky deployments (latest versions are always used) In a typical Software development lifecycle (SDLC), ideally, you will go through the build (continuous integration) and then do some testing; then, go live once you are ready. So, is there a better choice? Yes, of course! This is where AWS Lambda alias comes in. What makes AWS Lambda Alias different? Lambda alias is a custom named “container” that points to a specific version of your Lambda function. The version referenced in an alias can be updated at any time. This gives you flexibility as well as safety because you can promote a version whenever it is considered ready to go live. In addition, any references to the alias will always point to a target version. So, with this setup, there is no need to make updates to any other resource referencing the ARN! Pros: Subsequent updates are not required for other resources Safe deployments (you are in control of the reference) With the Lambda alias, you get the best of both worlds! AWS Lambda Alias example Here is an example of using a lambda alias. In your workflow, you can have separate stages (or alias) which can be: - for development and testing purposes dev - for live environment prod Then as you run your CI/CD, you can update each of the alias accordingly. The workflows will depend on the CI tool. Using the AWS CLI, you can achieve this by running: aws lambda update-alias \
    --function-name "myFunction" \
    --name "prod" \
    --function-version "2" AWS Lambda Alias IAM Gotcha There is a small gotcha with AWS Lambda Alias, and it is related to what you need to reference in your IAM permissions and policies. - should reference the ARN of the lambda alias to provide invoke permissions Event source (API gateway, event triggers, etc.) - should reference the ARN of the Lambda function Run time permissions (Access to S3, DB, etc.) ❗️ Just keep this in mind when using AWS Lambda Alias Advanced deployments Traffic shifting configuration There are also other benefits to using a lambda alias, these include advanced deployment patterns which AWS offers natively. By default, the AWS CLI for lambda supports traffic shifting (or weighted deployment) where you can split the traffic between two versions using a percentage (%). Using the AWS CLI, you can achieve this by running: aws lambda update-alias \
    --function-name "myFunction" \
    --name "prod" \
    --function-version "2" \
    --routing-config AdditionalVersionWeights={"2"=0.1} This means 10% of traffic will be shifted to version 2 while the rest of the 90% will stay on version 1. AWS Codedeploy AWS Codedeploy also supports lambda releases with canary deployments where you can delegate deployment to AWS Codedeploy. It will still make use of the traffic shifting, however, the eventual goal is to shift 100% over to the target resource. AWS Codedeploy also supports automatic rollback based on AWS Cloudwatch metrics during the canary rollout phase. Conclusion To recap, AWS Lambda alias bridges the gap between the existing solutions, using static and dynamic versioning. This allows for flexibility when promoting the versions, hence the safety of the deployments. Finally, any references to the lambda function ARN do not need to be updated when using an alias! This makes it a much better choice in general where you get the best of both worlds! Here is a quick summary of the versioning strategies:

AWS Lambda Alias: An Essential Guide 

While I write OOP code I apply some practices of Elegant Objects. One of them is that classes should be final. This means that they cannot be extended through inheritance but only through composition. The advantage is simplicity. I mean that, in this way, each object is seen as a cohesive block. What interest to its clients is its exposed behaviour. Nothing more. Instead, through extension, a client can break it. For instance, an object can interrelate two of its methods. So, if we can replace through extension one of them we can break the other. For this reason, to be sure, we should check its implementation. In this way we increase coupling between the extended and the extension. In other words, final classes enforces the idea that we should care only of exposed behaviour. And not of implementation. Nonetheless, it requires a change of how we reason about them. The Alias pattern simplifies an aspect of this change. Intent The Alias pattern allows to extend the way a class can build its objects without subclassing or modifying it. Motivation Suppose a final class that creates its objects using some mandatory parameters. How can we add another way to create its objects? For instance, how we can add a constructor that use a default value for one or more of its missing parameters? One approach could be to add another constructor to the class. But this could get out of hand. Furthermore, it could be not possible. For instance, the aforesaid final class could be in an external library. Another drawback of this approach is that we can pollute the final class. For instance, we can have a final class that builds its objects given a JSON. But after some time we need to add also XML. As you can imagine adding the code to map XML to JSON will pollute inevitably that class. However, the Alias pattern isn’t limited to final classes. For instance, we cannot have two constructors with same parameters but different semantic. To resolve this issue we can add static factory methods to the class code. But the same aforesaid drawbacks affects this approach. That is: this gets out of hand; this couldn’t be always possibile; this will pollute the class. A better approach to both problems is to create another class with the desired constructor behaviour. This class encapsulates its own construction logic. And it will delegate everything to the other class, including the actual creation. This is the Alias pattern. Applicability Use the Alias pattern when: You need to add or modify a constructor of a final class; You want to add or modify a constructor of a class without modifying or subclassing it; You need two or more constructor of a class with the same parameters without modifying or subclassing it. Structure The structure is simple. We need at least two class that implements the same interface: an and an Alias Aliased. Participants AnInterface declares an interface. Aliased implements ; AnInterface exposes one or more constructors. Alias implements ; AnInterface exposes one or more constructors; maintains a reference to an object; Aliased delegates everything to the referenced object. Aliased Collaboration builds - according to its own rules - an object and maintains a reference of it. Then it delegates everything to the aliased. Alias Aliased Consequences The Alias Pattern has the following consequences: It allows adding or modifying constructors easy; It promotes composition over inheritance; It increases the number of classes; It reduces code duplication when used to replace a recurrent creation; Alias classes duplicates delegating code. If this is a problem it could be approach with a base abstract Alias class. Implementation To implement the Alias pattern you need: to define an interface; to implement the previously defined interface with a class. This will be the aliased one; to implement the previously defined interface with an alias class, and you need: to define a constructor that builds an aliased object according some needs; a private instance variable that reference to the previously built aliased object; to delegates everything to the aliased object. Sample Code The below Java-ish code expresses the Alias pattern. In this code the alias injects a default value for an otherwise mandatory parameter: interface AnInterface {
  void aMethod();

  Something anotherMethod();
}

final class Aliased implements AnInterface {
  private final A a;
  private final B b;

  Aliased(final A a, final B b) {
    this.a = a;
    this.b = b;
  }
  
  void aMethod() {
    // implementation
  }

  Something anotherMethod() {
    // implementation
  }
}

final class Alias implements AnInterface {
  private final Aliased aliased;

  Alias(final A a) {
    this(
      new Aliased(
        a,
        new InstanceOfB(...)
      )
    );
  }

  private Alias(final Aliased aliased) {
    this.aliased = aliased;
  }

  void aMethod() {
    this.aliased.aMethod();
  }

  Something anotherMethod() {
    return this.aliased.anotherMethod();
  }
} Related Patterns At a certain degree, the Alias pattern could be also seen as a way to the objects construction. This vision is especially true if we see a class as an object which responsibility is to create objects. decorate

Uncover the Alias Pattern

Descubre el patrón de alias

Découvrez le modèle d'alias

उपनाम पैटर्न को उजागर करें

Alias パターンを明らかにする

Descubra o padrão de alias

Khám phá mô hình bí danh

发现别名模式

Around 3.1 million emails are sent every , and are spam. According to Dataport, this translates into an average daily volume of globally. second 85% of them 122.33 billion spam messages Marketers have been arguing about decreases in open rates since 2015, and that’s because people are simply of scanning through hundreds of useless content when opening their email inbox. tired Our main mailbox nowadays looks like a nightmare turned reality. Currently, I have more than 50.000 unread emails in my personal mailbox and over in all my accounts combined. 300.000 unread emails Why this matters When I talk to people about this, they don’t seem to care that much. They see email as and move on with their lives. a dead communication channel Although this is entirely understandable, I’d like to argue . Emails are still the #1 sales machine for all digital marketing enterprises, which means email traffic is still the best quality traffic you can get (probably next to Google in some instances). we never really got over email Also, internet sensations that were once dead, like , are gathering billions of views. newsletters resurfacing after the 2020 wave of nonsensical content online, We like to think of the Internet as this practical, everchanging machine. However, , and as such, it evolves over time. the Internet is very much a human creation Evolution in the digital space doesn’t always erase old progress. Sometimes, it enhances what was already there. WhatsApp didn’t invent anything new. Neither did Telegram, Signal, or Facebook Messenger. However, they capitalized on what Instant Messaging meant and created something beautiful out of it that changed our lives forever. Emails have been around since the beginning of everything. Before, “social network” was even a word. Yet, we still use them. Daily. Why? Because we grew accustomed to a private space where we decide what and when to see. No ads, . just our own ideas and private communication If we don't act now to safeguard our privacy, we could all become victims of identity theft. -Bill Nelson The Doom of Digital Enthusiasts If you’re like me, you created your email more than 10 years ago. And now, you’re doomed. You can have as many spam filters as you want, but and a consent-driven exchange of messages after so much time. there’s no going back to a clean inbox My personal email has been (you can check if yours is secure at ), and I receive an absurd amount of emails per day from . breached an indefinite number of times HaveIBeenPwned people I don’t remember, Companies I hate, and Products I no longer use Going through each one of them and clicking “unsubscribe” to follow a three-step unsubscribe process would take me days - if not weeks. This is the main reason Gmail invented the “Important” tag, to . filter through our own junk A couple of years ago, the market of tech enthusiasts started shifting towards a more practical, even pragmatic, use of emails. And it’s thanks to . aliases How Email Aliases Can Help Declutter Your Inbox I’m confident everyone here knows what an alias is, but just in case: an email alias is a . It takes what it’s sent to it and forwards it to your real mailbox. forwarding address This concept can be used to: your real email address mask (for privacy-enthusiasts) your business email substitute (if you can send emails from the alias) add extra layers of to otherwise insecure email clients security (such as PGP on top of Gmail) Email aliasing solutions nowadays are what VPNs and Password Managers were 5-6 years ago. It’s something reserved for the small niche of techies and hasn’t breached the consumer market yet. However, email aliases can be incredibly useful for the as well. average consumer For us techies, email aliases are useful to ditch GSuite and save money, add PGP to our content sent via the alias, and so much more, but to a normal internet user, aliases can help reduce the clutter in their inbox substantially. Aliasing provides you with a “kill-switch.” The Kill-Switch: Stop the “Unsubscribe” Nightmare Consent is not fun if it’s hard to take back. Newsletter and web services make it a pain to unsubscribe so that they can keep your precious email in their database. , as that’s used across thousands of websites and apps. You don’t really have control of your main mailbox With aliases, you can take back control. If you use a different email alias for each service you subscribe to, you will always have the ability to disable the alias and puff - they can’t contact you anymore. That newsletter you’re not interested in anymore? with one click in your email aliasing solution. Click - gone That service you stopped using in 2018? . Click - gone One of your aliases was in a data breach? . Click - gone On a scale, imagine having 2000 aliases and being able to filter through them, bulk delete them, bulk inactivate/activate, and send emails from them. These aliases would also be , meaning you can use them on top of any email solution. platform-agnostic Would this give you part of your freedom back? I bet it would. I can't in good conscience allow the U.S. government to destroy privacy, internet freedom and basic liberties for people around the world with this massive surveillance machine they're secretly building. -Edward Snowden How to Create Your Privacy-Preserving Email Aliases There are several tools on the market to create email aliases. It’s my responsibility to disclose I am indeed associated with one of them as a marketer, but I won’t make this biased at all. I’m not here to tell you which solution is the best one. Pick one, and use it. You’ll see long-term benefits, trust me. Create Email Aliases Tools to (Open-Source) AnonAddy SimpleLogin Both tools are completely open-source and can be . They allow you to as well as receive them, and they let you insert a PGP key to encrypt your content. self-hosted on your server send emails from your alias The main difference between the two is the pricing model, but they’re both affordable. I’m personally associated with SimpleLogin, and if you’re curious about how to send an email from your alias, you can . watch our tutorial here If you don’t need to send emails, is open-source as well 😊 Firefox Relay Tools to Create Email Aliases (Non-Open-Source) BurnerMail AppleMail 33Mail Abine Crumbs Among all of these, the most popular one is (Apple Hide My Email) which only works on Apple devices. platform-specific However, BurnerMail, 33Mail, Abine, and Crumbs all allow creating forwarding addresses. In most cases, their solution focuses on fighting spam and doesn’t allow to send emails from the alias or add PGP. These solutions are not open-source and follow a SaaS model only, which can be a pro or a con based on your personal technical abilities and interest in scanning the code behind the apps you use. Conclusion I hope this article was helpful and gave you great insights into how to start decluttering your mailbox, use aliases to mask your real email, and protect yourself against spam and irrelevant content. If you’re curious about more content on the topic of emails, here are some great articles from other contributors at Hackernoon: - by How Email Became the Weakest Link in Cybersecurity Brian Wallace - by Despite the overload, emails are here to stay Gwapit - by Introduction to Email Threats & Defense John Gruber - by A few thoughts on Email Freddy

What is an Email Alias and Why You Should Stop Using Your Real Email Address

I spend a lot of time working on the bash command line, and I’ve come to highly value the availability of my custom set of shortcuts, preferences, and tricks, right at my fingertips. You know, all the stuff that lives in .bashrc, .profile, .vimrc, .git, etc. I operate and develop across an array of servers, from my own to my clients, and it’s not always easy to reconfigure the same bash aliases every time I access a new server. As such, I decided to create a public list of the top aliases I use, and am making them available for anyone else to use as well. Setup There are a lot of various aliases and an infinite amount of variations possible. Because of this, we’re going to place our bash aliases in a separate file, that will exclusively contain aliases, called .bash_aliases. However, we need to be sure that the .bashrc file will load the file containing our aliases. To do this, simply open your .bashrc file in your preferred editor, and verify that the following code is in your file: if [ -e $HOME/.bash_aliases ]; then
   source $HOME/.bash_aliases
fi Now that you have confirmed that you can load your .bash_aliases file, let’s add the aliases to it! Here is the list of aliases that I use daily, and implement on all servers that I operate on: ## To make sure that your .bash_aliases file is loaded by bash, make sure that you have the following code in your ~/.bashrc file:
# if [ -e $HOME/.bash_aliases ]; then
#    source $HOME/.bash_aliases
# fi
#
# If you don't have the above code snippet in your .bashrc file, add it to the file, save it, and then run the command "source ~/.bashrc"

#All the standard automatic color formatting of the typical commands - these are in your .bashrc file by default. 
alias ls='ls --color=auto'
alias dir='dir --color=auto'
alias vdir='vdir --color=auto'
alias grep='grep --color=auto'
alias fgrep='fgrep --color=auto'
alias egrep='egrep --color=auto'


#JSON parser and pretty-printing tool for the command line 
#Usage (Output formatted JSON to command line):  jsp [unformatted.json]
#Usage (Output formatted JSON to a file): jsp [unformatted.json] > output.json
#IMPORTANT: You must have Python 3 and json.tool installed BEFORE this alias will work
alias jsp='python3 -m json.tool < '
#List all files in current working directory in a list format
alias ll='ls -alF'
#List all files in current working directory including hidden files and folders
alias la='ls -A'
#Classify all files in current working directory into columns
alias l='ls -CF'
# Ignore errors and warnings, and force the removal of a given file or directory
alias rm='rm -if'
#Copy file or folder from A to B, with interactive prompt 
alias cp='cp -i'
#Move file or folder from A to B, with interactive prompt
alias mv='mv -i'
#List all files in current directory including hidden files and folders, in a list, with human-readable file sizes. 
alias lsa='ls -alh'
#List all files in currenct directory except for implied . and .. paths
alias lss='ls -A1'
#Show system drive storage information in human-formatted numbers
alias df='df -h'
#Check the systemctl daemon for failed units - format for human interpretation 
alias sysstat='systemctl list-units --state=failed --no-pager'
#Returns the current system time in UTC - this is useful for quickly viewing the time in UTC when debugging log information, which is 
#often in the UTC format of your system's current time
alias udate='env TZ=UTC date'
#List disk usage for a file or folder in human format [defaults to the current working directory unless file/folder path specified]
alias dff='du -sh'
#Count how many files are in a given directory or filepath - NOTE: count ignores directories but NOT the files inside of them. 
alias count='find . -type f | wc -l'
#Find the top level of a Git project, no matter where in said project you are currently working, 
#and then to change directory to it, change to the master branch, and perform a Git pull
alias stargit='cd `git rev-parse --show-toplevel` && git checkout master && git pull'
#Return to the root folder of your current GitHub repository
alias gtop='cd `git rev-parse --show-toplevel`'
#Shows the output of the mount command, but pretty prints the response and shows human-formatted storage sizes
alias mount='mount |column -t'

# Parenting changing perms on / #
alias chown='chown --preserve-root'
alias chmod='chmod --preserve-root'
alias chgrp='chgrp --preserve-root'


# Get system memory, cpu usage, and gpu memory info quickly
## pass options to free ##
alias meminfo='free -m -l -t'
 
## get top process eating memory
alias psmem='ps auxf | sort -nr -k 4'
alias psmem10='ps auxf | sort -nr -k 4 | head -10'
 
## get top process eating cpu ##
alias pscpu='ps auxf | sort -nr -k 3'
alias pscpu10='ps auxf | sort -nr -k 3 | head -10'
 
## Get server cpu info ##
alias cpuinfo='lscpu'
 
## older system use /proc/cpuinfo ##
##alias cpuinfo='less /proc/cpuinfo' ##
 
## get GPU ram on desktop / laptop##
alias gpumeminfo='grep -i --color memory /var/log/Xorg.0.log' Simply copy and paste the entire file into your .bash_aliases file, save, and exit, and you’re nearly ready to go! The final step is to refresh your bash environment by running source ~/.bashrc. Congratulations on installing new bash aliases for yourself, and enjoy experimenting with the shortcuts!

Bash Aliases to Make Your Life Easier

Have you ever had to copy and paste duplicate content in a YAML file and wondered if it is possible to DRY that up? As it turns out, YAML allows you to repeat nodes via aliases. YAML Aliases allow you to assign a name to a value or block of data and recall the assigned data by its name in the YAML file. Aliases should work for any file written in YAML. Simple Example hello: &hello 'hello' greeting: audience: 'world' hello: *hello #greeting.hello has the string value of 'hello' new_greeting: audience: 'room' hello: *hello #new_greeting.hello has the string value of 'hello' Aliasing blocks of data Besides string or number values, you can alias a block of data as well: foo: bar: &bar qux: 'quxqux' baz: 'bazbaz' greeting: audience: 'world' bar: *bar #greeting.bar has the same values as foo.bar. #So greeting.bar.baz is 'bazbaz' Modifying a section of an alias You can copy an alias and modify a section of it by using the merge key (<<:): bar: &bar qux: 'quxqux' baz: 'bazbaz' greeting: audience: 'world' bar: <<: *bar # greeting.bar.qux is 'quxqux' baz: 'notbaz' # greeting.bar.baz is 'notbaz' Defining aliases from modified aliases You can even modify a section of an alias and define that as a new alias: bar: &bar qux: 'quxqux' baz: 'bazbaz' greeting: audience: 'world' bar: &newalias <<: *bar baz: 'notbaz' new_greeting: audience: 'room' bar: *newalias #new_greeting.bar.baz is 'notbaz' YAML specification Alias nodes are described in the YAML specification . here Previously published at https://blog.jasonhee.com/how-to-use-yaml-aliases

Repeating Nodes With YAML Aliases Like A Pro

I have an advanced data science interview question from Amazon today. This question is going to test your date manipulation and formatting skills as well as our window function knowledge. What I like about this question is that it’s a common analysis that you’d be performing on the job and it’s the perfect question that you’d get on an interview because it would not only tests your advanced data manipulation skills but also your communication skills as you guide the interviewer through your solution. I’m always trying to keep my examples as relevant as possible. Date manipulations and window functions can be considered advanced SQL skills, but the combination of these 2 technical concepts make this question even more difficult. So let’s break this question down -- I’m going to be really detailed as I guide you through building the solution so you know exactly what’s going on and how the data is being manipulated at each step. Let’s start coding. You can watch the video if you don’t feel like reading. here Also in case you want to code with me. here’s the question Approach I like to use the same approach for every question I try to answer. It always involves 4 steps. 1. Explore the underlying data to study the columns and behavior of the data. Here we can see that we have a date column, created_at, and a value column. The date column is not of date data type, which is common, as sometimes the data isn’t read in as a date, in which case we’ll need to cast or convert this column into a date column. The value column is what will be summed up and aggregated into year-month. But it’s important to know that the created_at column is on a day scale, so we’ll need to aggregate this date column to year-month. 2. Identify the required columns Here we’ve identified that we need the created_at column and the value column. We don’t need the other two columns. 3. Visualize the output and identify what columns to output and what aggregations are needed According to the question, the output will require year-month and month-over-month percentage change calculated using ((this month's revenue - last month's revenue) / last month's revenue)*100. So there’s a few aggregations we’re going to need to implement to change the date to year-month and to implement the percentage change formula. But we only need 2 columns in the output -- year-month and percentage change. All the work will be to try to aggregate our data to fit this output. 4. Build solution step-by-step and test Start coding but build your solution step-by-by and test out the query each time you add logic or business rule. Solution Date format using to_char() We’ll need to first convert the date column into a date data type because when you look at the table schema, you can see that it’s an object. If it already a date data type then you wouldn’t have to perform this operation. In postgres, we can use this double colon, but with other SQL engines like HIVE and MySQL, you will need to use the more traditional cast() function. The cast function would look like this --cast(created_at as date). Once you’ve converted the created_at column to a date data type, you then want to format the date to year-month using the to_char() function. The to_char() function recognizes the date column and will format the date to your specification. In this case, we want year and month as ‘YYYY-MM’. This column, year_month, is no longer a date. It is now a character string. SELECT 
  to_char(created_at::date, ) AS year_month,
       *
FROM sf_transactions 'YYYY-MM' This operation is extremely common in analytics. It’s very common to aggregate data on a month level and when you’re dealing with data that spans multiple years, it makes the most sense to display year-month to separate out the years. Calculating month-over-month percentage change in revenue Next we’re going to calculate the month-over-month percentage change in revenue for the year_month by implementing this formula: ( month s revenue) / last month this 's revenue - last month' 's
revenue This might look like an easy formula to implement but it actually requires advanced window functions to be able to implement correctly. Let’s build this calculation step-by-step in SQL so you know exactly what’s going on under the hood. Calculate the sum of the current month’s (or day’s value) The query will calculate the value for that date in the created_at column. SELECT to_char(created_at::date, ) AS year_month,
       created_at,
       sum(value),
FROM sf_transactions
GROUP BY created_at 'YYYY-MM' Calculate last month’s revenue (or the last records revenue) Next we’re going to calculate the last month’s revenue or in this case we’re really going to calculate the previous row’s revenue using the lag() function. SELECT to_char(created_at::date, ) AS year_month,
       created_at,
       sum(value),
       lag(sum(value), ) OVER
(ORDER BY created_at::date)
FROM sf_transactions
GROUP BY created_at 'YYYY-MM' 1 The lag() function will take the previous record because we have a 1 as a parameter. This parameter tells us which record to take so a value of 1 means to take the previous value while a value of 2 means to take the value 2 rows above the current row. Since we just want the previous row in this case, we just need a value of 1. What you’re seeing in the output is not an aggregation of year-month just yet. We’re keeping everything as day so that I can start with raw values before starting to aggregate things. By calculating both the current days and previous days revenue, we have everything we need to implement the percentage change formula: (this month's revenue - last month's revenue) / last month's revenue Aggregate the dates to year-month Now that we have all the components we need to calculate the month over month difference in revenue -- year_month, sum of values of the current month, sum of values of the previous month -- it’s time to aggregate by year-month, rather than keeping the data to the specific date. In this OVER() part of the query, we can reformat the create_at column so that it’s year_month. Then all we need to do is change the GROUP BY to year_month so that we’re aggregating to year_month rather than the day. The query looks like this. SELECT to_char(created_at::date, ) AS year_month,
       sum(value),
       lag(sum(value), ) OVER
(ORDER BY to_char(created_at::date, ))
FROM sf_transactions
GROUP BY year_month 'YYYY-MM' 1 'YYYY-MM' Implement the month-over-month difference formula We have all our components separated, but the purpose of doing this is to make sure that everything we’re returning is what we’re expecting. I like to separate everything out into its own components and perform aggregations and apply logic one by one so that I know how the data is behaving. Let’s implement the month-over-month formula now by combining the current and previous month’s sum of revenues. Here’s what the query would look like if we separate the numerator with the denominator: SELECT to_char(created_at::date, ) AS year_month,
       (sum(value) - lag(sum(value), ) OVER (ORDER BY to_char
       (created_at::date, ))) numerator,
       lag(sum(value), ) OVER (ORDER BY to_char(created_at::date, )) denominator
FROM sf_transactions
GROUP BY year_month 'YYYY-MM' 1 'YYYY-MM' as 1 'YYYY-MM' as Here’s what the query would look like if we created the ratio: SELECT to_char(created_at::date, ) AS year_month,
       (sum(value) - lag(sum(value), ) OVER (ORDER BY to_char
       (created_at::date, ))) /
       lag(sum(value), ) OVER (ORDER BY to_char(created_at::date, )) revenue_diff
FROM sf_transactions
GROUP BY year_month 'YYYY-MM' 1 'YYYY-MM' 1 'YYYY-MM' as Use a window alias to for readability The above query is hard to read and there are pieces of code that are duplicated. You don’t really want duplicated code because if you do decide to change that part of the code, you’d need to change it in all the locations where they’re duplicated. For example, if you decided to use ‘YY-MM’ format for whatever reason, you’d need to change the format in two different places. So we can use a window alias to clean up the code. SELECT to_char(created_at::date, ) AS year_month,
       (sum(value) -
lag(sum(value), ) OVER (w)) /
       lag(sum(value), ) OVER
(w) revenue_diff
FROM sf_transactions
GROUP BY year_month
WINDOW w AS (ORDER BY to_char(created_at::date, )) 'YYYY-MM' 1 1 as 'YYYY-MM' Now the code is easier to read and you’ve removed the duplicate code. Lastly, let’s keep up the formatting according to the question. We’ll be explicit with our ordering even though the default behavior already has the date in ascending order. And then we’ll multiple the ratio by 100 to give us a percentage. SELECT to_char(created_at::date, ) AS year_month,

       (sum(value) -
lag(sum(value), ) OVER (w)) /

       lag(sum(value), ) OVER
(w) * revenue_diff

FROM sf_transactions

GROUP BY year_month
WINDOW w AS (ORDER BY to_char(created_at::date, ))

ORDER BY year_month ASC 'YYYY-MM' 1 1 100 as 'YYYY-MM' Lastly, we’ll round the percentage to two decimal places using the round() function. SELECT to_char(created_at::date, ) AS year_month,
       round((sum(value) -
lag(sum(value), ) OVER (w)) /
       lag(sum(value), ) OVER
(w) * , ) revenue_diff
FROM sf_transactions
GROUP BY year_month
WINDOW w AS (ORDER BY to_char(created_at::date, ))
ORDER BY year_month ASC 'YYYY-MM' 1 1 100 2 as 'YYYY-MM' Conclusion So that wasn’t too hard was it? Sometimes it’s really nice to take your time to break down a problem and build it up one step at a time so that you can completely understand how the data is being processed at each step. Again, our date formatting is common in analytics. You’d be asked to present your data in this format all the time so it’s important to know how to cast your data and how to reformat it. Window functions are also important but they can get messy as you saw in the query. A window alias is helpful to make the code more readable and to implement the DRY technique -- Don’t Repeat Yourself. Or don’t repeat code. Taken both concepts together, it makes the question much more difficult to solve, so it’s really important to approach the question slowly and build up the solution one step at a time, one logic at a time. This helps you troubleshoot and debug, and it brings the interviewer along the way so they know how and what you’re thinking as you solve the problem. Hope this is helpful. Watch the video here. Previously published at https://www.stratascratch.com/blog/amazon-data-scientist-interview-questions/

Amazon Data Science Interview: Window Functions and Aliasing

Are you Developer doing FrontEnd? Are you using Webpack? If any answer is No, you can skip this post. But if Yes, are you using aliases in your webpack configuration? If Yes, you can leave this page. If No, then let me ask you a question: Why not? Problem Let’s start with the problem here. In a large scale application where the codebase is huge and you often see imports like following: Gallery { getUserPrefefences } import from '../../../commons/components/Gallery' import from '../../../utils/storage/browser/user' The or relative imports are the concern here. ../ For a small codebase, these are fine but for a large codebase where the developers work in parallel and move things around frequently, this introduces the following problems: Need to mentally traverse the directorySpend time in fixing the imported modules not found And for the new developers in the teams, this problem becomes 10 folds Solution As you have read the title of the article, this problem can be solved by using aliases in the repack config. How does it work? To explain the usage of aliases; consider the following directory structure: webpack.config.js
src
  - commons
    - components
      - Gallery
        - Gallery.js
      - User
        - User.js
      - Avatar
        - Avatar.js
      - Button
        - Button.js
  - pages
    - components
		- Layout
        - Wide.js
      - Grid
      - Page
    - Messages.js
    - Profile.js
    - Dashboard.js
    - Login.js
    - Register.js
  - utils
    - url For the above structure, consider following scenarios: Accessing the some component in the would look like following: Dashboard.js React WideLayout Gallery import from 'react' import from './components/Layout/Wide' import from '../commons/components/Gallery/Gallery' Now we try to rearrange the tree structure and put the gallery Component in the directory: <project-root>/src/pages/components/commons/Gallery And not we have to refactor the above code to keep working. As our project structure taken for example is small, so it is easy to remember the Component rearrange in code as well: import React from 'react'
  import WideLayout from './components/Layout/Wide' - import Gallery from '../commons/components/Gallery/Gallery' + import Gallery from './components/commons/Gallery/Gallery' Now let’s try to add a few lines to our web pack config: .exports = { resolve: { : { : path.resolve(__dirname, ), : path.resolve(__dirname, )
    }
  }
}; module //... alias Components 'src/commons/components/' Pages 'src/pages/' What above lines in your web pack configuration will do is to enable you to write the previous component in the following manner: React WideLayout Gallery import from 'react' import from 'Pages/components/Layout/Wide' import from 'Components/Gallery/Gallery' Hence, now you exactly know where these components are loaded from, provided that you know about the aliases in your config. And then refactoring the components will also be less painful. You can read more about the Aliases in the webpack configuration here: https://webpack.js.org/configuration/resolve/#resolvealias Conclusion Using Aliases is a way to speed up the development; though not in all cases: Small projects don't need it Bigger Teams need to agree on Aliases Bigger projects should include the list of Aliases in the ReadMe files What do you guys think about the Aliases? Would you use them? Why or Why not? Let me know what do you think about this article through comments 💬 or on Twitter at and @patel_pankaj_ @time2hack If you find this article helpful, please share it with others 🗣; subscribe for the new posts and see you the next time.

Why Aren't You Using Aliases in Webpack Config?

Back when I started programming, there was no Git. I tried using a couple of times for some pet projects and the only thing I do remember about Visual SourceSafe is that the database would become corrupted quite often. Visual SourceSafe Visual SourceSafe — picture from https://www.codeproject.com/KB/cs/VSSClient If you’re interested in some history about VSS and its issues, check out one of these two articles: Visual SourceSafe: Microsoft’s Source Destruction System Visual SourceSafe Version Control: Unsafe at any speed? When I started my first job, the team I worked in was using a company-internal source code control system called . Shortly after that, we moved the source code over to the that was using Team Foundation Version Control. At some point, this got rebranded or renamed to Visual Team Services (I might be wrong on this as it has been a while ago and I always referenced to it as TFS). Source Depot TFS Visual Studio Team Services — photo from docs.microsoft.com Later, we would eventually move to Git. At the beginning of my career, I was using Visual Studio heavily, and all source code control commands were available from the user interface (they were also available from the console, but most of the work got done in the user interface). One feature I liked about TFS was the ability to that could get easily shared with others. The equivalent of this in Git today is probably creating a branch and pushing it. For a little while, after I’ve started using Git, I’d still miss shelvesets, but once I got used to the way Git does things with branches the need for shelvesets went away. create shelvesets Git Aliases Ok, enough of history, let’s talk about Git aliases. I have a bunch of them in my .gitconfig file, but I don’t use all of them too often. I still like to use the GUI (I am using ), which is free for both Windows and Mac), especially for merges. Sourcetree Here’s the link to my full — note that most of these probably came from the repos I based my dotfiles on: .gitconfig file https://github.com/jfrazelle/mac-dev-setup https://github.com/mathiasbynens/dotfiles In addition to the aliases, I also have an alias set for the Git binary, so I don’t have to type all three letters, and I can only type g (huge time/type savings, I know :)). I’ve grouped the aliases below — note that there are way more aliases in my config file (related to finding stuff, diffing, merging, etc.), however, I probably never used them, and that’s why I haven’t mentioned them. I do most of the searching and merging in the GUI. Basic aliases These are mostly shortcuts, rather than more complicated commands. # View the current working tree status using the short format
s = status -s

# Clone a repository including all submodules
c = clone — recursive

# List all tags
tags = tag -l

# Lists all remote and local branches
branches = branch -a

# List remotes with URLs
remotes = remote -v Command below shows how you can clone a repo: g c [repo] Working with forks This is something you need to do quite often. I have two different aliases to do this — one merges the upstream master into local (origin) fork (fu) and the second one makes the fork even with the upstream master, discarding all local changes (fuf). # Merges upstream master into local (origin) fork
fu = !"git fetch upstream; git checkout master; git merge upstream/master"

# Makes the fork even with the upstream master, discarding all local changes
fuf = !"git fetch upstream; git checkout master; git reset — hard upstream/master; git push origin master — force" Branches I use an alias called go to either switch to an existing branch or create a new one if it doesn’t exist. This is one of those commands I use fairly often: # Switch to a branch, creating it if necessary
go = "!f() { git checkout -b \"$1\" 2> /dev/null || git checkout \"$1\"; }; f"

# Remove branches that have already been merged with master a.k.a. ‘delete merged’
dm = "!git branch — merged | grep -v ‘\\*’ | xargs -n 1 git branch -d" Commits Amend alias is the one I use if I want to add current changes to the latest commit (instead of creating a new commit): # Amend the currently staged files to the latest commit
amend = commit — amend — reuse-message=HEAD Do you have any favorite Git aliases that you’re frequently using? Thanks for Reading! Any feedback on this article is more than welcome! You can also follow me on and . If you are interested in learning more about Istio and Kubernetes, you should check out the book I am writing at Twitter GitHub www.learnistio.com.

Work Faster With Git Aliases

Optimize your docker command line workflow using aliases If you’ve worked with at the command line, you’ve undoubtedly written command shortcuts or have at least considered doing so. Docker In this post I’m assuming you’re somewhat comfortable using docker commands and are perhaps a bit interested in potentially useful . If you’re new to Docker - then this might not be a good place to start. aliases This post is about time-saving shortcuts or aliases for longer, unabbreviated commands. ’cause let’s face it: “Ain’t nobody got time to type out the whole damn command!” A shortcut can be implemented in several ways. Two that we’ll consider here is the bash shell alias and the shell script file. Any shortcut I’ll share can be placed in a script file or an aliases file. Each method has its pros and cons. Here’s a handy (docker ps) shortcut placed in a shell script. If you opt for this approach then you’ll end up with a collection of scripts that you’ll need to copy to a globally accessible path such as , use a PATH or something similar. You may also need system privileges in order to get it just right. dkps /usr/shared/bin dkps shell script The other approach is to place alias commands in your file found in your home directory. That makes the shortcuts portable without requiring special permissions. .bash_profile .bash_aliases script If you’re new to bash aliases checkout this . intro To keep things clean I’ll import my docker related aliases rather than add them directly to my or script. In my .bash_profile script I’ll simply add the following to load my new file. .bash_profile .bash_aliases .docker_aliases In my actual script I load other aliases such as a script. .bash_profile .git_aliases So you don’t have to type all this in, a sample file is available at the end of this article. .docker_aliases This method is also quite portable, as you’ll be able to share your docker aliases with friends and family. Before introducing my own handy docker aliases let’s create a sample set of containers that we can use to test aliases against. We’ll do that using the and two well-known services, Redis and MongoDB. Don’t worry if you’re not familiar with those, we won’t actually use them — think of them as just real-world placeholders. Docker Stack commands Launching our test stack simply requires doing a and passing the compose script above. We end the command with the name of our stack which we’ll call “test”. docker stack deploy Once the stack loads we can verify it using the command: docker ps Note: For the sake of brevity, I’ll abbreviate the output of some commands. This has an added benefit of creating smaller images. So keep in mind that output of the docker ps command above is much longer than shown. We can tear down our stack using the command. docker stack rm , right? Easy Peasy I’ll use the setup above when showing screenshots in the remainder of this post. Now on to our aliases… this better be good right? The first aliases we’ll look at simply provide abbreviations for common docker commands. Right off the bat, consider the time saving every time you replace with for commands like or when working with services and using for docker service commands like . The savings of typing add up! docker dk docker ps dks docker service ls dks ls So instead of typing docker: you type: docker logs dkl becomes docker logs b7a8 dkl b7a8 Use to follow a log. So rather than you can simply use dklf docker logs -f b7a8 dklf b7a8 Another handy logging alias is the (docker log by name) command. dkln It evaluates the piped commands within the backticks (`) and utilizes the result as a parameter to the command. The command uses the first parameter to filter the results of the command. And finally, the command takes the first field of the output as the value parameter. docker logs grep docker ps awk Ok, that might be confusing. Let’s take a closer look. The command returns a list of running containers. docker ps Abbreviated docker ps output And returns: docker ps | grep redis Abbreviated output And finally, return the container ID for Redis: f5f0ed387073 docker ps | grep redis | awk '{print $1}' This allows us to view the log for any container by name. Abbreviated docker ps output Naturally, you’ll need to make sure you don’t have multiple containers which match a name. If you do, then simply resort to the command with a container ID. dkl A key takeaway in the example above is that you can build some pretty powerful aliases by combining shell commands. We’ll see another example of this later in this post, when we look at an alias for building and publishing containers. Viewing the status of our running containers is a vital part of building and testing containerized services. The following aliases make it easier for us to do this. Earlier in this post we looked at the (Docker PS) command. dkps .bash_aliases script Here’s the command in action: Abbreviated docker ps output Another useful alias is the (docker stats) command: dkstats This command tests whether a parameter is supplied and if so applies a grep filter. Abbreviated docker ps output That allows us to see stats for all containers or to filter by a a specific container name. The command presents a top-like display, showing memory, CPU, network I/O and block I/O. dktop The actual alias is surprisingly simple: You’re free to with the values you’d rather see. I chose a basic set in order to have the display fit neatly in a mult-pane iTerm2 screen. customize it In the process of building containers it’s sometimes necessary to enter the container to have a look around. Doing so typically involves: docker ps to view a list of container IDs docker exec -it {containerID} /bin/sh Using our aliases this becomes: dkps dke {containerID} Here’s a video example: Sometimes it’s necessary to restart a service. The (docker service bounce) command allows us to do just that. dksb The non-alias method of doing this requires using the command: docker service scale $ docker service scale test_redis=0$ docker service scale test_redis=1 Using we simply type: dksb $ dksb test_redis 1 The last thing we’ll look at is an aliase for building and publishing docker containers. While this process typically involves a two-phase operation, docker build / docker push, there other tasks you might want to do to further automate the process. In my case, I build docker containers which hosts NodeJS Microservices. Part of my local build involves checking whether a .dockerignore file exists, then looking inside a Node package.json file to extract the name and version of a project. The name and version are then used to form a docker label. Here’s what a (docker publish) alias looks like: dkp The above alias uses (a command line JSON processor) to pull version information from a package.json file. jq Using is simply a matter of entering a node project directory and typing followed by the docker hub repository name. In the example below I’m building and publishing the docker container. dkp dkp HydraRouter I hope you’ve found some handy docker aliases in this post or that at least it’s inspired you to optimize your command line workflow using aliases. Cause remember — … Ain’t nobody got time Here’s the full script, including a few bonus commands we didn’t cover in this post. .docker_aliases — Thanks for reading! If you like what you read, hold the clap button below so that others may find this. You can also follow me on Twitter .

Handy Docker Aliases

What are Git aliases and how to configure & use them. Git is a free and open source control system designed to handle everything from small to with speed and efficiency. version very large projects One of ’s features allow you to create so you’re able to type shorter commands & combine multiple commands into one. Git aliases For example, I have an alias for the command to so you can type instead of (Yea, I’m that lazy), Git simply replaces the new command with whatever you aliased it for. checkout co git co git checkout Over time, I’ve created & collected useful aliases that made my everyday work with easier. I’ll be going through a couple of them below. Git Configuring a new alias First let’s talk about how to configure aliases. You can easily set up an alias for a command using . Here are a couple of examples you may want to set up: git config $ git config --global alias.co checkout$ git config --global alias.br branch$ git config --global alias.st status This basically adds a new entry in file. Git uses this file to store all your settings. On Windows it’s located in . ~/.gitconfig C:\Users\<user_name> Another way to add a new alias would be to edit directly. I always use this method since I can add comments to my aliases. ~/.gitconfig To do that, simply open in your current favourite editor, and add the new alias under the section. For example, to add manually: ~/.gitconfig [alias] git co [alias]co = checkout Which tells Git to replace with everytime you write . co checkout git co Keep in mind that this would only work for Git subcommands (like checkout, status, commit). For instance, If you try to alias an OS command: [alias]list = ls Running would make Git get mad at you (see what I did there!) git list $ git listexpansion of alias 'list' failed; 'ls' is not a git command Aliasing external commands Fortunately Git provide a simple way to alias anything that’s not a git command. If you want to run an external command, start the command with a character. Using our previous example: ! [alias]list = !ls Now typing in the terminal would instruct Git to run the command & list files in current directory. git list ls I’ll use two aliases I use daily to show you how powerful Git aliases are. Branches After creating a new branch, you’ll want to push it to your remote fork of the repo to have a backup of your code or to be able to merge it later with other repos. If you type after creating a new branch, you’ll get an error similar to this: git push fatal: The current branch <branch_name> has no upstream branch.To push the current branch and set the remote as upstream, use git push --set-upstream origin <branch_name> Basically Git is telling you that you need to explicitly tell it which remote branch you want your local branch to track before you can push your changes. And you can run the command it provided to push the branch & set it’s remote at the same time. Now I don’t know about you, but I don’t want remember all of this, and I don’t want to type in order for Git to remind me of the command I need, so I can copy & paste it in the terminal to run. That’s just too much work :) git push How about if we can just type one command that will: Set a remote upstream branch with the as your current branch, same name and then push your current branch. To do that, we’ll create a new alias called that does that for us. However, in order for to work it needs a way to figure out the current branch name. Fortunately we can run this Git command: to give us this info. publish publish git rev-parse — abbrev-ref HEAD To be able to get the output of one command, and use it in another, we can use . Command Substitution So now our alias becomes: publish git push --set-upstream origin $( ) git rev-parse — abbrev-ref HEAD This is how it looks in .gitconfig [alias]publish = git push --set-upstream origin $( ) git rev-parse — abbrev-ref HEAD This is where Git aliases really shine, its ability to combine multiple commands to save you time. Note that you’ll notice in my personal aliases list (at the end of this post) I’ve created a separate alias for the command that returns the current branch name, just for sake of organization. Now let’s see how we can even create aliases that takes input from the user! Syncing with upstream One of the other really helpful alias I use constantly is: git sync upstream/develop If you work on open source projects or if you use the , then you’ll find yourself always updating your repo with the upstream repo (the repo you forked from). Git Forking workflow This process basically involves two steps, the commits you want to merge. And actually those two commits. fetching merging To do the first step I run when gets all the newer commits from all I have. git fetch --all --prune remotes And then I run to merge the commits fetched specifically from branch to my current branch. While these two commands can be combined in an alias, I found that sometimes I want to commits from a different branch than 😕 git rebase -p --autostash upstream/develop upstream/develop rebase fetched upstream/develop How can I pass extra info, like a branch name, to my alias? Basically something like this: [alias]sync= **!**git fetch --all --prune && git rebase -p --autostash <user_input> Fortunately that’s still doable in Git. All you need to do is add a to where your input will be used in the command. $1 [alias]sync= !git fetch --all --prune && git rebase -p --autostash $1 And now you can just call the alias with any input you’d like! sync Hopefully that gives you an introduction to Git aliases. You can find my list of aliases below. If there are any other aliases that you use and find helpful, let me know and I’ll add them to the list :) Thanks for reading — I hope you found this article useful. You can follow me on & . Twitter GitHub Full list So without further ado here’s my current list of aliases: My current list of Git aliases Obligatory Git joke https://xkcd.com/1597/

Git going with aliases

Let’s look at domain names that have been created to ensure that people do not write the IP address 172.217.16.14 since it is much easier to remember the name of google.com. Now let’s look at the Ethereum address. For example 0x0472ec0185ebb8202f3d4ddb0226998889663cf2 — it looks even more difficult than the IP address. The goal of the ethnamed.io project is to implement named aliases for Ethereum addresses. Name Registration Process Install: https://chrome.google.com/webstore/search/ethnamed Github: https://github.com/ethnamed Reddit: https://www.reddit.com/r/ethnamed Facebook: https://www.facebook.com/ethnamed Website: https://ethnamed.io Name Registration Process One of our primary goals is to create a universal payment solution with an option to send funds knowing only the sender’s email or nickname. To some extent we fused the basic principles of ETH-wallet and DNS, and extended the whole idea to using emails and nicknames to eliminate the need to use complex HEX-addresses. For example, a regular Ethereum address looks like this: 0x89205A3A3b2A69De6Dbf7f01ED13B2108B2c43e7, and the majority of crypto wallets work with such. Unsurprisingly, such addresses are easy to misspell and hard to memorize, unlike simple nicknames or an email like . Besides, Ethnamed allows users to link several wallets of different blockchain networks to one email or nickname. Metamask Ethereum Name Service johndoe@test.com Integration with website Ethnamed’s another substantial feature is the planned for adding new cryptocurrency to the existing portfolio in your wallet. Right now, in order to interact with a cryptocurrency one would have to download and get familiar with a specific wallet software designed for the crypto in question. With Ethnamed we’re establishing an open repository for the pieces of code required to work with certain cryptocurrencies. We’ve implemented automatic invoice creation by integrating a web page with interface similar to the system Metamask uses for ETH. system WEB3T — like a web3 for Ethereum but for ALL cryptocurrencies WEB3T Javascript Examples: web3t. .sendTransaction({to: …, value: …}, cb); btc web3t. .sendTransaction({to: …, value: …}, cb); eth web3t. .sendTransaction({to: …, value: …}, cb); [ANYCOIN] Thus, anyone can add their desired cryptocurrencies into via simple pull request on our . open source library WEB3T Github In the process of creating the repository, the team from will actively participate. They see their mission as developing the blockchain technology, conducting several projects of their own and willingly giving their experience and resources for collaborations. advance.fund The result ofweb3.dash.sendTransaction(…) We’ve also got big plans as to the future Ethnamed development. The roadmap includes the implementation of the technical means of integrating our wallet with exchanges (fiat -> crypto, crypto -> fiat); atomic swaps for Ethereum and Ethereum Classic, Bitcoin, Litecoin, Dash, and others; desktop version and mobile apps for iOS and Android; Firefox plugin; and open-source repository for cryptocurrency standardization and integration. Please, share your feedback to help us build a better product and realize Ethnamed’s potential to drive mass adoption of crypto and blockchain tech worldwide. Install: https://chrome.google.com/webstore/search/ethnamed Github: https://github.com/ethnamed Reddit: https://www.reddit.com/r/ethnamed Facebook: https://www.facebook.com/ethnamed Website: https://ethnamed.io

Ethereum address alias

The more you work with Git the more familiar you become with the commands used in your every day workflow for your projects or your team’s projects. Commands like naming and creating feature branches making pull requests or pushing your changes if you have the requisite permissions. So still used by me on a daily basis, and everyone else that uses git [I presume] is the command, then and or git add . git commit -m "my awesome feature" git push git push origin <branch> In my short time using Git I have always just typed out the full commands [usually with close to hand] and thought nothing more of it, that is how you use the tool, right? my cheatsheet Well that was what I foolishly presumed until I learned about dotfiles, I learned about files from listening to the podcast with and a great channel for learning about tooling 👍 the podcast was about give it a listen it’s a great show. . toolsday.io Chris Una Git Tools This was a pretty cool learning experience for me and I now have a pretty efficient git workflow 🚀 Let’s go over , do you remember having to enter your email address and name when first setting up Git on your computer? That information is stored in your file, your file will be located in your user folder on Windows or on Linux/Mac .gitconfig .gitconfig C:\Users\yourusername\.gitconfig ~/.gitconfig If you navigate to the file in the text editor of your choice and pop it open you’ll see your details under the `[user]` flag, here’s mine: [user]name = spences10email = spences10apps@gmail.com I’m not sure what other configuration options you may have in yours so we’re just going to concentrate on the aliases, aliases can be used so that you can shorten the commands [or make them longer if you like] but I’m all for reducing key strokes, even if it is one or two less. So lets review the common commands I mentioned at the start: git add .git commit -m ‘my awesome feature’git push So with aliases we can shorten these down a bit: In your file if there’s not already one there add in the section, I have mine above my user details, then add in some aliases: .gitconfig [aliases] [alias]a = add .c = commit -amp = push [user]name = spences10email = spences10apps@gmail.com So now we can shorten down our workflow for adding a change to one of our repos: git add .git commit -m ‘my awesome feature’git push Will become: git agit c ‘my awesome feature’git p It’s not a massive reduction in what you’re typing but you’ll be amazed at how quickly you become accustomed to it and start adding more an more. Here they are in action 👍 Here’s my current list of aliases: [alias]a = add .b = branchc = commit -amcl = cloneco = checkoutd = difff = fetchi = inito = open # see: https://github.com/paulirish/git-open ♥p = pushpt = push --tagss = statust = tag A new one I have found out whilst making this post is which clones only the HEAD of the repository instead of the whole repository, so say if you were cloning react you’d just get the master version rather than the other 38 branches included in the repository. Pretty neat so that could be aliased into something a lot shorter clone --depth 1 git cl1d? You’ll no doubt notice the link I have in there for that little gem belongs to it’s an npm package that will pop open a browser tab to the current repository you are in, pretty neat right? o = open Paul Irish I’m sure there are many, many more ways to configure Git if you take a look at for his you’ll see there is a lot of ways to configure Git, I’m still learning and finding new ways to do things. Paul Irish’s dotfiles repo [.gitconfig](https://github.com/paulirish/dotfiles/blob/master/.gitconfig) If there is anything I have missed, or if you have a better way to do something then please let me know. Get me on or on GitHub. Twitter Ask Me Anything If you like this post or if it has helped you in any way then please give it a like and don’t forget to share it on social media.

Moving from beginner to (slightly more) advanced git with aliases.

Language design echo chambers TL;DR: The alias proposal is the wrong solution to a much bigger issue in Go’s ability to meet its stated goals The alias proposal is a feature that will probably be added in the next version of Go. If you have time to spare, you can or some Tylenol to spare you can read the . There’s also an interesting that has more context. language read the design doc on github github discussion on the proposal itself mailing list discussion To explain the alias proposal, let’s say you have a customer package and it’s used by a cart package to purchase things. Later, you decide to move items to their own package so you change the code to move Item. This works fine if you’re a small codebase, but if you’re (the complaint is) then you have a problem because other application’s code doesn’t compile because when they use Client they expect to pass in a customer.Item but your client now accepts an item.Item. They could continue to use your old client, but they won’t get bug fixes either. Under the alias proposal, your new customer package would instead contain an alias. Google Now old code still compiles because customer.Item still exists. New code can create item.Item directly, probably with extra features inside the new item.Item, and use the new cart.Client API. The goal is that you eventually remove the alias definition when everyone has updated customer.Item to item.Item. Is this a real problem? Software development isn’t only language syntax. It exists in a greater system of tooling. Indeed, Go’s great tooling support for such a young language has helped its adoption. Pushing a problem also has the added benefit of not requiring backwards compatibility for a feature that may later be a mistake. It also doesn’t force one company’s needs (the deficiencies of Google’s decision to use a large monolithic repository) upon other companies via a forced language feature. to the tools The specific problems Google has that are creating the alias proposal could be resolved via a tool Google runs to do this mass transformation in a compiler safe way. I don’t think it’s fair to claim Google is too big for tools to work. Still, for the rest of this post we’ll assume this is a real problem that needs a language level solution. Sidetrack: Google controls go? Someone once chided me for claiming Google controls Go. . Go isn’t just the source code, but what it’s released as. From that perspective, Go is whatever says Go is. No, it’s owned by the Contributors https://golang.org < whois golang.org...Registrant Organization: Google Inc.... Google unambiguously owns golang.org and and therefore controls releases of Go. You said control, not own! Go’s language definition and syntax is , but that ownership is a git commit from being taken away. It’s ambiguous what would happen if he disagreed with another core team member (I would hope the decision is inaction), but publicly he has final say. Still, it isn’t fair to say Google employees control Go’s language, therefor Google controls Go. They have their own brains! publicly owned by Russ Cox Instead, it’s how Google writes code that appears to direct the language and new features for Go. That doesn’t have to be a bad thing! They’re full of smart people and tend to write good code, so it’s not so bad to emulate. The biggest problem with a limited sphere having control is the . The problems of users inside this sphere become an echo chamber that magnifies their importance to the people inside it. The culture of the correct way to write code inside this bubble becomes the axioms that the theories of the Go language are based upon. bubble effect Example by counter example: the vendor feature When Go 1.0 was released, people complained it had nothing new. All of the big things in Go 1.0: light threads, channels, no exceptions, etc. They all existed in previous languages. Innovation isn’t always a good thing: look at fashion. It doesn’t innovate! Is fashion better when it innovates? We can make a great languages just doing the simple parts right. I’m happy not trying new things, and I was happy with Go. And then, Go released the vendor feature… Managing dependencies apparently wasn’t a problem inside the sphere that Google used Go, because when engineers brought up the issue on mailing lists, the typical response was . This is probably a side effect of: deal with it When Go 1.0 was released, there was no problem with external dependencies since no on else had Go code. Google tends to use monolithic repositories, where dependencies are just code inside the same repository I imagine we complained enough, because eventually ! As far as I can tell, the feature of hijacking absolute import paths depending upon the directory of the source file, allowing two source files to have different ideas of the same absolute import path . It’s no surprise then that I dislike this feature! It can create literally uncallable public APIs, singletons that aren’t actually singletons, and is a half feature that leaves library authors in the dust. It creates surprises in things that code authors assume are intuitive and has multiple gotchas. Go released a solution and it was innovative is the only original feature in Go Before defending the , think about why other languages didn’t take this path. I see three explanations: vendor innovation Go is so wildly different that it only makes sense for Go The people who thought of solutions for other languages weren’t clever enough to think of a /vendor folder solution The /vendor folder isn’t actually a good idea My gut feeling on why this feature is so terrible is that it didn’t come from a real need in Google. Bubbles don’t just create features that the bubble thinks is a good idea, they also poorly implement features that the bubble doesn’t fully understand. This is why I’m honestly excited by the coming up with a solution to package management for Go. After many years, it’s apparent a great solution for package management can’t come from inside Google itself. The generic proverb is . I imagine the final idea could be added to the package management team necessity is the mother of invention go proverb list. dep’s solution is no one’s favorite, yet dep is everyone’s favorite If Go followed the same process before the creation of the /vendor folder, and authorized the same people to think of solutions like , we would have a much different looking solution. It wouldn’t innovate at all and instead (just like a well-tailored suit) include working pieces from existing solutions. deprecating go get The alias proposal, a bubble, and half measures The alias proposal solves a particular problem Google has migrating definitions. Taken in the context of a segregated monolithic repository, it makes sense as a reasonable solution. My concern is that in the context of the broader Go community it is only a partial measure. I want Go to have a full solution, but when we eventually get it we’ll still have the partial solution floating around. Part of the bubble is visible in the proposal itself. The proposal talks about removing the alias when the migration to the new package is complete. Unfortunately, this is impossible in an open source project since you can’t know everyone using your code. Even outside the open source community, there are private companies that simultaneously maintain umpteen Go codebases that don’t use monolithic repositories and in these situations it can also be difficult to know when a migration is complete. The broader problem that’s being ignored is the trouble Go has creating isolated packages. includes developing software used by many teams . The largest issue working against that goal is . Inter package dependencies Go’s goal of limited coordination. You can see hints of this in Go’s stated goal with limited coordination between them inter package dependencies explicitly work against Go’s proverbs. A little copying is better than a little dependency. It’s my belief that the alias proposal is a Google specific half measure, when the real problem to tackle is unnecessary inter package dependencies. Go’s implicit interfaces actually resolve part of this problem. For example, let’s say you have two packages. The problem here is that there’s a package dependency between store and cart which can potentially require coordinating them. It also, honestly, limits Store’s functionality since it should work well not just with a Cart, but with anything that has a Subtotal(). Instead, we can write store as the following. In this version, store is an isolated package. Because it’s an isolated package, . It can exist as a “cart.Cart”, a “shopping.Cart”, or a “store.Cart” and as long as it implements Totaller everything is fine. Subjectively, I also think this implementation is better. A Store can now render everything that has a Subtotal(), not just carts. Good to note this flows with my general advice for Go the alias proposal is moot accept interfaces, return structs. We can bring this same philosophy back to the original customer.Client. Is it important that customer.Client.Purchase takes a customer.Item, item.Item, or that it takes a pointer to some structure that has a Price float64 field? We could wrap items with a setter and getter for Price, but practically this is not done for structs (most Go code tends to actively avoid setters and getters). We run into a similar problem with interfaces. For example, the following code does not work with store2.go Edit: An earlier version included much different code that did not show my intended point. I apologize and have updated the example. Here, package app tries to exist in isolation, but cannot expose an interface that store can implement. We could have store directly use app.Totaller, but we create a package dependency that may not be desirable and require coordination when each of them update. These limitations of Go’s implicit interfaces by creating unnecessary inter package dependencies, which make it harder to evolve a codebase in parallel. This is the core problem, a problem both the open source and closed source Go community has, and the alias proposal is a subset of this problem. actually hurt Go’s stated goal We can do better My gut tells me the alias proposal is a half solution to a Google specific problem. I’m confident the same people could create a more general and elegant solution that solves a group of problems the Go community has: a solution I may not be smart enough to come up with myself. This more general solution would simultaneously do more to further Go’s stated goals as well as remove the need for the alias proposal entirely. I think the real solution is closer to . It’s a shame the issue was almost immediately labeled as Go 2.0 without consideration. There are backwards compatibility concerns with the specific proposal, but I’m confident those could be resolved with thought. Especially if things like the alias proposal are open to wild ideas like new symbols and syntax. https://github.com/golang/go/issues/8082 I would also suggest that the more general solution doesn’t have to cover every corner case of the existing alias proposal. Instead, it only has to cover enough surface area that well designed Go libraries (those that follow best practice API design) are always left with a migration plan. No half measures The problem with half measures in a backwards compatible world is that a complete solution is still required. When it is eventually implemented all these half measures are stuck around in backwards compatibility limbo. No half measures

Stories, News & Mentions about ALIAS

Alias’s Stories on HackerNoon