Search

8/19/2010

The Clean Coder: Why Clojure?

The Clean Coder: Why Clojure?a

I have recently become quite an enthusiast for the language Clojure. But why? Why would someone who has spent the last 30 years programming in C, C++, Java, C#, and Ruby suddenly become enamored with a language that has roots that go back to 1957, i.e. Lisp?

During my first few decades as a professional programmer, I never learned Lisp. I had heard of it, of course; though mostly in derisive terms. People sneered about it with names like "Lots of InSignificant Parentheses". So my view was not particularly favorable.

A few years ago, someone suggested that I learn Lisp by reading a book entitled: "The Structure and Interpretation of Computer Programs". So I went to Amazon and ordered a copy from the used books section. It arrived a week or so later, and then sat on my "to read" stack for a couple of years.

I started reading it about two years ago; and it changed everything I had previously felt and believed about Lisp. It also changed a great deal of what I felt and believed about programming in general. In short, the book was startling.

SICP is a literary masterpiece. It's not often that you can say that a technical book is a page-turner, but that's just what I found SICP to be. The book moves from topic to topic with rare ease and clarity, but more importantly it moves with purpose and mission. As you read it, you can feel the authors slowly building a tension towards a climax. The chapters fly by as you read about data structures, algorithms, message passing, first-class procedures, and so much else. Each concept leads inevitably to the next. Each chapter adds to the ever building tension. By time you are half-way through the book, the sense that something important is about to change becomes palpable.

And then something important changes! Something you had not anticipated. Something you should have guessed, but did not. On page 216 they introduce a concept so familiar that most programming books start with it. On page 216 they prove to you that you've had some wrong ideas about programming all along. On page two hundred and sixteen, after talking about algorithms, data structures, recursion, iteration, trees, high-order procedures, scoping, local variables, data abstraction, closures, message-passing, and a plethora of other topics -- after all that, they introduce assignment!

And with that elegant coup-de-grace (which is not the last in this book!), they vanquish the concept that programming is about manipulating state. With that one stroke, they force you to look back on all you had done in the previous pages in a new and enlightened way -- a functional way.



If you've ever written multi-threaded code, the thought of eight, sixteen, thirty-two, or even more processors running your program should fill you with dread. Writing multi-threaded code correctly is hard! But why is it so hard? Because it is hard to manage the state of variables when more than one CPU has access to them.

And this is where functional programming comes in. Functional programming, of the kind shown in SICP, is a way to write code that does not manage the state of variables, and could therefore be partitioned to run in parallel on as many processors as you like -- at least in theory. In practice it might not be quite that trivial; but one thing is certain. Moving functional programs to massively parallel system will be easier than moving non-functional programs.

Why Clojure?
So why is Clojure the best option for a functional language? After all, there are lots of functional languages out there. Some are old, like Haskell, and Erlang. Some are new like Scala and F#. Why is Clojure the language that has everybody so fired up? Here are just a few reasons.

* Clojure is Lisp. And Lisp is a functional, simple, well-known, elegant language. The syntax is almost laughably terse. This is in contrast to languages like F# and Scala which have a complexity and "quirkiness" reminiscent of C++.
* Clojure is Java. Clojure sits on top of the Java stack, and has the ability to inter-operate with Java with extreme ease. Java programs can call Clojure, and Clojure can call Java. You can write Clojure code that derives from Java classes and overrides Java methods. In short, if you can do it in Java, you can do it in Clojure. What's more there is a Clojure port for the CLR! So Clojure may be the only functional language that inter-operates well with both major VMs.
* Clojure implements Software Transactional Memory which means that any time a Clojure programmer want's to change the state of a variable, they must do so using the same kind of transaction management as they would use for a database. This enforces the functional paradigm do a degree that few other functional languages do. The STM facilities of Clojure are elegant and simple, just like the rest of the language. They do not intrude where they aren't needed, and they are simple to employ where state must be changed.

* Clojure is fast. Data structures in functional languages are immutable. For example, you can't add an item to a list, instead you create a copy of the list with the new item added. This copying could obviously slow things down a lot. Clojure manages complex immutable data structures using a sharing technique that eliminates the need to make deep copies of those structures. This means that Clojure runs very fast.
* Clojure is supported. There are tutorials and blogs. There are IDE plugins. And there are mailing lists and user groups. If you program in Clojure, you won't be alone.

【costco】Lysol 馬桶清潔劑

【costco】Lysol 馬桶清潔劑
Clorox馬桶漂白錠,6顆裝$299

CSS pointer-events to allow clicks on underlying elements

CSS pointer-events to allow clicks on underlying elements
demo


