mullr

Because in a statically typed language, you want the type of a symbol to represent the set of values it can be bound to. We often have the set {something that passes a truth test, something that fails a truth test} in our programs, so a boolean type is a nice way to represent it.

Now, this is not the same thing defining what exactly the truth test is. It's perfectly reasonable and arguably a good design to have both a narrow boolean type and a wide definition of truthiness.

A good point. Or merging in changes from master, if you like it that way.

Because that would be continuous builds on unintegrated-branches.

The point of continuous integration is that everybody is reconciling their work with everybody else's all the time, thus helping you find nasty integration surprises early and while you can still do something about them.

The project in question: https://github.com/eholk/harlan

Angular is still a nice way to do your DOM manipulation declaratively. https://github.com/pangloss/clang extends angular to work with the the built in clojurescript data structures. Or https://github.com/zcaudate/purnam has some angular helpers that work with regular javascript objects.

You don't have to if you don't want to. But it's by far the easiest way to understand things. It's not actually complicated.

The whole point of git is the weird database. I'd tell you to go use another system if you don't like it, but that's not really an option anymore. So I'd instead just suggest that you do yourself a favor and spend an hour learning about it; you'll be far more effective as a result.

Because you're thinking about it wrong. They key to understanding git is to understand its data structures. Once you understand basically how it works, then all the wacky commands become shorthand for manipulating those data structures. It's really not a complicated system.

Watch this video: http://vimeo.com/14629850

This is a neat idea, but it feels oh-so-skeevy. As in "I don't think I'd trust these guys with my email address, much less my billing information." I don't trust that the Zen Master is actually what you say he is, or that he's even a human. I kind of think he might be an email bot, actually.

These are my impressions from reading the site; I have no way of knowing whether they are true. It would probably more successful by trying to earn my trust a bit before asking for my money.

This is quite nice. All of the animations would be made better by removing the bounce at the end; it's a jarring way to end something that's otherwise very smooth.

If somebody called me 少し変わった I would be a little taken aback, I think. I arguably am a bit 変わった for many reasons, but it's not the kind of thing you say to somebody's face.

> Fleex shows you mixed subtitles, so you get the hard parts in your language and the easier parts in English.

This seems like a Very Hard Problem. How did you approach it? Do you deal with polysemous words gracefully?

Can't quite tell if you're serious or joking. In case it's the former: the ClojureScript compiler is implemented in Clojure, which runs on the JVM. The compiled code is Javascript, which doesn't require the JVM. There have been some discussions about making the compiler hostable from Javascript as well, but it's not possible just yet.

This sounds glib on the surface but it's really surprisingly deep. The key is to realize that the problem solving doesn't happen in the second step, but rather in the first. Writing down your problem means you have to structure it in some way, to frame it in a way that at least can be represented on paper. Perhaps it's a formalization, or simply a brief explanation. In any case, step 2 is only possible because of step 1 for most interesting problems. Even for those of us who aren't Feynman.

The killer feature that they showed is an integrated UI layout preview tool, in a pane alongside the editor. Click on a widget in the preview to select the element in your layout file. This is neat but fairly ordinary; the great part is that it can show multiple previews at once, for different device sizes. Or for different locales. These all appear to update very quickly, if not live, when you change your code.

Starting at about 35 min in https://www.youtube.com/watch?v=9pmPa_KxsAM

>E.g. speculatively even looking near call sites by method name

That is devious and fantastic.

> But to get the most performance out of this you're likely to need to be prepared to do some very basic JIT.

Yeah. But the attractive targets here are places where you can't have a JIT: embedded systems and iOS.

This is neat.

