LOFTER for ipad —— 让兴趣,更有趣

点击下载 关闭

LOFTER-网易轻博

计算机科学

770浏览    43参与
程序媛洛塔丝

csc教授安利

打母校tag说一句,cs的课,要是教授是danny heap,jacqueline smith,或者Lindsey Shorsher,不要犹豫赶快选。都是优秀暖心到必须安利的教授。


认识了danny,我才知道只有足够的热爱,你才能在六十多岁的时候,还有清澈纯净的眼神。哪怕驼背成直角还没几根头发,danny是不折不扣的少年。


Jacqueline是csc148的宝藏,会在office hour因为我的蠢问题画满整个屏幕的memory diagram。如果说danny是你能想到的最好的数学教授,Jacqueline就是the ...

打母校tag说一句,cs的课,要是教授是danny heap,jacqueline smith,或者Lindsey Shorsher,不要犹豫赶快选。都是优秀暖心到必须安利的教授。


认识了danny,我才知道只有足够的热爱,你才能在六十多岁的时候,还有清澈纯净的眼神。哪怕驼背成直角还没几根头发,danny是不折不扣的少年。


Jacqueline是csc148的宝藏,会在office hour因为我的蠢问题画满整个屏幕的memory diagram。如果说danny是你能想到的最好的数学教授,Jacqueline就是the programming professor we dont deserve。更别说她还喜欢猫。


众所周知我系从教授到学生全是社恐,我曾目睹过试图自我介绍,对方五分钟后僵硬地转动脖子点了点头的惨剧。


Lindsey是cs的异类,淡定和理性的内核外包裹着热情洋溢的糖浆小饼干。她成功地让我在第一节207上就认识了三个人,虽然我们四个社恐谈话非常尴尬(“你上什么课?”“……这个课。”),但这至少是个开始,多亏了她。


中间休息时我抱着ipad去问她问题,答疑条理清晰,直击重点,而且充满激情。每次和她说话心情都会变好,多大这种情绪黑洞里有这样的人真是幸运。


就酱。


hdw2000
程序媛洛塔丝

十点到下午五点半在图书馆死磕graph theory的pset。

一打开只有两道题,太蹊跷了。

果然,我们为写完第一题弹冠相庆,然后发现第二题七个小题全是证明。

我:………okay。

在画了一百多条edge之后我终于证出了第一小题。仿佛看到教授慈祥(又佝偻)的背影冲我摆手:傻孩子,这智商学啥cs啊。

一个队友在死磕runtime,另一个完全clueless于是拿起了化妆包。

我:……我可是脸都没洗就爬起来写了朋友。

最后我死磕runtime的队友磕死了runtime,化妆包队友也补好了妆,然后我们一起死磕最后一小题。

队友1:我好饿。

队友2:我想吃麻辣烫。

我:啊啊啊啊啊...

十点到下午五点半在图书馆死磕graph theory的pset。

一打开只有两道题,太蹊跷了。

果然,我们为写完第一题弹冠相庆,然后发现第二题七个小题全是证明。

我:………okay。

在画了一百多条edge之后我终于证出了第一小题。仿佛看到教授慈祥(又佝偻)的背影冲我摆手:傻孩子,这智商学啥cs啊。

一个队友在死磕runtime,另一个完全clueless于是拿起了化妆包。

我:……我可是脸都没洗就爬起来写了朋友。

最后我死磕runtime的队友磕死了runtime,化妆包队友也补好了妆,然后我们一起死磕最后一小题。

队友1:我好饿。

队友2:我想吃麻辣烫。

我:啊啊啊啊啊我啥都想吃。

于是我们跑去吃麻辣烫,一边吃一边讨论,最后一拍大腿卧槽原来可以用contradiction证cycle的!

放下碗,豪气干云打开麻辣烫店的门,哇外面真冷,我们差点缩回去把汤喝了。

写完pset天黑了,我溜回家想学(mo)习(yu),屁股一粘凳子:

“卧槽今天线代peer review是不要due?”

还没站稳我又:

“卧槽我今天还要教10年级的?”

差点一个趔趄倒地上。

于是乎,现在11:50,我辅导了会高中数学,用根号二的无理数证明和imaginary number吓了吓小朋友(??),然后奋笔疾书线代,试图看上去会我根本不会的eigenvalue还是啥。

哇,我今晚才不要定闹钟_(:з」∠)_


突然发现还有20天我就20岁了_(:з」∠)_ 新的十年要成为更好的人!


HermanHeLF

企划·第三只手

企划·第三只手

   概要:实现对于特定输入产生一系列一定范围内的随机输出,以模拟自然状态下,对于一定范围内输入出于人工或复杂影响条件而产生的一定范围内的固定模式化随机输出

实例:人类手工有义字段.

step1.输入有义字段a

    a.编码输入:进入step2

    b.图像输入:进行计算机视觉分析,同时将图像作为学习原料.进入step2

step2.意义随机化处理

      1.在统计地图中设定对象特征矢量 ...

企划·第三只手

   概要:实现对于特定输入产生一系列一定范围内的随机输出,以模拟自然状态下,对于一定范围内输入出于人工或复杂影响条件而产生的一定范围内的固定模式化随机输出

实例:人类手工有义字段.

step1.输入有义字段a

    a.编码输入:进入step2

    b.图像输入:进行计算机视觉分析,同时将图像作为学习原料.进入step2

step2.意义随机化处理

      1.在统计地图中设定对象特征矢量    

      2.对有义字段a进行自然语言分析.根据对象特征矢量符合程度随机替换随机个有义字段单元,得到有义字段c

      3.进入step3

