rickmode

Sounds like Erlang is close to Dr Kay's notion of OOP - though my Erlang-fu is not strong enough to know if it has polymorphism.

I'll totally jump back on to the Scala bandwagon once it breaks free of the JVM.

I'd love for Clojure to make the same jump to LLVM however it relies far more on the host platform's libraries (the Java/C# libraries).

Anyone know the typical internal temperature?

Killing the Buddha has a second deeper meaning beyond Buddha is not sacred: to detach from all past teachers / buddhas.

Buddhism (at least the Zen Buddhism tradition I am learning) teaches one to detach from all things. This is part of opening the mind and experiencing things as they are and not through one's misconceptions.

So eventually a student masters this and all other teachings by his masters and all past buddhas. At this point the student must detach even from these buddhas.

So if you meet the Buddha? Strike him down! You have no need of him anymore.

Sam Harris is one of these "new atheists" that take a hard anti-theistic stance. Religions tend to have a fundamentalist core that is intolerant of any belief that does not fit their dogma. The idea is that even moderates and other more casual observers of a religion tacitly support that religions fundamentalist core.

It's a sound argument but there are two main barriers of acceptance. First the anti-theists do not acknowledge that religious beliefs (and indeed many unfounded beliefs) are rational. Religious people are not crazy or uninformed. This is a separate issue from having an inconsistent and / or scientifically unfounded belief system.

Second, the anti-theists do not provide much of an alternative. Dawkins seems to say, you guys are obviously nuts, so you must see that you simply have to adopt my world view. It's off putting.

Anyway I've gone from bemused to agnostic to naturalist (a way of saying "atheist" without mentioning theism). I quite enjoy reading these authors ... I just don't see how they'll affect a change.

This is similar to "geeks do not respect suits". Suits are meant to signal credibility. But since geeks value ability much higher than style, the suit, being worn by "less intelligent" salespeople and managers, became a negative signal.

Similarly, perhaps online the use of American punctuation is becoming a negative signal, showing pedantic training as a "professional writer" rather than a true ability to convey ideas.

The root problem is a lack of competition.

Ideas like government forcing service competition over the physical lines along easements granted by the a government should be explored.

Spending more on AWS to increase reliability isn't necessarily a benefit to Amazon. The increased costs can them less competative.

Has any tech company used fully disclosed salaries as described in Mavrick [1][2]? It's an intriguing idea.

Mavrick describes how all salaries were publicly posted. People see exactly where they are in relation to others. Of course this created tension at first, but eventually things settled. The magic happens during hiring. An open position's salary is also public, and everyone on an interview panel naturally ranks candidates versus current employees. Is the candidate better than Joe? She better be because she'll be making more than Joe.

Has anyone heard of a tech company doing something like this?

[1] http://en.wikipedia.org/wiki/Maverick_(book)

[2] http://www.amazon.com/Maverick-Success-Behind-Unusual-Workpl...

There's an unstated assumption that excellence equals pro in this article.

I'd say excellence is a necessary precursor to going pro, but is itself not sufficent. That extra push is some magic combination of genetics, upbringing and opportunity (nature and nurture coming together just so) - all along with the drive and experience to become excellent.

Here's yet another stab at explaining closures using C. Hopefully this is clear.

The confusion about closures happens because it doesn't exist in other languages. (There isn't a way to express it.)

Let's look at a simple C function that uses a global variable:

  int a = 1;

  int a_plus_2() {
    return 2 + a;
  }

This always returns 2 more than "a". Initially it will return 3. If "a" is set to 5 at some point in the future, "a_plus_2" will then return 7. Simple. No closure here.

In Lisp, "a" would be called a "dynamic variable" because it changing its value affects all code that uses "a" over time, including usage within other scopes; "a" has a dynamic binding. But Lisp also has static binding which means the value of the variable is captured each time a scope is created and remains static over time within that scope.

