This questions are mainly from internet.

Recently I forked a project on Github.com, and renamed it to vim4Lin which is a vim configuration. The project can be used to help to synchronize the configuration files of vim on multiple machines. However, I intentionally want to focus its experiences on Linux, such as Ubuntu. The project you can find in this following url: https://github.com/bfeng/vim4Lin

Overview

This is another vim configuration, which I normally use under terminal. So default theme is changed to molokai, which is optimized for C under terminals.

Vim related settings are in plugin/settings/Settings.vim, and other plugins’ settings are in plugin/settings corresponding directories.

Two vimrc files:

1. vimrc, standard version vimrc.

2. gvimrc, same as vimrc, but added some features only available in GUI mode.

you can link your ~/.vimrc to any one of them as you wish :)

It’s a screenshot of the up-to-date configuration:

The content above is from http://flask.pocoo.org/snippets/5/

Installation and Update

1. BACKUP your .vim directory and .vimrc first.(IMPORTANT!)

2. cd ~ to change directory to your home directory.

3. Clone files to your home directory:

    git clone https://github.com/bfeng/vim4Lin.git
   

4. cd to vim4Lin directory and execute the update.sh to get latest version modules:

    cd vim4Lin
    ./update.sh
   

5. make a symbolic link .vim to vim4Lin that you just cloned, or just rename it to .vim also be fine:

    ln -s vim4Lin .vim
   

6. link the vimrc to

    ln -s .vim/vimrc .vimrc
   

7. if you use GUI version VIM, such as MacVim or GVim, you can also link to .gvimrc:

    ln -s .vim/gvimrc .gvimrc
   

8. change directory to ~/.vim and execute ./update.sh script, it should do all the updates automatically.

Features and Key Mappings

1. Resize splited windows automatically, so that you get a bigger editing room if you’re working with a smaller screen. (stole from Gary Bernhardt)

2. Toggle between working mode and presentation mode by \``z, but only work in GUI version Vim. You can check here to see how it looks like. (stolen from Mike Skalnik)

3. some usually used key mappings in normal mode:

   1. <F1> to toggle a Calendar window on and off.

   2. <F2> to toggle NERDTree on and off.

   3. <F4> to toggle Taglist window.

   4. <F5> is the script runner, according to it’s filetype, it will run Ruby(.rb) ,Python(.py) or Javascript(.js) file(SpiderMonkey is needed), even CoffeeScript(.coffee, but you may have to install CoffeeScript first). If the filetype is VimScript, <F5> will run :source % for you.

   5. <F7> to switch to previous tab, and <F8> to the next tab.

   6. hit <ctrl>p will launch a quick window to match keywords from your current working directory, not only file name, but also path name. And <ctrl>w u will match from your MRU(Mostly Recent Used) files, which is also frequently used.

   7. hit \ twice to toggle comment on and off.

   8. <tab> and <shift><tab> to increase and decrease the syntax indentation. By default, <tab> will invoke the code-completion prompt. If you need to input a real <tab> into text, hit <ctrl>v and <tab>.

   9. \``v to open .vimrc in a new tab.

   10. \``0 to edit or create README.md in current working directory.

4. Remove tailing whitespace automatically while saving.

5. Exuberant Ctags is recommended for the executable of ctags.

Reference

This work was forked from Eddie Kao’s eddie-vim. Thanks! Some modules, such as which support flex and css colors, are moved out, and add some modules which support latex are added in. The molokai theme is now supported as the main coding theme and vim-airline replaces the obsolte vim-powerline. Much work were done to focus on the compatibility between the GUI mode and the console mode.

By default the cuda is not working on Ubuntu. You may not want to crash your system. Please do exactly follow the instruction step by step. If you are brave enough like me or you are still OK to handle the problem properly even if only the Linux kernel and SSH are working fine, there is no need to backup your system at first.

1. Go to the CUDA official website and download the Getting started guide for your system
1. https://developer.nvidia.com/cuda-downloads
2. Read the installation guide from Cuda official website
1. install all the prerequisites for your system 
3. Download Cuda 5 installation
1. typically it’s a cuda5.run file
4. Remove the existing nvidia driver from Ubuntu official reposistory
1. $ sudo apt-get remove –purge nvidia
5. Change tty to anyone without gui:
1. eg. ctrl + alt + F1
6. Stop the default dm:
1. eg. $ sudo service lightdm stop
7. Install gcc and change the default gcc to gcc-4.4:
1. sudo apt-get install gcc gcc-4.4
2. sudo update-alternatives –remove-all gcc ( if you have previous configuration )
3. sudo update-alternatives –config gcc ( if you have previous configuration )
4. sudo update-alternatives –install /usr/bin/gcc gcc /usr/bin/gcc-4.4 20
5. gcc –version
1. gcc 4.4.* or something like that should be printed out
8. Run installation:
1. chmod +x <cuda>.run
2. sudo ./<cuda>.run