step3.表象随机化处理.

      1.输入一定量指定字样本图像b.

      2.根据f(b)=指定字函数关系得到样本随机化处理函数.

      3.使用随机数在小范围内影响函数,得到有义字段c的指定格式字图想d

    step4.输出

       连接到指定打印机.

附录:「打印机」:「打印机」应该是一种拥有自我的位移能力,可以对目标载体的指定部位印刷具有长效保存能力的指定材料的装置.应该指出的是这一装置应尽可能的「表面化」,即在同一时间只接触目标载体的一部分单一表面,以适应需要保护的目标载体及自身条件不允许进行传统打印机印刷的目标载体.


澳洲成功出国留学网
IT 计算机&信息网络 技术
互聯網登錄系統曝出重大漏洞 黑...

互聯網登錄系統曝出重大漏洞 黑客可用知名網站釣魚 – Covert Redirect


繼OpenSSL漏洞後,開源安全軟件再曝安全漏洞。新加坡南洋理工大學研究人員,物理和數學科學學院博士生王晶 (Wang Jing) 發現,OAuth 2.0, OpenID 授權接口的網站存隱蔽重定向漏洞、英文名為“Covert Redirect”。


攻擊者創建壹個使用真實站點地址的彈出式登錄窗口——而不是使用壹個假的域名——以引誘上網者輸入他們的個人信息。


黑客可利用該漏洞給釣魚網站“變裝”,用知名大型網站鏈接引誘用護登錄釣魚...

互聯網登錄系統曝出重大漏洞 黑客可用知名網站釣魚 – Covert Redirect


繼OpenSSL漏洞後,開源安全軟件再曝安全漏洞。新加坡南洋理工大學研究人員,物理和數學科學學院博士生王晶 (Wang Jing) 發現,OAuth 2.0, OpenID 授權接口的網站存隱蔽重定向漏洞、英文名為“Covert Redirect”。

 

攻擊者創建壹個使用真實站點地址的彈出式登錄窗口——而不是使用壹個假的域名——以引誘上網者輸入他們的個人信息。

 

黑客可利用該漏洞給釣魚網站“變裝”,用知名大型網站鏈接引誘用護登錄釣魚網站,壹旦用護訪問釣魚網站並成功登六授權,黑客即可讀取其在網站上存儲的私密信息。

 

騰訊,阿裏巴巴,QQ、新浪微博、淘寶網,支付寶,網易,PayPal, eBay, Amazon, Facebook、Google, LinkedIn, Yahoo, VK.com, Microsoft,  Mail.ru, Github, WordPress 等國內外大量知名網站受影響。

 

鑒於OAuth和OpenID被廣泛用於各大公司——如微軟、Facebook、Google、以及 LinkedIn——Wang表示他已經向這些公司已經了匯報。Wang聲稱,微軟已經給出了答復,調查並證實該問題出在第三方系統,而不是該公司的自 有 站點。Facebook也表示,“短期內仍無法完成完成這兩個問題的修復工作,只得迫使每個應用程序平臺采用白名單”。至於Google,預計該公司 會追 蹤OpenID的問題;而LinkedIn則聲稱它將很快在博客中說明這壹問題。

 

OAuth 是壹個被廣泛應用的開放登六協議,允許用護讓第三方應用訪問該用護在某壹網站上存儲的私密的信息(如照片,視頻,聯系人列表),而無需將用護名和密碼提供給第三方應用。這次曝出的漏洞,可將Oauth2.0的使用方(第三方網站)的回跳域名劫持到惡意網站去,黑客利用XSS漏洞攻擊就能隨意操作被授權的帳號,讀取用護的隱私信息。像騰訊、新浪微博等社交網站壹般對登六回調地址沒有任何限制,極易遭黑客利用。

 

 

 

相關資料,
http://www.cnet.com/news/serious-security-flaw-in-oauth-and-openid-discovered/
http://tech.firstpost.com/news-analysis/after-heartbleed-major-covert-redirect-flaw-threatens-oauth-openid-and-the-internet-222945.html
http://tetraph.com/covert_redirect/oauth2_openid_covert_redirect.html
http://techxplore.com/news/2014-05-math-student-oauth-openid-vulnerability.html
http://phys.org/news/2014-05-math-student-oauth-openid-vulnerability.html
http://www.tomsguide.com/us/facebook-google-covert-redirect-flaw,news-18726.html
http://news.yahoo.com/facebook-google-users-threatened-security-192547549.html
http://thehackernews.com/2014/05/nasty-covert-redirect-vulnerability.html
http://www.scmagazine.com/covert-redirect-vulnerability-impacts-oauth-20-openid/article/345407/
http://blog.kaspersky.com/facebook-openid-oauth-vulnerable/
http://www.foxnews.com/tech/2014/05/05/facebook-google-users-threatened-by-new-security-flaw/
http://tech.ifeng.com/internet/detail_2014_05/03/36130721_0.shtml/
http://network.pconline.com.cn/471/4713896.html
http://media.sohu.com/20140504/n399096249.shtml/
http://it.people.com.cn/n/2014/0504/c1009-24969253.html
http://www.cnbeta.com/articles/288503.htm
http://www.inzeed.com/kaleidoscope/computer-security/oauth-2-0-and-openid-covert-redirect/
http://itinfotech.tumblr.com/post/118850342491/covert-redirect
http://baike.baidu.com/link?url=0v9QZaGB09ePxHb70bzgWqlW-C9jieVguuDObtvJ_6WFY3h2vWnnjNDy4-jliDmqbT47SmdGS1_pZ4BbGN4Re_
http://tetraph.com/covert_redirect/
https://zh.wikipedia.org/wiki/%E9%9A%B1%E8%94%BD%E9%87%8D%E5%AE%9A%E5%90%91%E6%BC%8F%E6%B4%9E
http://www.baike.com/wiki/%E9%9A%90%E8%94%BD%E9%87%8D%E5%AE%9A%E5%90%91%E6%BC%8F%E6%B4%9E
http://www.csdn.net/article/2014-05-04/2819588

 