What worries me about this and similar efforts (like https://github.com/takeoutweight/clojure-scheme) is that clojure's standard library design assumes that the underlying runtime will be do some kind of polymorphic method inlining.

For example: the sequence library is all defined in terms of ISeq, which basically requires a "first" and "rest" to be defined for the data structure in question. These are polymorphic: there are different implementations of these for different data structures (list, vector, map, etc). So a dispatch step is required to choose the right one. In clojure-jvm, this is implemented using a java interface; this means the jvm will inline calls to said methods when they're being used in a tight loop. And if you use the standard library, calls to 'first' and 'rest' are going to be inside nearly all of your inner loops.

Compare this to a normal lisp or scheme: 'first' and 'rest' (or 'car' and 'cdr', whatever) are monomorphic. They only work on the linked-list data structure. So compiling these directly down to C functions makes perfect sense and incurs no performance penalty.

So in summary: clojure assumes theres a really smart JIT which is helping things along. This means it's not as suitable for alternate compilation targets as you might want it to be.

I wonder if there's something clever you could do here. Vtables could be reordered based on expected usage, certainly. Clojure can already do some measure of type inference, so this could be used for AOT inlining when it's available. Even if it's not, perhaps several versions of a call could be speculatively generated based on what the compiler does know already. The normal polymorphic inline caching technique could perhaps be abused to apply here. But it's hard to see how any of this can work in absence of a profile or heavy hinting.

(not a compiler writer, just interested in the problem)

Fair enough. I'm thinking in particular of a paper I read that used pagerank for word sense disambiguation [1]. It's actually variant of pagerank, so the high level description in terms of probabilities (which I read several of) didn't take me very far. In order to come to grips with the technique I ended up actually implementing it and trying it on some toy datasets. This definitely would have helped me in that case.

[1] http://www.aclweb.org/anthology/E/E09/E09-1005.pdf It's interesting research, but it unfortunately turns out that even the best results in word sense disambiguation aren't good enough for a lot of applications. I wish I had 2 years to do nothing but play around in this field.

Nonetheless, linear algebra is the way it's done for real applications. It's how the literature treats the subject as well, so it's important to understand. This tool helps for that goal, so I'm glad it's there.

Any particular reason you need to proxy the data through your own server? Seems like a 302 to the original image url would be quite a lot easier and more scalable.

This must have been written before the announcement of the BeagleBone Black: $45, similar performance profile, HDMI out. Seems very much analogous to the Raspberry Pi.

http://beagleboard.org/Products/BeagleBone%20Black

It's worth noting that stackoverflow has some wiki blood in it; if an answer is out of date, you can edit it.

I'm going to be contrary here, not for its own sake but because I think this is kind of an important issue. What purpose does the animation serve? In what specific way is it better for these icons to be animated than to sit still? This is the question we should ask ourselves before putting motion on any user interface.

Tech-wise this is neat though, and thanks for open sourcing it.

> quite a few build systems are now turning to MQ's for build systems

References? I'm curious as to who's doing this and why. I'm trying to think of a reason and not coming up with much.

More than being wrong, the description is almost entirely without content. "Open source": true. "middleware-type": true, but doesn't mean much. "application deployment": not right, but also pretty vague itself.

The text straight from the results page tells an interested party that it's an "enterprise messaging system", which should be good enough for any blog on forbes.com. I really have no idea where they got the gobbledygook that they used.

"VMware’s RabbitMQ, an open source middleware-type application deployment project, ..."

Perhaps it's mean to poke fun at reporters, but this is pretty brazen.

The home page is really unclear; all of the explanatory text means basically nothing. The key question of "how is this different from maven" should be answered very obviously.

I think I figured it out: this is for installing java-based command line programs. Neat!

What's it for? If you can think of a reason to have it, then you should keep it.

I like the typography. The fade effect needs to go. The color scheme on the maps page, while neat, doesn't make much sense to me in the context of the rest of the site.

This is the same question I have. Memory usage is notoriously tricky to measure because of shared libraries and the like. So a simple figure like 95% doesn't end up meaning much at the end of the day. chrome://memory may be a good place to start.

Ninja edit: note the disclaimer at the bottom of chrome://memory:

    (Note: Due to memory sharing between processes, 
    summing memory usage does not give total memory usage.)