francoisdevlin

Personally, I think ageism in the industry is great. Let my competitors ignore the large pool of experienced engineers out there, and hire some young kid who is "cheaper". While he's fixing his design for the tenth time, I'll pay that expense old dinosaur to do something boring, like get it right the first time.

When you are used to having money, you're more likely to think that material things can be replaced. A bag of candy is a much smaller deal when you make 100k a year as opposed to 20k, so you don't think as much of it.

Just one thought.

Take a moment to compare this with the age distribution of HN, and you'll start to put it all together.

I use Vundle to take this a step further

https://github.com/gmarik/vundle

What you didn't take into account is that getting .1% control of anything would be a major coup for us in the lisp world :-p

The only potential catch is that this is a lot MORE targets for espionage. You only need to find one person with some life circumstances (new kid, long commute, conflict of interests, etc) and spearfish/blackmail/torture/teach scala accordingly.

Granted, your proposal does address a lot of things, but this is something that would need to be addressed. Thoughts?

Looks cool. My one thought is replace @when with @if, to make life easier for every programmer ever.

As my numerics professor said, "The more dimensions, the more you curse" :)

This has to do with trying to get a finer estimate of a problem. Suppose you have a one dimensional problem you're trying to solve. You take the line segment, break it into 100 pieces. These techniques usually a matrix with about 100 rows in it, and you have to invert it / find and eigenvalue, etc. These are O(n^2) or O(n^3) depending on the problem.

Now, let's get a better estimate, and use 200 points. We've doubled the number of points, so our solution now takes 4 to 8 times longer, depending on the type of problem.

Switch gears to a 2d problem. You now have a 100 X 100 mesh, that creates a matrix with 10,000 elements. If you want to improve the accuracy, you need a 200 X 200 mesh, which creates a 40,000 element matrix. Our algorithms cost O(n^4) and O(n^6) to get a better measurement now.

Now consider 3 dimensions and beyond. Your 100 x 100 x 100 system becomes a 200 x 200 x 200 system. This makes what is technically known a FREAKING HUGE matrix. Your algorithm is effectively O(n^6) or O(n^9), depending on the problem type.

You can see how this gets nasty quickly. HTH

wrexsoul? Is that you?

There's another way of looking at this. Do you want to work with smart colleagues and good management? Work for a company that pays you & the other developers well. It'll be much more enjoyable to go to work each day.

No. Just no.

The JVM is the only redeeming feature of Java (the language). You're nerfing the high performance features for what, exactly? A half assed tracing ability? "Write once, run anywhere"?

Javascript won in the browser, move on.

It sounds to me like you need an email list server.

He WANTS the DHS involved? I'm not sure that's a trade off I'm willing to make. Let's hope the thing just dies.

It's funny because it's hard to understand the value of experience until you have some.

Because of non local returns. People abuse them when instead they should be using an exception, or preprocessing their data better.

This is a terrible idea, and ruby used the wrong implementation. If you want this behaviour, you should just define a higher order function/decorator, and put your "block" in its own function. This is a case where there should be only one way to do it.

It's a firefly reference.

> accounting firms operate more like law firms in that they help you figure out how to meet the bare minimum to legally qualify for various returns

My wife is a CPA, and many dinner conversations sound just like this.

As a developer who's married to a CPA, here are my thoughts:

1. Taxes are a hard problem. Besides basic W2s, There are a lot of deductions to know about, and it's hard to keep track of all of them.

2. Depreciation schedules. They vary from item to item, and there's a bit of a grey area on what you can use, and what you can't. What can have bonus depreciation?

3. Calculating cost basis is too damn hard for most of us. Not just stocks, but partnerships as well.

4. When can you take a distribution from a business? How many times is that money taxed?

5. Add another 50 use cases, one for each state.

6. How do the states interact for individuals with diverse activity? Easily 2^50 cases here, and my gut say more like 50!

7. Foreign activity. Good luck with that.

The bottom line is there still is enough complexity that this needs to be done manually. Not to mention there are a lot of things that are legitimate judgement calls, and vary from accountant to accountant (or auditor to auditor when dealing with the IRS).

So, that's why robot's aren't doing my taxes any time soon.

Because they learned from netscape's mistake, that's why.

http://www.joelonsoftware.com/articles/fog0000000069.html

There's also slimv, another swank client in VIM. Here's a video using it with Clojure

https://vimeo.com/38372260

So true. I've been "That guy", and it cost me my job. I didn't get it until then.

Wouldn't a sniper rifle "remove the mine" from the MPAA's perspective?

Very, very cool. Would love to see this implemented somehow. Would save me from lots of "mouse goofs"

Okay, I'm one of those devs. What is this virtual/resident set size thing you're talking about?

EDIT: Thank you for all the helpful responses!

Well, Heroku certainly seems to be a major leader in the "Coolness" factor here. How good are they from a business perspective? Is their uptime good? How much do they cost? Would love to hear from the community.

And this is why I use noir.

I can feel a bit of his pain, though. I think some of the trouble is that there are things that should be closable, but the (.close x) isn't enough. A Closable protocol could help with some of this.

Granted, laziness still makes this issue very, very tricky.

There's Noir, which is more minimalistic that Rails, but it's easier to customize as a result. I've had some fun playing around with it, but I personally haven't used it in production yet.

webnoir.org