SSer_余舜哲_哲服

Want to start a startup? why LISP?

April 2001, rev. April 2003

(This article is derived from a talk given at the 2001 Franz Developer Symposium.) 

In the summer of 1995, my friend Robert Morris and I started a startup called Viaweb. Our plan was to write software that would let end users build online stores. What was novel about this...

April 2001, rev. April 2003

(This article is derived from a talk given at the 2001 Franz Developer Symposium.) 

In the summer of 1995, my friend Robert Morris and I started a startup called Viaweb. Our plan was to write software that would let end users build online stores. What was novel about this software, at the time, was that it ran on our server, using ordinary Web pages as the interface.

A lot of people could have been having this idea at the same time, of course, but as far as I know, Viaweb was the first Web-based application. It seemed such a novel idea to us that we named the company after it: Viaweb, because our software worked via the Web, instead of running on your desktop computer.

Another unusual thing about this software was that it was written primarily in a programming language called Lisp. It was one of the first big end-user applications to be written in Lisp, which up till then had been used mostly in universities and research labs. [1]

The Secret Weapon

Eric Raymond has written an essay called "How to Become a Hacker," and in it, among other things, he tells would-be hackers what languages they should learn. He suggests starting with Python and Java, because they are easy to learn. The serious hacker will also want to learn C, in order to hack Unix, and Perl for system administration and cgi scripts. Finally, the truly serious hacker should consider learning Lisp:

Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot.
This is the same argument you tend to hear for learning Latin. It won't get you a job, except perhaps as a classics professor, but it will improve your mind, and make you a better writer in languages you do want to use, like English.

But wait a minute. This metaphor doesn't stretch that far. The reason Latin won't get you a job is that no one speaks it. If you write in Latin, no one can understand you. But Lisp is a computer language, and computers speak whatever language you, the programmer, tell them to.

So if Lisp makes you a better programmer, like he says, why wouldn't you want to use it? If a painter were offered a brush that would make him a better painter, it seems to me that he would want to use it in all his paintings, wouldn't he? I'm not trying to make fun of Eric Raymond here. On the whole, his advice is good. What he says about Lisp is pretty much the conventional wisdom. But there is a contradiction in the conventional wisdom: Lisp will make you a better programmer, and yet you won't use it.

Why not? Programming languages are just tools, after all. If Lisp really does yield better programs, you should use it. And if it doesn't, then who needs it?

This is not just a theoretical question. Software is a very competitive business, prone to natural monopolies. A company that gets software written faster and better will, all other things being equal, put its competitors out of business. And when you're starting a startup, you feel this very keenly. Startups tend to be an all or nothing proposition. You either get rich, or you get nothing. In a startup, if you bet on the wrong technology, your competitors will crush you.

Robert and I both knew Lisp well, and we couldn't see any reason not to trust our instincts and go with Lisp. We knew that everyone else was writing their software in C++ or Perl. But we also knew that that didn't mean anything. If you chose technology that way, you'd be running Windows. When you choose technology, you have to ignore what other people are doing, and consider only what will work the best.

This is especially true in a startup. In a big company, you can do what all the other big companies are doing. But a startup can't do what all the other startups do. I don't think a lot of people realize this, even in startups.

The average big company grows at about ten percent a year. So if you're running a big company and you do everything the way the average big company does it, you can expect to do as well as the average big company-- that is, to grow about ten percent a year.

The same thing will happen if you're running a startup, of course. If you do everything the way the average startup does it, you should expect average performance. The problem here is, average performance means that you'll go out of business. The survival rate for startups is way less than fifty percent. So if you're running a startup, you had better be doing something odd. If not, you're in trouble.

Back in 1995, we knew something that I don't think our competitors understood, and few understand even now: when you're writing software that only has to run on your own servers, you can use any language you want. When you're writing desktop software, there's a strong bias toward writing applications in the same language as the operating system. Ten years ago, writing applications meant writing applications in C. But with Web-based software, especially when you have the source code of both the language and the operating system, you can use whatever language you want.

This new freedom is a double-edged sword, however. Now that you can use any language, you have to think about which one to use. Companies that try to pretend nothing has changed risk finding that their competitors do not.

If you can use any language, which do you use? We chose Lisp. For one thing, it was obvious that rapid development would be important in this market. We were all starting from scratch, so a company that could get new features done before its competitors would have a big advantage. We knew Lisp was a really good language for writing software quickly, and server-based applications magnify the effect of rapid development, because you can release software the minute it's done.

If other companies didn't want to use Lisp, so much the better. It might give us a technological edge, and we needed all the help we could get. When we started Viaweb, we had no experience in business. We didn't know anything about marketing, or hiring people, or raising money, or getting customers. Neither of us had ever even had what you would call a real job. The only thing we were good at was writing software. We hoped that would save us. Any advantage we could get in the software department, we would take.

So you could say that using Lisp was an experiment. Our hypothesis was that if we wrote our software in Lisp, we'd be able to get features done faster than our competitors, and also to do things in our software that they couldn't do. And because Lisp was so high-level, we wouldn't need a big development team, so our costs would be lower. If this were so, we could offer a better product for less money, and still make a profit. We would end up getting all the users, and our competitors would get none, and eventually go out of business. That was what we hoped would happen, anyway.

