lfborjas

I hear you, friend, it's like it's ok for companies to hire us , men, as a "risky bet", I'm not the best engineer but thankfully my employers have all "seen" something in me to have enough faith to give me the chance to learn the job and then become better. Women seem to not get the same kind of good faith: my partner has two engineering degrees and she's by far a better engineer than I (skill-and-attitude-wise), and yet most companies reject her because of her "lack of experience". I know that that is a problem that befalls recent graduates all over the globe, but the fact that I garnered faith from employers more than once and she hasn't, not a single time, is -IMO- telling of a lack of balance.

Happens to me too, with a slightly modified latin-american keyboard layout

Interesting, does this essay convey to you that the manual labourer is doomed and Russell's being a pessimist? I got quite the contrary from it (advocating some sort of socialist state), on par with wilde's [the soul of man under socialism](http://www.marxists.org/reference/archive/wilde-oscar/soul-m...)

Or are you referring to other writings by Russell? I have to confess that besides this essay and "proposed roads to freedom" I've read little of his own stances.

Articles like this remind me of Bertrand Russell's [In praise of idleness](http://www.zpub.com/notes/idle.html):

"I want to say, in all seriousness, that a great deal of harm is being done in the modern world by belief in the virtuousness of work, and that the road to happiness and prosperity lies in an organized diminution of work."

nice twitter integration!

Cool, I'm currently using vim and the fugitive plugin offers a similar functionality: http://sontek.net/turning-vim-into-a-modern-python-ide#integ...

Something like wsgi/rack/ring would be cool (actually, ring could be your inspiration: https://github.com/mmcgrana/ring )

Check out rubinius, the bytecode seems to perform considerably faster than interpreted source: http://rubini.us/

I was wrong, ruby 1.9 has callcc back since 2009, you have to `require 'continuation'` now, though.

Cool, I was wondering if it could be implemented in ruby; it's a shame that callcc isn't present anymore in ruby 1.9

Sounds nice, but keep in mind that the git history is modifiable: http://www-cs-students.stanford.edu/~blynn/gitmagic/ch05.htm...

tl;dr : you can either keep struggling with the unknown, keep making science, keep searching for the truth to fill the gaps and tame the uncertainty or just choose to believe in some sort of intelligent transcendental designer and sleep happy at night thinking you're special.

I, for one, still choose science. I'd rather have uncertainty till the day I die -knowing that I did my best to make it less so- than giving in to the God of The Gaps.

Natural language is ambiguous, sorry for being misleading; I meant "novel" in the sense of "fresh, not seen before", referring to the more pragmatic paradigm described in the paper.

This is very true, I came to realize this very thing by watching the SICP lectures: the important thing is to understand programming as a problem solving method and computers as tools; the languages that carry this method and express it to computers become secondary in learning.

I tried to use this approach last semester in a course I taught and found out that it isn't easy to get used to an SCM the first time, so regular and good students end up doing huge and late commits, moreover, one of the worse performing students learnt -ironically- to alter the git log to seem more diligent than he actually was (lots of commits and files changed), and with stuff like git rebase, a more clever cheater could never actually get caught. So an approach strongly reliant on the SCM kinda weakens in practice(though, as you point out, it could be used as a _secondary indicator_ or guarantee of work). And in theory, as other commenters say, taken to extremes, one ends up evaluating secondary things and overseeing essential things like the ability to rationally defend the code and explain one's approach.

Nevertheless, it is feasible to set up stuff like post-commit hooks (I actually used 'em to monitor the turn ins to an exam) to maybe submit the code to an automated plagiarism detector like [moss](http://theory.stanford.edu/~aiken/moss/), that would be cool, maybe I'll try that out next semester.

They do provide private repos, that's seems to be the idea of offering this alternative to students, instead of expecting them to buy personal plans.

I used this last year, they gave me an org and private repos for the student projects without any fuzz, it was really cool to teach a course with that and we open sourced the projects afterwards (it's in spanish, though) : https://github.com/progra4

I'll definitely use it again, the students learned a lot about project management and distributed version control systems, which is something that isn't being taught as it should, at least not where I went to college.

Interesting, and yes, I am a witness of how fast proper java is; and in extreme performance cases, I guess I'd turn to java before C++ ; maybe the f# also benefits from optimizations (like tail-call optimization) and the underlying VM? (though I don't know how performant the CLR is)

now we're talking, this is a really good response! I almost agree with all of your points, except for the performance, and only in thoroughness: a benchmark will be nice.

And for clarity: the other ones aren't function definitions, they also build a new list, like your example. The examples are meant to be run in a REPL and that's why they don't send to stdout, although it will be just another function application in most cases (but your example works in beanshell, the stand-alone java quasi-REPL, so we're ok). I think all of them can be considered a full-program in those languages: as a stand-alone chunk of code that can be compiled/interpreted and will produce an executable output, that is. And, yes, the autoboxing was the only reason I chose generics, but I tried for it to be concise, given my limited knowledge of java; the max-verbose mode would have used a Runnable or something evil to simulate a higher order function.

hehe, clever! although we are building a new list in the other languages, we're never using it, so this is just as good in the immediate context.

That's true, and although I don't hate java or the technologies it has spawned (the JVM is a neat one, just look at it's finest offspring, clojure), trying to teach basic programming with it just seems bad. Maybe for an intermediate course on OOP, it does a good job if one wants to teach C++ or C afterwards; but as a first language, I have against it that it forces to spend too much time in syntax and inexplicable cruft (unless you're willing to explain the concept of class and static method the first day), and magic is never good for teaching if it's never explained. Just look at the classic SICP lectures: the syntax is done with in half an hour, then recursion and then higher order functions, and it doesn't feel like a brainfuck at all!

This is admittedly better, note, tough, that I was trying to do it in the mindset of the other languages included (just having one explicit list and filtering out instead of in); however, as it was stated before, it's never good to try to write code in the idiomatic style of other languages if the end result is something not idiomatic at all, it's like trying to play the bach chaconne for violin in a tuba or <put better analogy here> : it can be done but it's just forcing it.

pretty cool!

The other ones are meant to be run in a REPL, but java doesn't have one (lest you count beanshell, which ships with a really old version of java, one before generics) so I had to print it explicitly

Yep, in an environment like that the serious architecture java enforces is a good thing, especially with heterogenous groups of not-necessarily-hackers-but-good-coders.

It actually happened to me, my first programming language in college was java and it made programming look really hard. I actually hated programming until the very end of my third year, when I learnt python in my first job. Ironically, later, when taking a compilers course -when I already knew how to program- I was quite happy with java+flex+cup, it felt powerful and fast.

Oh, right! even? is already a function, d'oh!

this looks really nice, gotta learn me some haskell

Oh, this is just a tongue-in-cheek joke; java has really cool stuff, I actually code in java every morning and I really like the JVM and the JIT, without it, clojure, jruby and jython wouldn't exist, and jruby is way cooler than Cruby!

You're right, we can't be saying that a language sucks because it doesn't look cool in some coding styles. Is like trying to do fancy OOP in pure scheme or common lisp without the CLOS!

I don't do C#, but feel free to fork the gist and add it :)