abhicodes

Using Continuous Integration has shown to be incredibly powerful - especially when you combine it with Github/Bitbucket/any version control platform. CircleCI/TravisCI/Jenkins and any other CI frameworks allow programmers to automatically deploy, and test their code on a clean environment. The clean environment part is important as sometimes programmers have different dependencies on their own machines and on their servers. This becomes a problem as it breaks deployments, and causes programming errors in the future. The CI platforms give programmers the ability to test their code in a controlled environment before deploying it onto their own servers. The CI platforms takes care of installing the dependencies programmatically on this staging server, and in a way it acts as a middleman.

Even if you are building a library it becomes useful as you can run your tests and make sure your library builds under this clean environment. As you get more collaborators for your projects you can make sure the additions they make run in this environment and not just on their own computers.

This is just one benefit CI platforms have. There’s a ton of benefits:

Automate builds and deployment.

Running tests (bug detection!)

Everyone is able to monitor the builds.

Metrics can be generated on how long builds take, how complex the code is, and many other things. It helps make it easy to notice what the flaws in the process are.

It’s ruthless because the task is being done by the machine. If it encounters an error in the build it’ll halt rather than deploying it anyways.

There’s also costs associated with CI platforms:

Usually rely on a complex platform. This reduces flexibility over using Fabric or some other method of deployment (they can also be used in conjunction).

You don’t always have complete control over all the packages that they install. They use their own base image for the OS that you can’t overwrite (can be solved if you use Jenkins or any other CI solution in-house).

It’s expensive if you want parallelism or any type of extra features. 

It’s incredible simple to get started with a CI platform as well! CircleCI is one I love using because it’s easy to get started + they allow developers to use private repositories (rather than TravisCI where you have to pay for a private repository). 

To get started you can go on circleci.com and login through your Github (or Bitbucket, etc). Then you can just add the repositories you want to add CircleCI to by visiting the “Add Projects” section. Now your repository to be built automatically when you push any new commits to it on Github. Before you start pushing code - you’ve to do one final thing. You’ve to add a file called circle.yml. This file tells CircleCI what it’s supposed to do when you push to the master branch of your repository.

An example of a circle.yml file is below:

This is a simple circle.yml document that builds a jekyll website and then uploads it to Rackspace Cloud Files. Let’s look through the code:

The general section at the top is to give CircleCI information about your branches and many other settings. 

The machine setting tells CircleCI which timezone, OS, programming language versions (etc) you want to use. These are settings on how it should spin up the virtual machine.

The next is dependencies. It tells CircleCI the software dependencies you need to install. There’s 3 settings within dependencies: pre, overwrite, and post. We’re using post in this script which means install these gems after CircleCI has ran it’s own dependency commands. Pre is before CircleCI runs it’s own dependency commands, and overwrite basically means run these instead of CircleCI’s. 

The test section is just to tell CircleCI how to run your tests!

The last is deployment. You can tell CircleCI how to deploy each of the branches you want CircleCI to run on. Here I’m using turbolift to upload files to Rackspace Cloud Files. The values starting with $ are just environment variables that you’re able to set through the Project Settings section of CircleCI.

There's a lot of optimizations that are done by the compiler at compile time. Here are a couple of them! Some compilers do these optimizations and some don't.

strength reduction

Strength reduction optimizations usually take place in a loop. It usually looks for expression involving a loop invariant and an induction variable. Sometimes these operations can be simplified.

Strength reduction could be replacing X with Y in a piece of code. For example, replacing a multiplication with an addition. The point is to simplify a more complex expression (multiplication) with an addition expression.

A loop invariable in compiler design are values that do not change within the scope of the loop.

An induction variable in compiler design is a variable that always gets increased or decreased by the same amount each time the loop iterates. When you have a particular loop for example:

the variable i is always an induction variable. Induction variables can be said to be the values that are being iterated and changed every time the loop iterates.

The following example is taken from Wikipedia. Lets say we have a program with a constant c, an array y, and a bound N. We have setup a loop that has a the loop counter i and is bounded by N. Each time we are setting the index i of array y by the constant multiplied by i.

Here the loop invariant is c, and the induction variable is i. The loop invariable is c because it's a value set before the loop, and does not update in the scope of the loop. The induction variable is i because it's the variable that is being iterated or changed at every iteration of the loop. I believe it can also be said that y[i] is an induction variable because it's also being changed at each iteration of the loop, but we don't need to make this statement (as you will see).

iptables

Accepting a port:

Setting up port routing using (from port 80 to 8000):

Deleting existing rules:

get ip

or if you don't have dig

speed test

SSH tunneling allows an individual to use their server as a proxy for their internet connection. This means that the bytes that you send and recieve from websites/servers will go through the server you're using.

The benefit of this is that it reduces the risk of your main computer being exposed as your IP becomes the servers IP, and all the requests to external websites/servers are made by the server rather than your computer. In addition, if you're in an external country you're able to use those servers to pretend like you're in another country. For example, if I want to watch netflix and I'm currently in China then I'm able to setup a SSH tunnel through a server in the US to watch netflix.

Basically the command is:

If you have your SSH keys in the authorized_keys of your server then you're set, but if you don't then enter the password for the user. Keep this connection open - you should not expect any output right away.

This will setup a proxy at port 8080 on your computer. The username is usually root for your server, but can be replaced if you created a new user. The servername is usually the IP of your server or the domain name. For example, my username@servername could be [email protected] where abhi is the username and abhi.co is the servername. Your hostname could be 28.254.39.67.

A sample command would be:

The next step is limited to Mac OSX. Go to System Preferences, Network, Wifi/Ethernet (depending on what you're using to connect), Advanced, Proxy. Then turn on SOCKS Proxy with the details being 127.0.0.1:8080. This means that the input before the colon is 127.0.0.1, and the input after the colon is 8080.

Some people have Hola installed on Chrome. Disable this if you're going to use the proxy with Chrome. Hola takes control of the proxy in Chrome when it's enabled (it's how it manages to connect you through different countries).

This step is for Linux. You have to export your http_proxy variable in order for this to work.

Run this in the command line.