2nd_draft.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why and how to use ipython notebook\n",
    "\n",
    "    I would like talk about about why I would prefer ipython and how to use it together. From my point of view, and with the limitited time that I used ipython, there are few features that is realy usefull compare to classic IDLE. First, notebooks are extremely usefull compare to IDLE's limited comment system. It is possible to explain what is going on and run the code at the same time. Also going through files and directories is way more simple and possible without using os_getcwd() like commands, simple pwd and cd works fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "u'/home/onur/Desktop/ipython'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/onur/Desktop\n"
     ]
    }
   ],
   "source": [
    "cd .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0m\u001b[01;34m1h23\u001b[0m/           \u001b[01;31mcadd.tar.gz\u001b[0m  \u001b[01;31mGradProject_OnurOzcan.tar.gz\u001b[0m  \u001b[01;34mmoulder\u001b[0m/  \u001b[01;31mspl.tar.gz\u001b[0m\r\n",
      "\u001b[01;31m4_april.tar.gz\u001b[0m  \u001b[01;34mg\u001b[0m/           \u001b[01;34mipython\u001b[0m/                      \u001b[01;34mproject\u001b[0m/  \u001b[01;34mvina\u001b[0m/\r\n",
      "\u001b[01;34mcadd\u001b[0m/           \u001b[01;31mgpro.tar.gz\u001b[0m  \u001b[01;34mKPSS\u001b[0m/                         \u001b[01;34mspl\u001b[0m/\r\n"
     ]
    }
   ],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    As in the example, doing this in the IDLE is pretty time consuming and exhausting. Also running python codes from notebook is also pretty easy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_word\n"
     ]
    }
   ],
   "source": [
    "my_word='my word'\n",
    "print my_word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    We can directly run codes in the cell. But also we can call it from directory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/onur/Desktop/ipython\n"
     ]
    }
   ],
   "source": [
    "cd ipython/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2mta.B99990004.pdb  2nd_draft.ipynb  go_score.py    untitled.txt\r\n",
      "2mta_cut.pdb        go_score2.py     ip_test.ipynb\r\n"
     ]
    }
   ],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mkdir new_example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/onur/Desktop/ipython/new_example\n"
     ]
    }
   ],
   "source": [
    "cd new_example/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "myfile=open('myfile.py','w')\n",
    "myfile.write('print \"my word\"')\n",
    "myfile.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my word\n"
     ]
    }
   ],
   "source": [
    "%run myfile.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    As shown in above and this small tutorials it self, both preparing and managing scripts are easier compare to IDLE interface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is GIT how and why we use it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    About GIT, I can say its nice way to handle and manage your files. If you need to store and share your files but also if you want to see changes on those files GIT allows it in a smooth way. When starting, after loading git with $ sudo apt-get install git-all, we need to initialize a folder as our repository with basicly going in a file and typing git init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "u'/home/onur/Desktop/ipython/new_example'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myfile.py\r\n"
     ]
    }
   ],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print \"my word\""
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "less myfile.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized empty Git repository in /home/onur/Desktop/ipython/new_example/.git/\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "git init"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Now this folder initialized for git. Now we can see what is goind on in this file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "Initial commit\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\tmyfile.py\n",
      "\n",
      "nothing added to commit but untracked files present (use \"git add\" to track)\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "git status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "git add ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "Initial commit\n",
      "\n",
      "Changes to be committed:\n",
      "  (use \"git rm --cached <file>...\" to unstage)\n",
      "\n",
      "\tnew file:   myfile.py\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    These few comments above, shows how to add files to tracking and chekcing what going on. Also, with rm option these changes can revert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "my=open('myfile.py','w')\n",
    "word='new'\n",
    "my.write(word)\n",
    "my.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "less myfile.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "Initial commit\n",
      "\n",
      "Changes to be committed:\n",
      "  (use \"git rm --cached <file>...\" to unstage)\n",
      "\n",
      "\tnew file:   myfile.py\n",
      "\n",
      "Changes not staged for commit:\n",
      "  (use \"git add <file>...\" to update what will be committed)\n",
      "  (use \"git checkout -- <file>...\" to discard changes in working directory)\n",
      "\n",
      "\tmodified:   myfile.py\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Since something changed on that file,I recreated the same file with different content so it will overwrite it , Git will ask you to commit those changes. If you dont want you can change it back to original file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "*** Please tell me who you are.\n",
      "\n",
      "Run\n",
      "\n",
      "  git config --global user.email \"you@example.com\"\n",
      "  git config --global user.name \"Your Name\"\n",
      "\n",
      "to set your account's default identity.\n",
      "Omit --global to set the identity only in this repository.\n",
      "\n",
      "fatal: unable to auto-detect email address (got 'onur@onur-VirtualBox.(none)')\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "git commit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "     After giving necessary informations, that will be done once, those files committed and snapthots added to history."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    So far, all these changes done in local machine, now if want we can upload these changes to remote service such as github"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/onur/Desktop/ipython\n"
     ]
    }
   ],
   "source": [
    "cd .."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "git remote add origin https://github.com/onur-ozcan/example_for_git.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "fatal: could not read Username for 'https://github.com': No such device or address\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "git push -u origin master"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    At this part i switched to terminal for logging id and pw for github."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    So every file i have have worked on so far, uploaded to github under https://github.com/onur-ozcan/example_for_git.git I can let people that I worked with to make changes on this remote service, after that with git pull command I can also download those changes and see what is different. This makes a lot easier to work together with different peoples on the same project also all those commits are stored safely. With this way after changes you dont need to upload whole while or you dont need to ask to that person specifically what is changed in the project."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Free Software\n",
    "    Being free software is basicly requires 4 rules as shown in below. Free Sofware Foundation(FSF) is an organization that advocates free software\n",
    "    \n",
    "    I directly quoted there rules from http://www.gnu.org/philosophy/free-sw.html.\n",
    "      \n",
    "    A program is free software if the program's users have the four essential freedoms:\n",
    "\n",
    "    -The freedom to run the program as you wish, for any purpose (freedom 0).\n",
    "    -The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1).\n",
    "    Access to the source code is a precondition for this.\n",
    "    -The freedom to redistribute copies so you can help your neighbor (freedom 2).\n",
    "    -The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.\n",
    "    \n",
    "    So as in  the name free sowfware essentially focuses on freedom which is not same free in terms of price. \n",
    "\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is open source software\n",
    "\n",
    "    As in the free software I'll start with quoting how Open Source Initiative(OSI) describe open source software\n",
    "    from here https://opensource.org/docs/osd\n",
    "    \n",
    "    Open source doesn't just mean access to the source code. The distribution terms of open-source software must comply with the following criteria:\n",
    "\n",
    "1. Free Redistribution:    The license shall not restrict any party from selling or giving away the software as a component of an aggregate software distribution containing programs from several different sources. The license shall not require a royalty or other fee for such sale.\n",
    "\n",
    "2. Source Code:    The program must include source code, and must allow distribution in source code as well as compiled form. Where some form of a product is not distributed with source code, there must be a well-publicized means of obtaining the source code for no more than a reasonable reproduction cost, preferably downloading via the Internet without charge. The source code must be the preferred form in which a programmer would modify the program. Deliberately obfuscated source code is not allowed. Intermediate forms such as the output of a preprocessor or translator are not allowed.\n",
    "\n",
    "3. Derived Works:    The license must allow modifications and derived works, and must allow them to be distributed under the same terms as the license of the original software.\n",
    "\n",
    "4. Integrity of The Author's Source Code:    The license may restrict source-code from being distributed in modified form only if the license allows the distribution of \"patch files\" with the source code for the purpose of modifying the program at build time. The license must explicitly permit distribution of software built from modified source code. The license may require derived works to carry a different name or version number from the original software.\n",
    "    \n",
    "5. No Discrimination Against Persons or Groups:    The license must not discriminate against any person or group of persons.\n",
    "    \n",
    "6. No Discrimination Against Fields of Endeavor:    The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.\n",
    "    \n",
    "7. Distribution of License:    The rights attached to the program must apply to all to whom the program is redistributed without the need for execution of an additional license by those parties.\n",
    "    \n",
    "8. License Must Not Be Specific to a Product:    The rights attached to the program must not depend on the program's being part of a particular software distribution. If the program is extracted from that distribution and used or distributed within the terms of the program's license, all parties to whom the program is redistributed should have the same rights as those that are granted in conjunction with the original software distribution.\n",
    "    \n",
    "9. License Must Not Restrict Other Software:    The license must not place restrictions on other software that is distributed along with the licensed software. For example, the license must not insist that all other programs distributed on the same medium must be open-source software.\n",
    "    \n",
    "10. License Must Be Technology-Neutral:    No provision of the license may be predicated on any individual technology or style of interface.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    After looking through both definitions they are highly close to each other. As I seacrh for hot to differantiate one from other I couldnt came up with clear result. All free softwares are open source by defination however there was a case as tivoization which a software unable to run on different devices where it was open source but not a free software.\n",
    "    \n",
    "    So after looking more, I couldnt find a clear end for conversation however there was an example on https://www.whitesourcesoftware.com/whitesource-blog/open-source-free-software/\n",
    "    \n",
    "    `A pure open source enthusiast, that is not at all influenced by the ideals of free software, will say, “Your program is very attractive. How can I get a copy?” This attitude may reward schemes that take away our freedom, leading to its loss, based on Stallman.\n",
    "    \n",
    "    The free software activist will say, “Your program is very attractive, but I value my freedom more. So I reject your program. I will get my work done some other way, and support a project to develop a free replacement.”`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "    Another explanation that I found was `The two terms describe almost the same category of software, but they stand for views based on fundamentally different values. Open source is a development methodology; free software is a social movement. For the free software movement, free software is an ethical imperative, essential respect for the users' freedom.` from https://www.gnu.org/philosophy/open-source-misses-the-point.en.html\n",
    "    \n",
    "    At the end, for me,both sides want the same thing however their way of wanting it is a little bit different than other. This little difference able to make one licence accepable or not according to them. If we came to my personal opinion, free software advocaters thinking in more idealistic way. For open source software advocaters, they think in more practical.\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Licences\n",
    "\n",
    "    My research about licences brought me to this site which I find more clear than others. https://fosswire.com/post/2007/04/the-differences-between-the-gpl-lgpl-and-the-bsd/\n",
    "    \n",
    "    Basicly all licences are there for protect person, this persons name and his/her works in a way that requested by that person. All licance text is too long to put here but i'll conclude what I understand for each licence.\n",
    "\n",
    "    GPL - It allows end user to use, change and redisrubute but under GPL again so the code wont be part of proprietary software\n",
    "    \n",
    "    BSD and MIT - These two licences are more permissive and allows end user to do whatever he/she wants with the code but also creator not taking any responsibilies about the results. So its more like to prevent usage of your name in unnecessary ways.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}