jhickner

From what I can tell it adds to the $35 pi:

- a case w/integrated speaker

- a keyboard/trackpad combo

- a wifi dongle

- nice manual

That's not too bad for the added $65. The mini keyboard looks nicer than the ~$20 FAVI ones[1] I usually use.

At first I thought they'd figured out a way to add a screen. That would be great. But it looks like you need to supply your own.

I work with students in Uganda and it's hard to beat what you get from a $200 netbook. Much faster processor than a pi, plus the screen is integrated. You can't do GPIO stuff like you can with a pi though, so there are trade-offs. Twice the price of this, too.

Looks like a great project to me!

[1]: http://www.amazon.com/FE01-BL-Wireless-Keyboard-Mouse-Touchp...

Does lens have a succinct way to traverse a nested data structure where each node is a maybe?

Lenses + Prisms (nicest way I know of in lens):

nested ^? foo . _Just . bar . _Just . baz . _Just

vs. the Maybe monad:

foo >=> bar >=> baz $ nested

> First of all: what is work? Work is of two kinds: first, altering the position of matter at or near the earth’s surface relatively to other such matter; second, telling other people to do so. The first kind is unpleasant and ill paid; the second is pleasant and highly paid. The second kind is capable of indefinite extension: there are not only those who give orders, but those who give advice as to what orders should be given. Usually two opposite kinds of advice are given simultaneously by two organized bodies of men; this is called politics.

John Carmack talks at length about Haskell in this keynote. Definitely worth watching if you're interested in that stuff.

Yes.

David Foster Wallace says it better than I could: http://www.theatlantic.com/magazine/archive/2007/11/just-ask...

I'm not saying it's all there yet, just that it's a way forward.

> Instead we are mired in the innards of the machine micromanaging absolutely everything with incredible verbosity.

This is one area where Haskell really shines. If you want the machine to be able to do what you want without micromanaging how, than you need a way to formally specify what you mean in an unambiguous and verifiable way. Yet it also needs to be flexible enough to cross domain boundaries (pure code, IO, DSLs, etc).

Category theory has been doing exactly that in the math world for decades, and taking advantage of that in the programming world seems like a clear way forward.

The current state of the industry seems like team of medieval masons (programmers) struggling to build a cathedral with no knowledge of physics beyond anecdotes that have been passed down the generations (design patterns), while a crowd of peasants watch from all angles to see if the whole thing will fall down (unit tests).

Sure, you might be able to build something that way, but it's not exactly science, is it?

> Do common people in the US really identify with being a patriot?

Patriotism originally meant you were willing to sacrifice something for your country. Presumably the smallest measure of that sacrifice would be spending your time developing well-founded opinions about how the country should operate. (Just take a look at the federalist papers: 85 long, dense articles arguing in favor of the minutest details of the constitution. And the expectation was that people would actually read them!)

Unfortunately patriotism doesn't mean sacrifice anymore. It means something akin to a fingers-in-the-ear, uncritical fanboyism. Just plaster everything with flags and soaring eagles and call it good. It's not sacrificing everything (like Snowden did), it's something you do instead of sacrificing _anything_, even the time it would take to educate yourself on what your country is doing. And as a bonus you get to flaunt that very ignorance as an additional point of pride.

And yeah, common people here in the US definitely do embrace it to a nauseating degree.

We wrote our RF radio mesh coordinator software in Haskell, and it's been a great success. Working with binary data formats (various building control protocols) in Haskell is the kind of thing that spoils you forever.

The one issue I've run into is that ghc can't cross compile. If you want to run your code on ARM, you have to compile an ARM version of ghc (QEMU comes in handy here).

Every statement by Clapper has mentioned repeatedly how the program is lawful and falls under Section 702 of the FISA act approved by congress etc., etc.

But that assertion is meaningless because as a couple of brave senators have let us know (Wyden, Udall), the very court that's supposed to oversee activities under FISA, the FISC (Foreign Intelligence Surveillance Court) has found the NSAs activities to be unconstitutional[1]. The response to this finding wasn't reform, but to classify the findings themselves.

[1]https://www.eff.org/deeplinks/2013/06/government-says-secret...

Very cool!

Small suggestion: In the case of selecting an item that's not the topmost, it would be nice if it was a one-step process rather than two (you need to first highlight with ctrl+letter, then activate with Enter).

Maybe a repeated press of ctrl+letter could actually activate the selection. Or maybe pressing and holding ctrl+letter for a short while.

+1 for this, also check out Graham's io9 video on the Counting Problem. The solution is beautiful and really got me excited about Haskell when I was first learning:

http://channel9.msdn.com/Series/C9-Lectures-Erik-Meijer-Func...

Also this one, from the github repo: https://dl.dropboxusercontent.com/u/2178548/CAPRICE.pdf

Agreed. Any relationship where you can freely "entertain ideas without accepting them" (- Aristotle) is something to be cherished. pg wrote an essay on this topic, for anyone interested: http://www.paulgraham.com/say.html

Anyone smart enough to have an interesting opinion on this topic is probably also smart enough to see that there's absolutely no upside to expressing that opinion. It either parallels the mainstream (in which case it's redundant) or it differs in some way, in which case it invites a retaliatory shitstorm.