What were the results of this experiment? Somewhat surprisingly, it worked. We eventually had many competitors, on the order of twenty to thirty of them, but none of their software could compete with ours. We had a wysiwyg online store builder that ran on the server and yet felt like a desktop application. Our competitors had cgi scripts. And we were always far ahead of them in features. Sometimes, in desperation, competitors would try to introduce features that we didn't have. But with Lisp our development cycle was so fast that we could sometimes duplicate a new feature within a day or two of a competitor announcing it in a press release. By the time journalists covering the press release got round to calling us, we would have the new feature too.

It must have seemed to our competitors that we had some kind of secret weapon-- that we were decoding their Enigma traffic or something. In fact we did have a secret weapon, but it was simpler than they realized. No one was leaking news of their features to us. We were just able to develop software faster than anyone thought possible.

When I was about nine I happened to get hold of a copy of The Day of the Jackal, by Frederick Forsyth. The main character is an assassin who is hired to kill the president of France. The assassin has to get past the police to get up to an apartment that overlooks the president's route. He walks right by them, dressed up as an old man on crutches, and they never suspect him.

Our secret weapon was similar. We wrote our software in a weird AI language, with a bizarre syntax full of parentheses. For years it had annoyed me to hear Lisp described that way. But now it worked to our advantage. In business, there is nothing more valuable than a technical advantage your competitors don't understand. In business, as in war, surprise is worth as much as force.

And so, I'm a little embarrassed to say, I never said anything publicly about Lisp while we were working on Viaweb. We never mentioned it to the press, and if you searched for Lisp on our Web site, all you'd find were the titles of two books in my bio. This was no accident. A startup should give its competitors as little information as possible. If they didn't know what language our software was written in, or didn't care, I wanted to keep it that way.[2]

The people who understood our technology best were the customers. They didn't care what language Viaweb was written in either, but they noticed that it worked really well. It let them build great looking online stores literally in minutes. And so, by word of mouth mostly, we got more and more users. By the end of 1996 we had about 70 stores online. At the end of 1997 we had 500. Six months later, when Yahoo bought us, we had 1070 users. Today, as Yahoo Store, this software continues to dominate its market. It's one of the more profitable pieces of Yahoo, and the stores built with it are the foundation of Yahoo Shopping. I left Yahoo in 1999, so I don't know exactly how many users they have now, but the last I heard there were about 20,000.

The Blub Paradox

What's so great about Lisp? And if Lisp is so great, why doesn't everyone use it? These sound like rhetorical questions, but actually they have straightforward answers. Lisp is so great not because of some magic quality visible only to devotees, but because it is simply the most powerful language available. And the reason everyone doesn't use it is that programming languages are not merely technologies, but habits of mind as well, and nothing changes slower. Of course, both these answers need explaining.

I'll begin with a shockingly controversial statement: programming languages vary in power.

Few would dispute, at least, that high level languages are more powerful than machine language. Most programmers today would agree that you do not, ordinarily, want to program in machine language. Instead, you should program in a high-level language, and have a compiler translate it into machine language for you. This idea is even built into the hardware now: since the 1980s, instruction sets have been designed for compilers rather than human programmers.

Everyone knows it's a mistake to write your whole program by hand in machine language. What's less often understood is that there is a more general principle here: that if you have a choice of several languages, it is, all other things being equal, a mistake to program in anything but the most powerful one. [3]

There are many exceptions to this rule. If you're writing a program that has to work very closely with a program written in a certain language, it might be a good idea to write the new program in the same language. If you're writing a program that only has to do something very simple, like number crunching or bit manipulation, you may as well use a less abstract language, especially since it may be slightly faster. And if you're writing a short, throwaway program, you may be better off just using whatever language has the best library functions for the task. But in general, for application software, you want to be using the most powerful (reasonably efficient) language you can get, and using anything else is a mistake, of exactly the same kind, though possibly in a lesser degree, as programming in machine language.

You can see that machine language is very low level. But, at least as a kind of social convention, high-level languages are often all treated as equivalent. They're not. Technically the term "high-level language" doesn't mean anything very definite. There's no dividing line with machine languages on one side and all the high-level languages on the other. Languages fall along a continuum [4] of abstractness, from the most powerful all the way down to machine languages, which themselves vary in power.

Consider Cobol. Cobol is a high-level language, in the sense that it gets compiled into machine language. Would anyone seriously argue that Cobol is equivalent in power to, say, Python? It's probably closer to machine language than Python.

Or how about Perl 4? Between Perl 4 and Perl 5, lexical closures got added to the language. Most Perl hackers would agree that Perl 5 is more powerful than Perl 4. But once you've admitted that, you've admitted that one high level language can be more powerful than another. And it follows inexorably that, except in special cases, you ought to use the most powerful you can get.

This idea is rarely followed to its conclusion, though. After a certain age, programmers rarely switch languages voluntarily. Whatever language people happen to be used to, they tend to consider just good enough.

Programmers get very attached to their favorite languages, and I don't want to hurt anyone's feelings, so to explain this point I'm going to use a hypothetical language called Blub. Blub falls right in the middle of the abstractness continuum. It is not the most powerful language, but it is more powerful than Cobol or machine language.

And in fact, our hypothetical Blub programmer wouldn't use either of them. Of course he wouldn't program in machine language. That's what compilers are for. And as for Cobol, he doesn't know how anyone can get anything done with it. It doesn't even have x (Blub feature of your choice).

As long as our hypothetical Blub programmer is looking down the power continuum, he knows he's looking down. Languages less powerful than Blub are obviously less powerful, because they're missing some feature he's used to. But when our hypothetical Blub programmer looks in the other direction, up the power continuum, he doesn't realize he's looking up. What he sees are merely weird languages. He probably considers them about equivalent in power to Blub, but with all this other hairy stuff thrown in as well. Blub is good enough for him, because he thinks in Blub.

