Acquire::http::proxy "http://ProxyServerAddress:ProxyServerPort/";
Acquire::ftp::proxy "ftp://ProxyServerAddress: ProxyServerPort/";
$svn co https://drjava.svn.sourceforge.net/svnroot/drjava drjavaNow if you wish to add new file to the svn repository the command is very simple. For example if you wish to add the text file readme.
$svn add README_TEXTThe above command will not add it to the server but add it to the schedule. If you wish to view current status of additions, deletions that are scheduled you could use the command
$svn statusAnd finally if you are satisfied simple do the following and the commit will be done meaning all the changes will now be part of the repository and a new version will be assigned. REMEMBER adding/ deleting/ changing code in a repository requires permissions. Therefore you might be prompted for passwords during the process.
$svn commitThis is all the information that you need to get past the basic svn commands and concentrate on your project.
$svn help
$ mysql -u username -pthe command will prompt for a password
mysql> Show databases;The above two commands are extremely useful when one wants to look at the databases installed and tables in individual databases.
mysql> show tables;
mysql> use drupal6;
mysql> select * from users;
where the first argument is the regular expression for finding one or more spaces and the second argument is the input text.preg_split ("/\s+/",$textInput);
$ mysqladmin -u db_user -p create JoomlaMySQL will prompt for the 'db_user' database password and then create the initial database files. Next you must login and set the access database rights e.g.
$ mysql -u db_user -pAgain, you will be asked for the 'db_user' database password. At the MySQL prompt, enter following command:
GRANT ALL PRIVILEGES ON Joomla.*where:
TO nobody@localhost IDENTIFIED BY 'password';
Query OK, 0 rows affectedto activate the new permissions you must enter the command
flush privileges;and then enter '\q' to exit MySQL.
$ sudo apt-get install octaveOnce installed octave can be invoked via the command.
$ octaveIts best to understand the modus operandi of Octave. Like lists are the primary data structures in LISP Language. In octave vectors are at the core. Vectors are used to store information, manipulate information via vector algebra and display data still using 2D/3D graphics. Applications of octave are huge but we will use probability as a starting point and see how we can learn better probability using the computational and graphical features of octave.
octave:1> x=[1 2 3 4 5 6]The following values x = and followed by 1 2 3 4 5 6, shows the value stored in the vector x. This display can be avoided by placing a semi-colon (;) at the end of the command. Now that we have declared a variable named x with values lets see how octave stores it. This can be achieved anytime by writing the command whos on the command line of octave.
x =
1 2 3 4 5 6
octave:2> whosThe size of variable x is 1x6 which means that its a vector (matrix) of size 1 row and 6 columns, with 48 bytes needed to store it while the class of variables in double.
Variables in the current scope:
Attr Name Size Bytes Class
==== ==== ==== ===== =====
ans 1x30 30 char
x 1x6 48 double
octave:3> px=1/6*ones(1,6)Here in the above code we have used the function ones which helps to declare a vector of size 1x6 and initialize it with ones. We simply multiply it with 1/6 to get 0.16667 in all the elements. In order to check what is the probability of event 3 simply write the following command.
px =
0.16667 0.16667 0.16667 0.16667 0.16667 0.16667
octave:4> px(3)Similarly for all the other events. This was simple because we used the simplest possible probability model.
ans = 0.16667
octave:5> mu=3.5; sigma=1;
octave:6> fx=(1/sqrt(2*pi*sigma^2)*exp(-(x-mu).^2/(2*sigma^2)));
fx =
0.017528 0.129518 0.352065 0.352065 0.129518 0.017528
octave:8> x=[1:0.1:6];
octave:9> fx=(1/sqrt(2*pi*sigma^2)*exp(-(x-mu).^2/(2*sigma^2)));
octave:10> plot(x,fx)
octave:10> mu=[40, 60]; sigma=[100, 30; 30, 140]; octave:39> isigma = inv(sigma);
octave:11> detsigma = det(sigma);
octave:12> coeff = 1/(2*pi*sqrt(detsigma));
octave:13> for i=1:100
> for j=1:100
> x = [i;j];
> xm = x - mu;
> p(i,j) = exp(-0.5*xm'*isigma*xm);
> end
> end
octave:14> p=p*coeff;
octave:15> [X,Y]=meshgrid(1:100,1:100);
octave:16> surf(X,Y,p);
$ sudo apt-get install umbrelloOnce installed the program is available in Applications--> Programming menu.
$ sudo apt-get install pythonThe first step to testing a language is to write a hello world program.
$ pythonOnce inside the shell. Type print "hello world" and the output hello world will appear.
>>> print "hello world"Another way of saying hello from the Python world is via creating a text file and writing the same in it and then saving it say "helloworld.py" and then on the command prompt executing the following statement.
hello world
$ python helloworld.pyOr to write the following in the interactive shell. (Please note that .py is not written)
>>>import helloworldThe Next Step Forward
>>> import subprocessFunctions in Python
>>> subprocess.call(["df","-h"])
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 1299.4G 5.0G 4.0G 56% /
udev 490M 228K 490M 1% /dev
def fact(n):Notice how similar it is to the factorial code written in any other C-lookalike language. The keyword def indicates the start of a function. Now execute the code in the interactive shell using the following commands.
if n==1:
return 1
else :
return fact(n-1)*n
Examples include finding 2!, 10! and 4! respectively
>>> import factorial
>>> factorial.fact(2)Now lets write another function but this time its not recursive rather its iterative version of Fibonacci Serics. Write the following in a text file and save as fibonnaci.py. Notice how multiple assignments and increments are being performed.
2
>>> factorial.fact(10)
3628800
>>> factorial.fact(4)
24
def fib(n):Execute the function in the interactive shell using the following commands.
a, b = 0, 1
while b < n:
print b,
a,b = b, a+b
>>> import fibonnaciObject-Oriented Python
>>> fibonnaci.fib(10)
1 1 2 3 5 8
>>> fibonnaci.fib(100)
1 1 2 3 5 8 13 21 34 55 89
class NameClass :Now write the following in the interactive shell to test not only the class method but also to create the instance of the class.{Notice that PrintName is the name of the module loaded. Hence required to create instance of the class NameClass}
myFirstName, myLastName = "Alexia", "Candella"
def printName(self):
print self.myFirstName
print self.myLastName
>>> import PrintName
>>> x=PrintName.NameClass()
>>> x.printName()
Alexia
Candella
Could not locate a suitable Java runtime.This requires installation of Java 6 by using the following command (another roughly 55 MB).
Please ensure that you have Java 6 or newer installed on your system
and accessible in your PATH or by setting JAVA_HOME
$ sudo apt-get install sun-java6-jdkNow going back to the Java EE installation through the following command.
$ sh java_ee_sdk-6-web-unix.shGoing through the clicks (one has to only write the password for admin account and the proxy if any). Rest of the information is filled in by default.
http://localhost:4848If you changed the value of admin control panel port. Please replace 4848 with the port number you specified during installation. This would open the administration control panel (shown below) and demand user name and password. Please put the username/ password which were set during installation.
$ vi .bashrcGo to the end and add the following please note # indicates comments its healthy practice to write comments so that later we know why we wrote the particular lines.
# Proxy settings
export http_proxy="http://MY_PROXY_IP_OR_HOST:MY_PROXY_PORT"
export ftp_proxy="http://MY_PROXY_IP_OR_HOST:MY_PROXY_PORT"
$ w3m www.google.com
$ sudo apt-get install clispAlongside this its recommended to install the HTML version of the book Common Lisp the language, 2nd Edition by Guy L. Steele Jr.
$ sudo apt-get install cltlThe book is installed in the /usr/share/doc/cltl/clm/index.html.
$ clispTry out the lisp-expression to add 2 and 2 the result is in the second line.
[1]> (+ 2 2)Build on more complex lists. The following expression is lisp way of (1*2)+ 6.
4
[2]> (+ (* 1 2) 6)Now with the increase in comfort and confidence that lisp is installed and functional. Assigning values to variables is done via the following command
8
[3]> (setq a 10)For an extremely simple loop using the print command to print hello world five times.
10
[4]> (do ((x 1 (+ x 1))) ((> x 5)) (print "hello world"))Step 3: Doing something more than "hello world"
"hello world"
"hello world"
"hello world"
"hello world"
"hello world"
NIL
[5]> (defun increment (x) (+ x 1))The line 5 defines the function named increment which essentially has one argument and one line in which the argument is incremented by one. The line 6 calls the function increment with the argument passed as second member of the list.
INCREMENT
[6]> (increment 10)
11
(defun square(x) (x*x))Exploration of LISP on emacs is another really interesting topic which needs a dedicated post.
(setq x 10)
(square x)
\documentclass{article}The following command creates an output file (pdf format) with same name as the name of the tex file.
\title{Welcome to Freedom}
\begin{document}
\maketitle
This is a sample document which showcases the freedom and peace of mind offered by using {LATEX}
\end{document}
$ pdflatex firstTry.tex
\documentclass{article}The following screen shot exhibits the usage of the above tags.
\title{Welcome to Freedom}
\begin{document}
\maketitle
This is a sample document which showcases the freedom and peace of mind offered by using \LaTeX
\section{Formating Sections}
The best part is that you dont have to set font sizes and then try to place the
section headings
\subsection{Sub Sections are cool}
Adding simple tag of subsection simply adds more sections and special part is there is no numbering involved. The numbering is dealt with automatically at the time of preparing pdf file.
\subsubsection{Moving further inside we can enjoy better functionality}
This shows how easy it is create subsections within subsections. Simply continue
to add sub behind the tag and it goes deeper and deeper.
\section{Simplicity is still the essence}
So the current document if shown to a novice will scare away but we are begining to get the feel of Latex.
Rest would be mostly easier part
\end{document}
Instead of going into the details of each and every command/ tag. Its far better to use the "i will learn it when I need it" approach. This can only be achieved by keeping a tap on where to get the desired information. One method is to use "The (Not So) Short Introduction to LATEX 2E" as a reference and simply copy and use any commands (examples) and tweak to requirement.
- Give a man a fish and you feed him for a day. Teach a man to fish and you feed him for a lifetime.
\section{Explaining how to write Mathematical Equations}
One simple way to write mathematical equations is $A_x^2$ or using the tags begin equation and end equation
\begin{equation}
\sum_{i=0}^{\infty} X_i=0
\end{equation}
\begin{equation}
\omega = \Omega
\end{equation}
\begin{equation}
\sigma = \Sigma
\end{equation}
Where proxy.example.com is simply the address of proxy and could be replaced by the IP Address of the proxy server. 8080 is the port address for http in most networks but could be different in some networks.
function FindProxyForURL(url, host){return "PROXY proxy.example.com:8080; DIRECT";}
grep -l ".*" *REMEMBER this only lists the files (not directories). Now this is not why grep is used but simply given to enhance confidence of the user that "yes we can" use grep. The command ls can be used to list contents of current working directory. The command grep is used to do something more productive. Now lets start doing something ls might not do. Lets try to find all the files with the word "include" IN them. The following simple command does this simply.
grep -l "include" *To search all the subdirectories add r to the options which means to search recursively.
grep -lr "include" *This is all one actually needs to start using grep a little bit more effectively.
grep -l "[td]rap" *
grep -l "^a" *And the following command simply searches words which end with the alphabet d.
grep -l "d$" *Now in combination the following command can be used to find the files which contain words starting with alphabet a and ending with the alphabet d.
grep -l "^a.*d$" *This was accomplished by simply adding the ".*" between the two alphabets ensures that anything in between the start and end "pattern".
grep -l "^[aeiou]" *This command searches for all the words that start with a vowel i.e, a,e,i,o or u. This can be used in combination by using commands similar to the following where the files listed contain words that start with a or b and end with d or s.
grep -l "^[ab].*[ds]$" *Now the expression in brackets can be improved by using ranges and groups.
grep -l "^[A-Za-z].*[0-9]$"The above discussion is enough for a Linux newbie to appreciate the usage of grep command and be comfortable at different levels. In order to attain more power in using grep consult man / info pages of grep or any advanced grep or regex tutorial over the Internet.
And boom ... one is able to use Linux X-Windows Graphical Interface over Windows Machine.
Linux Box
Step 1: Run vncserver command and then vncpasswd command to set password for entry. The first command will give you "New 'X' desktop is HOST_NAME:DISPLAY_NUMBER".
Windows
Step 2: Install vncviewer from the website (http://www.realvnc.com/cgi-bin/download.cgi). Then run the vncviewer and enter the information HOST_IP_ADDRESS:DISPLAY_NUMBER. Clicking ok will prompt for password. Enter the password set using vncpasswd command.
$ as helloWorld.s -o helloWorld.o
$ ld -helloWorld.o -o helloWorld.outTo execute the code we need to do the following.
$ ./helloWorld.out
.text
.global _start
_start:
movl $len,%edx # third argument: message length
movl $msg,%ecx # second argument: pointer to message to write
movl $1,%ebx # first argument: file handle (stdout)
movl $4,%eax # system call number (sys_write)
int $0x80 # call kernel
# and exit
movl $0,%ebx # first argument: exit code
movl $1,%eax # system call number (sys_exit)
int $0x80 # call kernel
.data # section declaration
msg:
.ascii "Hello, world!\n" # our dear string
len = . - msg # length of our dear string
testString="aaabbbbc"This completed the test of ruby in Ubuntu. More about ruby over rails later.
if testString=~/^a*b*c$/
print testString, " is in the language a*b*c\n"
else
print testString, "is not in the language a*b*c\n"
end
testString="aaaaacb"
if testString=~/^a*b*c$/
print testString, " is in the language a*b*c\n"
else
print testString, "is not in the language a*b*c\n"
end