.overlay {
position: absolute;
right: 0px;
top: 0;
width: 40px;
height: 40px;
background: rgba(0, 0, 0, 0.5);
}
.pointer-events-none {
pointer-events: none;
}

8/11/2010

Vim 80 column layout concerns

Vim 80 column layout concerns


function HightLightOverLength()
highlight OverLength ctermbg=darkred ctermfg=white guibg=#FFD9D9
match OverLength /\%>80v.\+/
endfunction

map <F12> :call HightLightOverLength()

vim: jsbeautify : a javascript source code formatter

jsbeautify : a javascript source code formatter

Vim 的 JavaScript 縮排格式最佳化 外掛

1. 於此 jsbeautify : a javascript source code formatter 下載 jsbeautify.vim
2. mkdir -p ~/.vim/plugin
3. mv jsbeautify.vim ~/.vim/plugin/
4. vim .vimrc # 設定 鍵值 (若已經有設好 鍵, 此步驟請跳過)
let mapleader=","
5. ,ff # 直接 ,ff 就可以顯示格式化縮排的結果

vim colorscheme: zenburn

With sufficient thrust, pigs fly just fine. » Zenburn

To use Zenburn in Vim, you must enable the 256-color mode for Vim. This can be done with e.g. export TERM=xterm-256color. You might also need to add set t_Co=256 into your .vimrc file, before loading the colorscheme. Note, that due to limitations of the 256-color mode the color scheme is not exactly like it appears in GVim, but very close nevertheless.

Tweaking Vim For Fun and Profit
tput colors

8/10/2010

清新純淨~WeiB

清新純淨~WeiB

電話:(02)2732-5099
地址:台北市安和路2段71巷6號1樓
官網:http://www.weis.com.tw/index.htm

L’IDIOT 驢子餐廳

L’IDIOT 驢子餐廳

L’IDIOT 驢子餐廳
地址:台北市民生東路三段156號1樓
電話:02-25456966
網站:http://www.lidiotrestaurant.com

8/09/2010

IE的transparent border

CSS Border使用小分享

- 透明:
IE6浏览器不支持transparent透明属性,就border生成三角技术而言,直接设置对应的透明边框的border-style属性为 dotted或是dashed即可解决这一问题,原因是在IE6下, 点线与虚线均以边框宽度为基准,点线长度必须是其宽度的3倍以上(height>=border-width*3),虚线宽长度必须是其宽度的5倍以上(height>=border-width*5),否则点线和虚线都不会出现.
- IE6的奇偶bug:
如果定位外框高度或是宽度为奇数,则IE6下,绝对定位元素的低定位和右定位会有1像素的误差.所以,尽量保证外框的高度或宽度为偶数值.
- IE6的空div高度bug:
IE6下,空div会有莫名的高度,也就是说height:0;不顶用,此时形成的尖角的实际占高于其他浏览器是有差异的.可使用font-size:0; + overflow:hidden;修复此问题.
- filter: chroma滤镜
该属性属性可以设置一个对象中指定的颜色为透明色, 如:

border-color: pink;
filter: chroma(color=pink);


via: Creating Triangle Arrows in pure CSS

demo: http://chunghe.googlecode.com/svn/trunk/experiment/border.slants/ie-transparent-border.html

8/05/2010

Dynamically removing/ replacing an external JavaScript or CSS file

Dynamically removing/ replacing an external JavaScript or CSS file

So what actually happens when you remove an external JavaScript or CSS file? Perhaps not entirely what you would expect actually. In the case of JavaScript, while the element is removed from the document tree, any code loaded as part of the external JavaScript file remains in the browser's memory. That is to say, you can still access variables, functions etc that were added when the external file first loaded (at least in IE7 and Firefox 2.x). If you're looking to reclaim browser memory by removing an external JavaScript, don't rely on this operation to do all your work. With external CSS files, when you remove a file, the document does reflow to take into account the removed CSS rules, but unfortunately, not in IE7 (Firefox 2.x and Opera 9 do).

Notice the helper function createjscssfile(), which is essentially just a duplicate of loadjscssfile() as seen on the previous page, but modified to return the newly created element instead of actually adding it to the page. It comes in handy when parentNode.replaceChild() is called in replacejscssfile() to replace the old element with the new. Some good news here- when you replace one external CSS file with another, all browsers, including IE7, will reflow the document automatically to take into account the new file's CSS rules.

快速做好重灌隨身碟,歷代Windows全支援


快速做好重灌隨身碟,歷代Windows全支援

* 軟體名稱:WinToFlash 0.6beta
* 官方網站:http://wintoflash.com/home/en/
* 下載網址:按我下載
* 檔案大小:6.7 MB
* 更新日期:2010年7月20日
* 使用限制:無(Freeware)