When we switch to the point of view of a programmer using any of the languages higher up the power continuum, however, we find that he in turn looks down upon Blub. How can you get anything done in Blub? It doesn't even have y.

By induction, the only programmers in a position to see all the differences in power between the various languages are those who understand the most powerful one. (This is probably what Eric Raymond meant about Lisp making you a better programmer.) You can't trust the opinions of the others, because of the Blub paradox: they're satisfied with whatever language they happen to use, because it dictates the way they think about programs.

I know this from my own experience, as a high school kid writing programs in Basic. That language didn't even support recursion. It's hard to imagine writing programs without using recursion, but I didn't miss it at the time. I thought in Basic. And I was a whiz at it. Master of all I surveyed.

The five languages that Eric Raymond recommends to hackers fall at various points on the power continuum. Where they fall relative to one another is a sensitive topic. What I will say is that I think Lisp is at the top. And to support this claim I'll tell you about one of the things I find missing when I look at the other four languages. How can you get anything done in them, I think, without macros? [5]

Many languages have something called a macro. But Lisp macros are unique. And believe it or not, what they do is related to the parentheses. The designers of Lisp didn't put all those parentheses in the language just to be different. To the Blub programmer, Lisp code looks weird. But those parentheses are there for a reason. They are the outward evidence of a fundamental difference between Lisp and other languages.

Lisp code is made out of Lisp data objects. And not in the trivial sense that the source files contain characters, and strings are one of the data types supported by the language. Lisp code, after it's read by the parser, is made of data structures that you can traverse.

If you understand how compilers work, what's really going on is not so much that Lisp has a strange syntax as that Lisp has no syntax. You write programs in the parse trees that get generated within the compiler when other languages are parsed. But these parse trees are fully accessible to your programs. You can write programs that manipulate them. In Lisp, these programs are called macros. They are programs that write programs.

Programs that write programs? When would you ever want to do that? Not very often, if you think in Cobol. All the time, if you think in Lisp. It would be convenient here if I could give an example of a powerful macro, and say there! how about that? But if I did, it would just look like gibberish to someone who didn't know Lisp; there isn't room here to explain everything you'd need to know to understand what it meant. In Ansi Common Lisp I tried to move things along as fast as I could, and even so I didn't get to macros until page 160.

But I think I can give a kind of argument that might be convincing. The source code of the Viaweb editor was probably about 20-25% macros. Macros are harder to write than ordinary Lisp functions, and it's considered to be bad style to use them when they're not necessary. So every macro in that code is there because it has to be. What that means is that at least 20-25% of the code in this program is doing things that you can't easily do in any other language. However skeptical the Blub programmer might be about my claims for the mysterious powers of Lisp, this ought to make him curious. We weren't writing this code for our own amusement. We were a tiny startup, programming as hard as we could in order to put technical barriers between us and our competitors.

A suspicious person might begin to wonder if there was some correlation here. A big chunk of our code was doing things that are very hard to do in other languages. The resulting software did things our competitors' software couldn't do. Maybe there was some kind of connection. I encourage you to follow that thread. There may be more to that old man hobbling along on his crutches than meets the eye.

Aikido for Startups

But I don't expect to convince anyone ( over 25) to go out and learn Lisp. The purpose of this article is not to change anyone's mind, but to reassure people already interested in using Lisp-- people who know that Lisp is a powerful language, but worry because it isn't widely used. In a competitive situation, that's an advantage. Lisp's power is multiplied by the fact that your competitors don't get it.

If you think of using Lisp in a startup, you shouldn't worry that it isn't widely understood. You should hope that it stays that way. And it's likely to. It's the nature of programming languages to make most people satisfied with whatever they currently use. Computer hardware changes so much faster than personal habits that programming practice is usually ten to twenty years behind the processor. At places like MIT they were writing programs in high-level languages in the early 1960s, but many companies continued to write code in machine language well into the 1980s. I bet a lot of people continued to write machine language until the processor, like a bartender eager to close up and go home, finally kicked them out by switching to a risc instruction set.

Ordinarily technology changes fast. But programming languages are different: programming languages are not just technology, but what programmers think in. They're half technology and half religion.[6] And so the median language, meaning whatever language the median programmer uses, moves as slow as an iceberg. Garbage collection, introduced by Lisp in about 1960, is now widely considered to be a good thing. Runtime typing, ditto, is growing in popularity. Lexical closures, introduced by Lisp in the early 1970s, are now, just barely, on the radar screen. Macros, introduced by Lisp in the mid 1960s, are still terra incognita.

Obviously, the median language has enormous momentum. I'm not proposing that you can fight this powerful force. What I'm proposing is exactly the opposite: that, like a practitioner of Aikido, you can use it against your opponents.

If you work for a big company, this may not be easy. You will have a hard time convincing the pointy-haired boss to let you build things in Lisp, when he has just read in the paper that some other language is poised, like Ada was twenty years ago, to take over the world. But if you work for a startup that doesn't have pointy-haired bosses yet, you can, like we did, turn the Blub paradox to your advantage: you can use technology that your competitors, glued immovably to the median language, will never be able to match.

If you ever do find yourself working for a startup, here's a handy tip for evaluating competitors. Read their job listings. Everything else on their site may be stock photos or the prose equivalent, but the job listings have to be specific about what they want, or they'll get the wrong candidates.