Imagine a variation of C where variable make this distinction explicit by prefixing with with <dynamic> and <static>. <dynamic> would be the default and in fact is how the real C behaves. <static> now means Lisp notion of static binding (forget C's notion of static, which is totally different). Let's use it.

  <static> int b = 1;
  
  int b_plus_2() {
    return 2 + b;
  }

So here "b" is marked as static. When "b_plus_2" is defined at compile time, the current value of "b" is captured - statically bound - to its current value of 1. So "b_plus_2" will always return 3 _even if the global variable "b" is later modified.

  b = 5; /* modifying b */
  
  int new_b_plus_2 {
    return 2 + b;
  }

Calling "new_b_plus_2" return 7. No surprise here. The twist is that the original "b_plus_2" still returns 3. The value of "b" is captured in a closure. Each new scope encloses the current value of "b", binding its current value statically (unchanging) within that scope. Closures become interesting when the block in question is a function body.

So, yeah - it's a simple concept in the end. It's tricky because it doesn't exist many other languages. It provides a way to encapsulate state analogous to an object in OO languages [1].

The concept is more useful in Lisp with its higher order functions - functions that define other functions. This is very fluid in Lisp, while Python uses its lambda form for anonymous functions, Ruby has blocks and lambdas and...[2], and Java gets close with inner classes.

I hope this helps.

[1] "Objects are a poor man's closure" and "Closures are a poor man's object" http://stackoverflow.com/questions/2497801/closures-are-poor...

[2] I'm don't do Ruby - but's here's a ton of stuff on closures in Ruby: http://innig.net/software/ruby/closures-in-ruby.rb

Having beat my head against Common Lisp, then spent a non-trivial amount of time working in Clojure, I totally agree with his premise.

Learning Lisp requires real, significant use of the language. Eventually you begin to think in the language and that's when profiency begins.

Merely reading about the language is not enough.

I'm sure this applies to learning any new programming language paradigm (as in procedural like C, OO like C++, Java and C#, and functional like CL, Clojure and Erlang) or any natural language for that matter.

[Edit: adding following sidenote.] Reading "On Lisp" was a big part of why I recently bought the $139 Kindle. Reading the "On Lisp" PDF isn't bad with the divice in landscape orientation.

Not to mention that in an accident, the available energy with liquid fuel is a fraction of the total. Only the gaseous portion will expode. With a battery, the entire stored energy is available should it arc.

Consider transportation of oil and gas (petrol / auto gasoline) along with gas refining versus electricity generation and transmission.

In any case full electric cars allow centralized power generation, in turn allowing more opportunities for clean power.

Correct me if I'm wrong but it seems you mean "statically typed" instead of "strongly typed".

PHP is weakly typed. Common Lisp, Clojure, Haskell and OCaml are strongly typed.

PHP is dynamically typed, Haskell and OCaml are statically typed.

That said I would like to learn more about these statically typed functional languages.

Direct messaging is optional; profiles have an email field.

Collaboration.

It's really that simple. We live in cities and work in groups and/or at companies because the benefits of collaboration and casual exchanges of ideas outweigh the detractions.

Ya - it's link bait. Saying "Lift is the most powerful, most secure web framework available today for Scala and Java" might be more accurate, but would be a yawn.

The Microsoft versus Facebook comparison is not apt.

Facebook takes something like a 50% cut of the money made by Zynga with their Facebook app.

Microsoft did not create a walled garden so did not have the opportunity to charge for running on their platform.

Software as a service and (to a lesser extent) the various app stores are different. The incentives are not the same.

Immutability being possible is not the same as mutability being impossible (or the rare exception that is dealt with in a special manner).

His point is that since in Scala mutability is possible (and indeed is idiomatic) you run into concurrency concerns.

A real-life "Center of the Earth"!

http://en.wikipedia.org/wiki/A_Journey_to_the_Center_of_the_...

It's not that governments want people scared, rather there's no incentive to avoid scaring the public. And so officials go ahead with their politically expedient security theater. The officials get the benefit of appearing to "do something" while the resulting inconvenience and "scare" never wash back on them.

What ever happened to the idea that a company should avoid purchasing and managing real estate and instead focus on its core competency?

Perhaps due to Bayesian Magic Pixie Dust?

I agree. The article's headlines has a distinct anti-intellectual flair, and yet the article itself points out human flaws in research rather than a fundamental flaw in the scientific method.

There more to life than money. It's thought provoking and inspiring to see someone putting this into action.

The following quote from the Weekly World News link is suspect. The most environmentally sound way for humans to live is in dense urban cities. Leave the countryside alone.

Quote:

“People’s reasons for living small vary a lot, but there seems to be a common thread of sustainability,” Shafer said. “A lot of people don’t want to use many more resources or put out more emissions than they have to.”

Similar: Hacker News thread on engadget.com article: http://news.ycombinator.com/item?id=1951662

So is the magic here, over Clojure, that Kawa uses less ephemeral garbage, or is it doing Dalvic bytecode generation, or is it the size of the dependent runtime libraries, or ...?

Common Lisp may be worth another look. I've been loving Clojure for the past few months but this looks promising.

Quicklisp looks especially nice, hopefully solving the packaging and dependency situation.