Davertron

Yeah, I guess my real question is "why is this (hacker) news?". But I know why it's really being reported, I guess I just hoped HN wasn't as bad as other news outlets...but here I am, commenting on the story so...

Why is this news?

Capital One, not Schwab.

James Long (jlongster) does this from time to time. I haven't watched any of his videos yet but I find it hard to believe that they wouldn't be interesting considering his talks/articles etc.

https://www.twitch.tv/jlongster

PUBG

Dark Souls 3

TIS-100

Rocket League

Yeah, back when I tried Common Lisp #3 was a stumbling block. I hear Clojure solves that problem pretty well, maybe because it's a little more mainstream than other lisps and also because my understanding is it's pretty easy to work with existing Java libs from Clojure.

I was just going to post that. I don't think any other explanation or tutorial does a more complete-yet-understandable job of explaining how the DFT actually works. I feel like there are a million articles out there that do basically what this article does, which is to explain kinda-sorta what the Fourier Transform is (i.e. "make a wave using other waves!") but never go into any detail about how you select which constituent waves contribute to the overall wave etc., and so I was always left unsatisfied.

Is your company hiring front-end devs? ;)

It might be useful to put the company name out there, I'd be interested in learning more.

David Nolen - http://swannodette.github.io/

James Long - http://jlongster.com/

I follow these guys for similar reasons. They always seem to be a couple steps ahead of the rest of the industry and it's frankly a little embarrassing how productive they are. Come to think of it maybe I'd feel better about myself as a programmer if I stopped following them...

Is everything else between these two groups completely equal? I seriously doubt it is, in which case I don't think it's fair to make any conclusions that hold weight.

This is one of the problems I have with these sorts of things. My company went Agile about two years ago, and lots of people like to rant about how much better everything is now and how much more productive we all are because of it. Except we actually have no way of knowing whether it made any difference at all.

Rich Hickey just did a great talk about this sort of thing at Clojure Conj: https://www.youtube.com/watch?v=oyLBGkS5ICk

First I guess let me say that I would love to hear more of this kind of thing, as I think the rest of the US would right now, because a lot of us are shocked by the outcome of the election.

And while I can understand her feelings about Obamacare etc., it's very frustrating to hear someone voting for a candidate based on the actions of islamic extremists. The danger of being harmed or killed by terrorism is extremely low, especially here in the US. It's like people being afraid of flying, but having no problem driving or riding in cars every day, when statistically you're far more likely to be harmed in a car than a plane.

The CSP thing is something I've been looking at recently, and while it seems like it's a little bit lower-level than things like Rx, it seems like channels are more flexible streams (i.e. channels are two-way so you can do back-pressure etc.). I've been playing with https://github.com/ubolonton/js-csp and it's pretty nice; the "yield" statements everywhere are a little wonky, but otherwise it seems like you can implement some pretty sophisticated concurrency between processes with pretty straight-forward code.

For examples of that sort of thing, David Nolen and James Long have written some really great articles on the subject:

http://swannodette.github.io/2013/07/12/communicating-sequen...

http://swannodette.github.io/2013/07/31/extracting-processes

http://jlongster.com/Taming-the-Asynchronous-Beast-with-CSP-...

There was also an article recently that described a flux-like architecture using channels that I found pretty interesting, but I can't track it down right now.

I was going to say, a lot of the Math I learned in High School and then never applied to anything I re-learned more recently when I started mucking around with computer graphics and game dev (especially trig, matrices, vector math, etc.)

I'd love it if people had suggestions for other engaging ways to apply math while programming!

I was going to say, if these are in priority order, move #8 to the top if you're not already doing it! That way you get the benefits of it moving forward :)

Moving entirely to svg for user interface has some of its own issues (i.e. there's no default layout engine in svg; everything is essentially absolutely positioned...) but would be interesting to think about. Moving entirely to WebGL would only be viable if you don't care at all about accessibility though. For some subset of applications that might be acceptable (i.e. games), but for something like gmail or other similar applications it's definitely not.

What if you can't know the height of the element?

I've built a few apps using node-webkit for myself and, being a web developer, found it pretty awesome. One of the challenges that I think atom-shell handles better is background tasks/jobs. In node-webkit, my understanding is if you want to be able to background tasks using a node worker (not a webworker), then you have to bundle another node runtime with your app and use node's execute/spawn. This works OK, but bundling another version of node is kind of a pain. atom-shell works this way out of the box which is awesome if you need it.

Both projects are great ways of developing apps using web technologies though.

For normal apps I would mostly agree, but for a lot of games performance matters.

It's not like you have to update it/configure controllers every time you turn it on. My Xbox often has to update prior to me being able to use it if I haven't played it for awhile too.

I believe Cloud9 (https://c9.io/) is exactly what you're asking for. Unfortunately I haven't been able to get it to clone any of my repos recently to play around with it a lot but I did try it out awhile ago and it seemed pretty decent.

Ha I wasn't too serious about it...that was basically the only nitpick I could find :)

You got the color of the ones and twos swapped :p

Great job!

I've done similar and now I almost always write a select first and then only after I've verified I'm getting the rows that I expect do I update my query to an update/delete.

I wrote an update script for a database table not realizing I had the key wrong (I'm kind of fuzzy on the details, but essentially I think it was a composite key but I was only using one of the columns in my WHERE clause...) and accidentally updated all customers addresses in our database to the addresses of one account.

Luckily we had backups from that morning so we only lost any address updates people would have done that day, but it made for some interesting customer service calls for awhile...

Do you still have to set the column widths explicitly? That was one of the main reasons I had to drop this lib, because we had dynamic data and I didn't want to deal with adding a bunch of JavaScript on top to resize columns on the fly when the data changed.

Yeah, I've run into this as well. I would say avoid doing this if you can and use an AJAX call from inside the javascript to pull the data in that you need. Sometimes this isn't feasible/ideal though (especially if the data is slow to get/calculate and is already used on the html page...). If you can cache the results of the calculation on the server-side, that would mitigate the performance implications a bit and then you just have the overhead of the request itself.

I didn't see anything about them having their own servers, but they do mention you can use something like BitCasa or Carbonite along side Plug, which run about $5/month for unlimited backups.

"Dear users: you're doing it wrong".

I don't think this is a very good answer. If the majority of your users think that your site isn't useful (and I'm not at all sure this is the case, although I can certainly identify with this sentiment) then you need to go back to the drawing board.