During the years we worked on Viaweb I read a lot of job descriptions. A new competitor seemed to emerge out of the woodwork every month or so. The first thing I would do, after checking to see if they had a live online demo, was look at their job listings. After a couple years of this I could tell which companies to worry about and which not to. The more of an IT flavor the job descriptions had, the less dangerous the company was. The safest kind were the ones that wanted Oracle experience. You never had to worry about those. You were also safe if they said they wanted C++ or Java developers. If they wanted Perl or Python programmers, that would be a bit frightening-- that's starting to sound like a company where the technical side, at least, is run by real hackers. If I had ever seen a job posting looking for Lisp hackers, I would have been really worried.



Notes

[1] Viaweb at first had two parts: the editor, written in Lisp, which people used to build their sites, and the ordering system, written in C, which handled orders. The first version was mostly Lisp, because the ordering system was small. Later we added two more modules, an image generator written in C, and a back-office manager written mostly in Perl.

In January 2003, Yahoo released a new version of the editor written in C++ and Perl. It's hard to say whether the program is no longer written in Lisp, though, because to translate this program into C++ they literally had to write a Lisp interpreter: the source files of all the page-generating templates are still, as far as I know, Lisp code. (See Greenspun's Tenth Rule.)

[2] Robert Morris says that I didn't need to be secretive, because even if our competitors had known we were using Lisp, they wouldn't have understood why: "If they were that smart they'd already be programming in Lisp."

[3] All languages are equally powerful in the sense of being Turing equivalent, but that's not the sense of the word programmers care about. (No one wants to program a Turing machine.) The kind of power programmers care about may not be formally definable, but one way to explain it would be to say that it refers to features you could only get in the less powerful language by writing an interpreter for the more powerful language in it. If language A has an operator for removing spaces from strings and language B doesn't, that probably doesn't make A more powerful, because you can probably write a subroutine to do it in B. But if A supports, say, recursion, and B doesn't, that's not likely to be something you can fix by writing library functions.

[4] Note to nerds: or possibly a lattice, narrowing toward the top; it's not the shape that matters here but the idea that there is at least a partial order.

[5] It is a bit misleading to treat macros as a separate feature. In practice their usefulness is greatly enhanced by other Lisp features like lexical closures and rest parameters.

[6] As a result, comparisons of programming languages either take the form of religious wars or undergraduate textbooks so determinedly neutral that they're really works of anthropology. People who value their peace, or want tenure, avoid the topic. But the question is only half a religious one; there is something there worth studying, especially if you want to design new languages.


SSer_余舜哲_哲服

Meteor:纯 javascript 快速开发 Web app 的框架--Wired


COMPANIES LIKE GOOGLE and Facebook have done an awful lot of work to make their internet apps feel just as snappy and responsive as the software that runs directly on your PC, letting us, say, follow constantly-updating online timelines or track our Lyft rides in real time.

The internet giants...


COMPANIES LIKE GOOGLE and Facebook have done an awful lot of work to make their internet apps feel just as snappy and responsive as the software that runs directly on your PC, letting us, say, follow constantly-updating online timelines or track our Lyft rides in real time.

The internet giants make this sort of thing look easy, but they have deep pockets and huge teams of engineers at their disposal. For the little guys, building similar interfaces can take months or even years, says Geoff Schmidt, the software developer behind the coding-tools maker, Meteor.

Schmidt would know. He helped build Asana, a task management application masterminded by Facebook co-founder Dustin Moskovitz and former Google engineer Justin Rosenstein. Moskovitz and Rosenstein knew that in order to be successful, Asana needed to be just as fast using a desktop app. People just wouldn’t wait around for the application to sync each change with the server. So before they even began coding the actual task management features, Schmidt and company spent months building their underlying framework. It was hard. “This is a challenge up there with building Unix or Windows,” Schmidt says.

Schmidt thinks it’s a waste of time for companies to build these same foundations again and again, which is why he founded Meteor, which builds an open source web programming framework that anyone can use to build complex, desktop-style applications in the browser. “The idea of Meteor is that everyone should have that stuff,” he says. “It shouldn’t take a couple years to get to the market.”

Meteor, which officially launches today, uses JavaScript, the standard programming language for writing applications for web browsers. Meteor apps can run on phones, tablets, desktops or anywhere else that a standard web browser can run. But unlike other JavaScript libraries like Angular or Backbone, Meteor lets coders build the server side pieces of their applications with JavaScript as well. That cuts back on the amount of coding developers need to do, and makes it easier to put the more of the complex pieces of the application on the client side, which is great for making applications more responsive — and making them work offline.

We noticed that everyone at Y Combinator was struggling to do what we were doing

Meteor is part of a growing number of tools aimed at making it easier to build real-time applications, such as the cloud database Firebase, which was just acquired by Google, and other frameworks such asDerby, co-created by former Google engineer Nate Smith, and Yahoo’sMojito. These projects all play into a larger shift towards running applications locally, and syncing data with the cloud, as opposed to having the entire application run on a web server somewhere.

Schmidt didn’t set out to create a programming framework when he left Asana. He and his co-founders Matt DeBergalis, who co-founded the fundraising service ActBlue, and Nick Martin, who co-founded music streaming company MixApp, originally planned to make a travel recommendation app. The trio was accepted into the prestigious startup incubator Y Combinator, and it was there that they built the original version of Meteor to power their own product. “We noticed that everyone at Y Combinator was struggling to do what we were doing already because we had experience from these companies like Asana,” Schmidt says. “So we realized that our framework for building this stuff was way more valuable than our travel guide.”

The team released a developer preview of Meteor in 2012, and within hours of being posted to Hacker News, a popular online hangout for developers, the framework was downloaded several thousand times. But getting people to use a free software platform is just the first step for a venture-funded company like Meteor. It also needs to find a way to make money. Schmidt says the company plans to offer a cloud hosting service specifically tailored for Meteor apps. The company already offers free, experimental hosting for Meteor apps, but Schmidt says it’s not suitable for live, business-grade applications.