Introduction

This article is to introduce you PyCUDA, which is a python framework allows you write NVidia’s GPU program in a pythonic way. This framework is consisted of two major parts. The first part is a cuda source code compiler, which compiles the embedded cuda code in python at runtime. The second part is to do the computing by leveraging the numpy, which is also a famous python library for scientific computing.

Start with your first Pycuda program

This website gives out the PyCUDA’s documentation.

Here is an example from the above.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import pycuda.autoinit
import pycuda.driver as drv
import numpy

from pycuda.compiler import SourceModule
mod = SourceModule("""
  __global__ void multiply_them(float *dest, float *a, float *b)
  {
    const int i = threadIdx.x;
    dest[i] = a[i] * b[i];
  }
  """)

multiply_them = mod.get_function("multiply_them")

a = numpy.random.randn(400).astype(numpy.float32)
b = numpy.random.randn(400).astype(numpy.float32)

dest = numpy.zeros_like(a)
multiply_them(
drv.Out(dest), drv.In(a), drv.In(b),
block=(400,1,1), grid=(1,1))

print dest-a*b

In this example, the SourceModule is used to create a python Module from the cuda source code. This involves the Just-in-time compilation. Then, get_function is used to extract the function from that compiled module, hence the following program can directly call the function like a normal python function.

pycuda.driver helps to copy-in and copy-out the data between the main memory and the GPU memory. drv.Out function wraps the variable, which is used in the main memory, in contrast if the variable will be used in GPU memory, use drv.In. Other parameters, like block and grid are the same as used in the normal c cuda program. This blog post gives nice explanation about them: http://www.resultsovercoffee.com/2011/02/cuda-blocks-and-grids.html.

Conclusion

With the help of the some libraries, such as numpy, scipy and etc., PyCuda gives us another handful method to do the scientific computing. By leveraging the GPU computing power, we can not only process and analyze data sets but also do it efficiently.

For a long time, I really envy those who have Chrome book, whose OS is not a normal Linux distribution (of course), but a browser based OS. Chrome OS is a cool way to use computers. However if you want to try it, you can try install it on a virtual machine or if you don’t care about money you can buy one.

But if you just want to taste a Chromebook-like experience, worn out of trying it in a virtual machine and don’t want to waste money to buy a real one and the most is that you happened to have an old laptop like mine (the one I’m typing on), you can try to install Joli OS.

I was looking for a free, nice prototype tool for web and mobile design for a long time. It’s actually not hard to find an useful prototype or mock-up tool, but it’s not easy to find a one which is free and easy to use on laptop and desktop which means the software is natively installed.

So, yes, Pencil did the right thing. It is also an add-on for firefox here: https://addons.mozilla.org/en-us/firefox/addon/pencil . And also the home page here: http://pencil.evolus.vn/

Let’s talk about its features. Although the on-line editing tools are so popular today, sometimes we just want to memorize the quick responsiveness of native apps. Facilitated by Mozilla’s xulrunner, the project provides cross-platform installations. This is very cool feature if you needs to work on different types of operating systems.

It’s a nice and easy to use tool for web design. It meant a not so complicated web but good enough for prototyping.

It has the latest Android interface mockups. This is a very cool feature that most Android developers would love, because this tool could create an almost exact the same UI for Android mobiles and tablets. In addition, of course, to make this tool a strong competitor, this tool also supports iOS wireframes and GUIs.

1. Create a virtual machine
2. Change the network to bridge mode
3. Install Ubuntu Server OS
4. Setup the hostname to something like “node-01”
5. Boot up the new virtual machine
6. Remove some network rules sudo rm -rf /etc/udev/rules.d/70-persistent-net.rules
7. Clone the virtual machine
8. Initialize with a new MAC address
9. Boot up the cloned virtual machine
10. Edit /etc/hostname: change “node-01” to “node-02”
11. Edit /etc/hosts: change “node-01” to “node-02”
12. Reboot the cloned virtual machine
13. Repeat step 7 to 13 until there are enough nodes

Note: the ip address of each node should start with “192.168.” unless you don’t have a router.

Today I watched a video of porting Qt application into Android. It looks so fantastic that more and more platforms are emerging, iPhone, Android, Windows, and some others flying on netbooks with touch capabilities. Let’s call them smart mobile devices.

The typical problem developers are being solving is to make an application and port it to more available platforms. However, porting is so frustrated to programmers because it is like a progress of copying yourself. In contrast, DRY (don’t copy yourself) is the first principle of programming.

Other technologies which can help to do porting seems great. At least this one looks so.

The simplest answer to this question is that I am too lazy.

The more, I’m always doing refactoring until I can’t tough them. But it’s obvious that I don’t want to test the code again and again, not to mention testing manually. So unit testing is great to keep me safe that I wouldn’t crash the whole system after refactoring.