vmind

It was theorised/known the Earth was round a lot earlier than Galileo: http://en.wikipedia.org/wiki/Spherical_Earth

Making the type system pluggable and a separate pass also means you can do cool things like interfacing your type system with your database [1]. And the Heterogeneous and Value types mean you can be very flexible and precise with your requirements while also coding in a mostly idiomatic Clojure way. (Though things are obviously still raw or unimplemented, the base is looking good and shaping up quickly.)

[1]: https://gist.github.com/c-spencer/6569571 (just a PoC)

You can define functions inside the database and then use them inside a transaction [1] so that you can get atomic update, if that's the question. You can also mark attributes as noHistory [2] if you don't care about the past state.

[1] http://docs.datomic.com/database-functions.html

[2] http://docs.datomic.com/schema.html

V8?

If you're going to use etymology as a reason to censor words, then I hope you never use the word 'bad'.

Slight offtopic: if anyone installed Nightly to have a look at this, and the UI is scaled strangely (might just be a windows thing related to HiDPI) you can set the devPixelsPerPx in about:config to 1.0 to get the scaling back to normal.

There's some progress being made on static typing in Clojure, too: https://github.com/clojure/core.typed

Still fairly early days on that though (missing protocols and rest parameters are the big issues I think)

The risk element, to me, makes EVE a much more fun game than many others when it comes to combat. The pay off in fun, excitement and stories to be told is so much greater when there was a risk involved.

Not sure what the objection to the keep function is, other than maybe the performance optimisations that chunked sequences allow. Taking away the chunked consideration gives something like:

    (let [x (f (first s))]
      (if (nil? x)
        (keep f (rest s))
        (cons x (keep f (rest s)))))

Which looks almost identical (with differences, as you seem to be giving filter rather than keep, which are different functions). The library function COULD be defined like this, it just wouldn't be as fast.

Nice approach, though it would seem to not be needed with Backbone 0.9.9, with the new 'update: true' option for fetching collections. (If you have a central data model for your application that is.)

(function draw(i){ return function () { document.write(i%30==0 ? '<br>' : Math.random()>0.5?'\u2571':'\u2572'); setTimeout(draw(i+1), 100) } }(1)())

A throttled run-forever version.

edit, slightly neater:

(function draw(i){ setTimeout(function (){ document.write(i%30==0 ? '<br>' : Math.random()>0.5 ? '\u2571':'\u2572'); draw(i+1); }, 100) }(1))

As long as you gain some experience in addition to your CS degree there are plenty of programming jobs around, though they are largely concentrated in London and Cambridge (Quant jobs in London, other more general programming in both locations, quite a bit of hardware around Cambridge too). The larger employers often recruit directly through University career fairs.

There's still a high demand for good developers in the UK, main issue in recruitment is sifting through the many applicants for positions who, even with experience, show no aptitude for the job.

I think that the argument generally goes that if the grammar is unambiguous then it's also easier to read (once you're accustomed to the syntax) because there can only be one interpretation and so you don't need to keep knowledge of what's a type and what's a value in your head to understand a line.

<offtopic> The correct spelling is 'irk'. </offtopic>

Well the example given is bugged, as if you make updates at 0 and 50, then it never fires the function at 100 for the change that occurred at 50. If I didn't want to rely on the whole framework, I'd copy and paste the tested implementation (and dependencies) in underscore.

Not that it's bad to know how to do it yourself, but I'd make sure my implementation was sound before sharing it as advice.

Yep, have used Hetzner servers too for some things and would use again, but for our customers being 90% in the US, and OVH offer a canadian location (and we may need some EU servers in the future).

I much prefer the middle ground of dedicated servers over the hassle of colocation and hardware management. (16GB RAM quad core with 2TB raid1 from OVH for £65 a month are a good affordable level, and very quick and easy to spin up new ones).

The example at http://imperavi.com/kube/demo/ is responsive, I'm not sure why their documentation isn't too.

Sounds like a good plan, SRS is definitely under-used for how powerful it can be as a memory tool, so it's good to see some more development in the space.

So, is this based around a Spaced Repetition system, or just some standardly spaced reminders? Would this be an alternative to Anki? Or is it just meant to solidify some small set of facts using reminders?

I don't see any mention of 'shitty', just over-engineering. For the record, I would use Vagrant if I had the need, and probably will in the future (this kind of caveat seems sadly required otherwise I would be painted as somehow opposed to a software project), that said..

Fitting in with the community style/idioms is rather important for a project, especially as it grows in size. When it's a huge codebase, used by many, in many different use-cases, people being able to look into the code to help sort out their own issues is hugely valuable. If someone who knows your programming language and knows your problem domain gets scared off by how your software is architectured/functions, that's not a particularly good sign.

But maybe the problem is huge, and all that complexity is needed, and will pay-off now they're looking to have multiple VM providers. But criticism of complexity shouldn't just be tossed aside as 'trashing'.

Rather than just an echo chamber of praise? It's good to see multiple points of view and criticism. There's always a place for improvement, and he's right, the codebase doesn't seem particularly ruby-ish.

There's also Kicktraq, which has a longer history and a rough trend to total. http://www.kicktraq.com/projects/ibdknox/light-table/

(webnumbr looks really nice for watching random pages that don't have dedicated trackers, though)

Cool, but I think my favourite 4k demo is still Elevated, which is much less obviously procedural. (http://www.youtube.com/watch?v=_YWMGuh15nE)

At least for Chrome, all optimisation is disabled in functions containing a try/catch. It's probably similar for the other browsers. Try/catch combined with some of the more sneaky semantics of javascript is rather a nightmare to optimise, I can imagine. Even a simple looking value can actually be a huge function chain (via defineProperty, defineGetter, or valueOf).

Fairly neat, bug report: Tracing a route to Japan that goes through the US ends up with a line just going off to the left: http://i.imgur.com/TXlE0.png

This is only part of the why. The other part is the valueOf function which you can specify in order to control what the value of an object is when coerced.

So for instance:

    var arr1 = [1,2,3], arr2 = [1,2,3,4];
    console.log(arr1 + arr2); // "1,2,31,2,3,4"
    arr1.valueOf = function () { return this.length; };
    arr2.valueOf = arr1.valueOf;
    console.log(arr1 + arr2); // 7

Showdown's a great library, I use it with some tweaks on http://notepag.es/ for doing markdown/latex math editing. Given it is just a chain of regexes though, modifying it to add new functionality can be a little hairy.

The sunspider tests are also fairly dubious as a performance indicator because of their very short execution time, the Chrome team posted a modification which ran it 50 times to get a better idea of steady-state performance (http://blog.chromium.org/2011/05/updating-javascript-benchma...). Sunspider does act as a fairly good indicator of any latency overhead the JIT adds, though.

In terms of real-world scripting, almost any script I've benchmarked has always been ~1.5-2 times faster in Chrome than firefox (versions 4 through 6), except when bound by API calls (last I checked Firefox was on-par or better when dealing with TypedArrays). It looks like TypeInference might be a really big win though.

A (niche) use may be to compile for NativeClient, to provide better responsiveness if you're doing large templated live-previews (though admittedly this is more sensible with formatting like markdown rather than templating).