In a nutshell Salvatore said that he prefers to raise the level of abstraction (as programmers are wont to do) from focusing on how _female_ humans are treated unequally to focusing on how _all_ humans are treated unequally. At worst isn't this a disagreement on methodology rather than a disagreement on values?

What purpose has been served by turning this topic into a third rail?

When this topic comes up I always marvel at the _intellectual_ shortcuts people take to justify the _practical_ shortcuts they take to simplify the hiring process.

Working with someone is the only way to evaluate what it will be like to work with someone. Looking at their work is the only way to evaluate their work. Tautology is your friend in the hiring process. There is no royal road to hiring great people.

With regard to "you should be prepared to talk about your hobbies and interests" - Great people are (almost by definition) not interested in the particulars of your interview process. In fact, if they actually are great people you'll be courting them, not the other way around, and they'll be bringing their own ideas to the table instead of sweating over whether they're conforming to your preconceptions.

I like vimwiki + Dropbox. You get the added benefit of being able to make notes on the run with an app like Writeroom that syncs to Dropbox.

Neat idea. I'd definitely donate if the whole thing was going to be open sourced so I could run it on my own infrastructure.

Currently we use csshX for this sort of thing, and it does the job. It's an open source tool that opens a bunch of ssh sessions and sends each character you type to each session. You can launch it with command line args that specify the hosts you'd like to connect to and optionally the commands to run, so it's pretty easy to set up scripts that mimic the recipes in this video. If you're working with less that 20 servers at a time (about the limit of what you can read on screen at once) it's a great tool.

http://code.google.com/p/csshx/

Still getting the same error here as well with 0.0.4

I don't see any marketing speak, but there's a lot of Clojure terminology. If you're not familiar with Clojure I can see how this could be annoying.

REPL: read/eval/print/loop (think irb from Ruby, although there's more to it). http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print...

Instarepl: A portmanteau of instant and REPL, meaning a REPL that evaluates immediately as you type.

"context for the Instarepl": essentially the namespace in which the REPL executes, meaning that if you run lein-light inside your project folder you can get access to your project's functions inside LightTable.

leiningen: Clojure's most popular build tool and vector for plugins that enhance the build cycle. https://github.com/technomancy/leiningen/

Very cool! Running into an issue installing lein-light though. Are the jars not posted yet maybe? gist here: https://gist.github.com/3078428

I haven't tried it with swank-js yet, but most swank-related things work well with slimv, a swank client for vim: http://www.vim.org/scripts/script.php?script_id=2531

I really like the coffeescript + haskell feel. I always miss haskell's '$' for function application and '.' for composition. LiveScript has both (<| and .).

Check out the "10 LiveScript one-liners to impress your friends" post. Great stuff: http://gkz.github.com/LiveScript/blog/livescript-one-liners-...

shiffern's example uses the same coding style you use in Clojure. It doesn't feel like stretch to call it FP. Start with a basic data structure (the object in shiffern's example would translate to a map in Clojure) and then operate on it with simple functions.

  (def snake {:name "Sammy" 
              :distance 5 
              :move-verb "Slither"})

  (def horse {:name "Tommy" 
              :distance 45 
              :move-verb "Gallop"})

  (defn move[{:keys [name distance move-verb]}]
    (println (str (or move-verb "Mov") "ing..."))
    (println (or name "It") "moved" (or distance 1) "meters")) 

  (move snake)
  (move horse)

>Take a look at all those multi platform desktop frameworks like Qt, wxWidgets, etc. Apps made with those don't feel native and usually deliver subpar user experience. It's not much different with PhoneGap, RubyMotion and friends.

This is not actually the case with RubyMotion, since it compiles directly to native code and uses iOS-native UI. A RubyMotion app is indistinguishable from a native Obj-C app.

Those same students and programmers should realize that yours is just one opinion among many. Your advice leans toward the "fungible cogs" school, where the capital crime is to expect others to learn something they don't already know.

That's still a widely held view, and maybe even a majority, but probably not on HN. (see pg's Beating the Averages essay: http://www.paulgraham.com/avg.html)

There was another one called Subspace (now Continuum) http://www.getcontinuum.com/. I loved the early days of that game. 1997-ish.

Aren't we just embracing the difference between a site and an API? It's hard to do both well at the same URL. The API provides the repurposable content in an open format, and the site itself is free to experiment with different presentations. Is that so bad?

They'll never be popular? I think the main impediment to wearable computing has been how socially awkward it is. If someone actually came up with a discrete, well-designed glasses-based computer, I think it would be immensely popular.

AR won't really come into it's own until such a platform exists. Holding a phone in front of your face is just too awkward.

- read any language

- never forget names

- navigational aids (obviously)

- identify any bird, plant, etc.

- a whole raft of products just geared around augmenting the museum experience

- look at a printed equation and see it solved

- look at a printed question and see it answered (within certain constraints obviously)

- look at binary, hexidecimal, etc. and see it converted to decimal

- look at a color and see pantone and hex color codes

- read existing printed books, but with access to immediate dictionary lookup, references, etc.

I could go on and on... if this ever hits, the ramifications will be extraordinary.

I find emacs + swank to be roughly equivalent to vim + vimclojure + paredit.vim. Install vimclojure and the lein-nailgun leiningen plugin and you'll be up and running in no time.