In the meantime, Meteor has maintained some of that early momentum, according to RedMonk analyst Donnie Berkholz. “Meteor has grown in popularity over the last couple of years as backend JavaScript continues to gain interest as an alternative to other languages,” Berkholz says. Based on the data he’s gathered from Google Trends and developer-centric sites such as Hacker News and StackOverflow, Meteor is by far the most popular of the “full-stack” frameworks, which seek to handle both the browser and server sides.

Meteor still has a way to go in terms of replacing the old ways of building apps, but it’s still early for Meteor and even though it’s just now emerging from beta, many companies are already building applications with it. For example, Lookback, a startup co-founded by former Spotify engineer Jonatan Littke that makes a platform that helps developers capture videos of mobile applications. “Meteor affects about 75 percent of our code,” Littke says. And although Meteor was fairly immature when Lookback started using it it two years ago, Littke says, the framework has come a long way.

Even Schmidt is surprised by this kind of early traction. “I think the fact that people have gotten so far with Meteor despite it being pre-1.0 speaks to how great the need is for something like that,” he says.



Reading Marks

大数据时代 I:大数据时代的思维变革

今天正好看完《大数据时代》的第一部分,书中所说的“大数据时代的思维变革”对我来说可能有三个方面:

大数据所使用的样本是由于太过庞大,书中认为这样的庞大就等同于是“样本=总体”。这样的观点其实也成立,因为大数据所使用的样本值确实是传统统计学无法比拟的,但是如果就说样本值很大的样本等同于总体,这样的说法至少是欠妥的。作者以为地在强调样本值如何大,以至于太大到等于总体,但至少他忽略了一点:总体值会更大。这一点上,我是有疑问的。

精确性将被忽略,取而代之的是混乱性。这一点我是同意的,由于大数据的特点,我们无法得到精确解,或者说很难得到。而且我们也不需要精确解。

因果关系将被忽略,相关关系才是目的...

今天正好看完《大数据时代》的第一部分,书中所说的“大数据时代的思维变革”对我来说可能有三个方面:

大数据所使用的样本是由于太过庞大,书中认为这样的庞大就等同于是“样本=总体”。这样的观点其实也成立,因为大数据所使用的样本值确实是传统统计学无法比拟的,但是如果就说样本值很大的样本等同于总体,这样的说法至少是欠妥的。作者以为地在强调样本值如何大,以至于太大到等于总体,但至少他忽略了一点:总体值会更大。这一点上,我是有疑问的。

精确性将被忽略,取而代之的是混乱性。这一点我是同意的,由于大数据的特点,我们无法得到精确解,或者说很难得到。而且我们也不需要精确解。

因果关系将被忽略,相关关系才是目的。最开始我并不理解这句话是什么意思,但在仔细阅读后顿时茅塞顿开。因为大数据得到的是一个可能的结果,而造成这个结果的原因可能是多方面的,也就是说有很多可能的原因和这样的结果有关系。如果过分痴迷于因果关系,那么事情可能会变得滑稽。但是我在想是不是可以将造成这样结果的各种原因排成一个概率分布表……或许我还没有完全适应大数据的思维吧

学渣表示这样科普性质的书本来应该得心应手,毫无压力的,可是学渣怎么能和学霸相提并论。在很多基础知识,比如像概率、统计这些学科在痛苦地考试完以后就恭敬地还给了老师。

而如今自己所做的这一块儿也是与之紧紧相关,唉~~

lightning strike

Computer Science 计算机科学

《[Operating.System.Concepts(9th,2012.12)].Abraham.Silberschatz》

网络network fundementals### network classfication LAN: local area network MAN: metropolitan area network WAN: wide area network ### protocal ### network connecting repeater : which is little more than a device that simply passes signals back...

《[Operating.System.Concepts(9th,2012.12)].Abraham.Silberschatz》

网络network fundementals### network classfication LAN: local area network MAN: metropolitan area network WAN: wide area network ### protocal ### network connecting repeater : which is little more than a device that simply passes signals back and forth between the two original buses (usually with some form of amplification) without considering the meaning of the signals bridge : similiar to repeater but with the albility to determine wheather certain packaged need to be transfered to the other side of the bridge. switch : a switch is essentially a bridge with more than two buses connected to it. router : The connection between networks to form an internet is handled by devices known as routers, Note that the task of a router is different from that of repeaters, bridges, and switches in that routers provide links between networks while allowing each network to maintain its unique internal characteristics. ### Methods of Process Communication client/server model p2p(peer to peer) model ### Distributed Systems #### cluster computing: Cluster computing describes a distributed system in which many independent computers work closely together to provide computation or services comparable to a much larger machine. ##### advantages high-availability load-balancing Grid computing: Grid computing refers to distributed systems that are more loosely coupled than clusters but that still work together to accomplish large tasks. The Internet### Internet Architecture #### terms ISP: Internet Service Providers (ISPs). VoIP: (Voice over Internet Protocol) ### Internet Applications #### email string after '@' of email address is the domain name. ### 4 Layers of Internet Application Layer: responsible for issue message with destination (ip address + port number) attached to it Transport Layer: recieve message from application layer and divide it into small package segement. Assemble segments on the destination end.Send it to Application Layer via computer port number Internet Layer: maintain a rout information table, link layer will use it to direct packages. Link Layer: actually transport the packages. ### TCP vs UDP TCP: 1. relible: it will start conection first to acknowledge destination end what information will be send before actually send the message. and package arrival sequence order is assured. 2. flow control: it able to ajust trasmission rate base on the conditions of network. UDP: 1. stremlined, real-timed: because it doesn't guarantee information integrity and sometimes even destination, it will be send right away.So it's more real-timed
大隐隐鱼市

An Overview of Computer Science

这本书一开始就提到“抽象工具”——技术是一层一层的,上层的构建者不必了解下层的工作原理,只需要把它作为一个“抽象工具”使用就行了。就比如一个司机不需要清楚汽车制作原理,汽车制造者也不需要明白马达是如何工作的——在他们各自的范围内,只需要知道能用就行了。

而对于计算机,我最感兴趣的一点是如何通过物理手段(电子电路,或同样神奇的机械形式)来计算加减法。这一点在计算机科学的最底端,也许已不属于学科范畴,所以在国内教科书上从未提过,甚至在这本本来让我兴奋的国外教科书上也模模糊糊,告诉有这么一种设备(齿轮,继电器,光学设备),能够用来实现与或门。

我想知道这些设备是如何工作,把1+1=10,11-1=10算...

这本书一开始就提到“抽象工具”——技术是一层一层的,上层的构建者不必了解下层的工作原理,只需要把它作为一个“抽象工具”使用就行了。就比如一个司机不需要清楚汽车制作原理,汽车制造者也不需要明白马达是如何工作的——在他们各自的范围内,只需要知道能用就行了。

而对于计算机,我最感兴趣的一点是如何通过物理手段(电子电路,或同样神奇的机械形式)来计算加减法。这一点在计算机科学的最底端,也许已不属于学科范畴,所以在国内教科书上从未提过,甚至在这本本来让我兴奋的国外教科书上也模模糊糊,告诉有这么一种设备(齿轮,继电器,光学设备),能够用来实现与或门。

我想知道这些设备是如何工作,把1+1=10,11-1=10算出来的?

同样感兴趣的是,
底层设备是如何把一个数从一个存储位置移到另一个存储位置?
这种每一步都按照规律来实现的机器,如何能产生随机数?

Alan.T

Adobe Edge Reflow的开发过程视觉化,github完成,so beautiful!

Adobe Edge Reflow的开发过程视觉化,github完成,so beautiful!

电灯网 www.tdide.com

MIT 计算机科学和人工智能实验室展示对未来个人航空运输的设想

Studio2109

通俗数学名著译丛:数学游戏与欣赏

快盘下载:   http://www.kuaipan.cn/file/id_19142669245537.html

全书分14章,内容包括:数字游戏与几何游戏、多面体、棋盘上的游戏、魔方、地图染色问题、一笔画问题以及计算神童小传等。


快盘下载:   http://www.kuaipan.cn/file/id_19142669245537.html

全书分14章,内容包括:数字游戏与几何游戏、多面体、棋盘上的游戏、魔方、地图染色问题、一笔画问题以及计算神童小传等。

Kim Leo

社区&高校&黑客精神

  1. Access to computers—and anything which might teach you something about the way the world works—should be unlimited and total. Always yield to the Hands-On Imperative!

  2. All information...

  1. Access to computers—and anything which might teach you something about the way the world works—should be unlimited and total. Always yield to the Hands-On Imperative!

  2. All information should be free

  3. Mistrust authority — promote decentralization

  4. Hackers should be judged by their hacking, not criteria such as degrees, age, race, sex, or position

  5. You can create art and beauty on a computer

  6. Computers can change your life for the better

Sharing,Hands-on Imperative,Community & Collaboration

师傅说,他高中的时候也被网络小说侵蚀过,也曾迷恋过现在的那群黑客。

但他们跟《Hackers》和《Hackers & Painters》里面描写的完全不一样。高中的时候,呃,或者是初中的时候,就已经对这群人厌倦了。

但是,真的想回到那个时代,TMRC作为真正的黑客聚集地的时代,John McCarthy还在创作Lisp论文的时代,Homebrew俱乐部聚集着一群大神的时代。

现在的高校已经完全没有当时那个氛围了,或者说,至少国内的高校,甚至是根本就没有过那种氛围。一步步沦为高门槛培训机构的中国高校们在今天能够再度出现这种组织的几率小的很(三叶草的孩子们可能会笑了),胡中华哥哥也直接劝告我说,有想法的话自己搞一个民间的吧,指望学校和学生会是不成的。

昨晚又一不小心分析了高校和社区,如果说我明白了什么,我周围的人明白了什么,那又能怎么样?很想去用心影响一下现在这情况,可是,这貌似不只是整个教育体制的问题了:社会有需求、学生也乐意、学校何乐而不为呢?但如果说在高校待了四年出来只为了混张证书然后好找工作,那么为毛不去外面的专业培训机构呢?从蓝翔那么伟大的培训学校出来技术不一定比我们四年之后差,还免了多少费用!省了多少时间!?

唉,受不了。我在想是究竟该好好做好我的然后不理其他人呢还是该好好的宣扬下这个思想呢?很多人来了就来了,然后就走了,没有留下些什么。国外高校的科研都进行的轰轰烈烈的,国内却没有几个能够拿得出来用于生产的!社区里集结了多少专业的人,高校的多少人却又对他们不了解!那些依靠谭浩强先生来进行计算机科学启蒙的学校是不是该好好反省了?!谭浩强先生是不是也该反省了?

现在没有黑客了,但黑客精神尚在,远离了那些阶级感和压迫感强烈的高校,进入了自由和专业的社区。

嗯,高校是青楼,社区是妓院。

LOFTER

让兴趣,更有趣

简单随性的记录
丰富多彩的内容
让生活更加充实

下载移动端
关注最新消息