skysight-inc/HackerNews huggingface dataset:
A common problem at the moment is RSpec being slow with Rails 3 and Ruby 1.9.2. If you do things the "normal" way, Rails ends up having to load twice and you're guaranteed to spend at least 10 minute looking at nothing.

The solution is to use Spork to have a Rails test environment running permanently (it also does caretaking between sessions) and then RSpec will access it over DRb. Couple this with a good .watchr file to run only the relevant specs when you update them and you get very quick RSpec tests. It's a bit of a pain to set everything up but it's worked great for me.
The table needs context. How much could the same person make in private industry for a similar job?
Apple Touts Suicide Nets In Supplier Responsibility Report, But Changes Little
I like it! I'm wondering why it's invite-only though?
That's a very optimistic error message!

error: conversion from std::_Rb_tree_const_iterator<std::pair<
const std::basic_string<char, std::char_traits<char>, std::allocator<char> >,
std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >
to non-scalar type std::_Rb_tree_iterator<std::pair<
const std::basic_string<char, std::char_traits<char>, std::allocator<char> >,
std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >
requested
It just depends on what you want to test for. I find balance in testing for the most important security features such as authentication and stuff that'll most likely change very little.

You can speed up RSpec so much by offloading it to Spork, a test server of sorts that loads your environment.
TDD is just not as important as getting a product out the door.

There's not always a "do TDD, develop slowly" vs "do no TDD, develop quickly" dichotomy.

If you're doing it right, TDD should speed you up. It adds some guaranteed extra time to your plans up front but significantly reduces all of the hidden costs of wasting hours debugging bugs that unit tests would have picked up.

So I might know developing a particular app might take 10 hours without tests, 15 hours with tests, but if I waste more than 5 hours fixing a myriad of bugs, the TDD approach still wins. (The constant reward cycle is an important psychological factor too, though, even if the times are equivalent.)
In the presentation shown at http://www.startuplessonslearned.com/2008/09/customer-develo... (specifically the last slide where he talks about the Five Why's system) it seems to me that the guru of Lean Startups is a advocate of automated test suites, and therefore a believer in TDD.
A few things I've noticed:

Developers should not be paid to write tests, only code. If the tests are worthwhile, then they'll get written anyway.

I've seen some developers who write lots and lots of pointless tests... hmm does Model.find(:all) return all the items in the test db? Ok one passing test, does :first return one? Ok, another passing test. I'm not exaggerating.

If your test codebase is full of stupid tests that are actually testing your framework, and if your test suite takes 5 minutes to run, maybe that's why your team has so much time to read HN.

Good, useful tests will test the most critical 10% of the codebase at most. The "money" paths that are critical to your core business. Things like credit card processing, account signups, password resets.

Many of the critical 10% of tests may very well be integration tests, not unit tests. There is no reason to write unit tests if the big problems would be caught by an integration test before a deploy.

If your testing ideology makes all this sound like hogwash, then you probably work in a cubicle where it does make sense to do test your codebase more broadly.
IP in Mono falls into several categories.

1. There is stuff covered by the ECMA/ISO standards. This is covered by the Microsoft Community Promise, which is legally binding. This stuff is safe from Microsoft.

2. There is a lot of .NET stuff that Microsoft has released under the Apache 2 license, which includes a patent pledge. If any of this stuff is implemented in Mono, it is safe.

3. There is stuff in .NET that is not covered by the standards, and has not been released by Microsoft under a license that includes a patent pledge. Mono has independent implementations of the interfaces of some of these things. There is no Microsoft patent pledge covering these parts, and Microsoft may have patents on their own implementations. These patents would cover specific methods used in the implementation, not the interface.

The risk from #3 is small. Most important, it is about the same as the risk if you use that functionality in a non-Mono system. For example, I believe that there is an XML parsing library included in category #3. If Microsoft has a patent covering some particular technique of implementing an XML parser, there is no reason to believe that the people who implemented Mono's XML handling are any more likely to have infringed it than the people who implemented Java's XML handling, or Ruby's XML handling, or Python's XML handling, and so on.

Also, most of the things in #3 are things specifically related to Windows programming, so you'll only find them in .NET programs that were written for Windows. If you are writing for Linux, you don't need those things. Even if you want your programs to run on both Windows and Linux, you can do that without using the category #3 stuff. For instance, instead of using WinForms, use GTK#.

If Microsoft did decide to sue someone over their patents that cover the category #3 items that aren't Windows-specific, it is doubtful they would go after Mono. Microsoft has done enough to support and encourage the development of Mono that they would have a big estoppel problem to surmount if they wanted to sue over Mono. It would make a lot more sense to sue over Java or Python, where they would not face the estoppel issues. Remember, as I noted earlier, the category #3 patents are as likely to be infringed by those as Mono.
Think about the guys in any prison movie: Take time to plan your escape.

1) Instead of digging a hole with stolen spoons in the prison yard, learn to program. "Rails for Zombies" (the tutorial) or Michael Hartl's book can substitute for stolen spoons. Build a personal pet project or find a way to contribute to an open source project. It'll be more fun than digging a hole in the prison yard. And you'll develop a marketable skill that'll get you a job so you don't end up back in prison.

2) While you are developing programming skills, get yourself transferred to a different prison where you can make an easier escape. You can get into any community college in the Bay Area (Laney College in Oakland, for example). Or try SF State or CSU-Hayward. Going to college in the Bay Area will give you a base and you can make your escape to a startup from there.

3) Just like the guys who volunteer in the prison library to get in position for their great escape, once you're in the Bay Area and enrolled in a local college, volunteer for all the startup events and conferences (seems like you've already done that with the TechCrunch events). It'll be a lot easier to ask people about jobs or hookup with a cofounder if you can say you're already living here and have got some useful skills.

You're smart to recognize that you need to escape your current environment to move ahead in your life. Just make the change in a smart way. Or you'll be stuck in solitary confinement for a long time.
1) Namespace complaints pop up every time JSON debates pop up. XML handles them two ways, and their equivalents, fully within what I already defined:

ns:node => {#:"ns:node"}
xmlns="http://www.w3.org/1999/xhtml" =>
{"xmlns":"http://www.w3.org/1999/xhtml"}

ie, it's already handled. Namespaces are a parser's job for interpretation, the notation is simple.

2) The point wasn't to say JSON is better than XML - apparently you didn't read my second sentence. I said they're trivially identical - they're the same thing, with the same capabilities, but with minimally different ways of representing the same data. The point is that claiming XML can do X because it's XML and JSON can't because it's not XML is complete nonsense. All the schema / XSLT / etc tools are just that - external tools, algorithms to run against data, which have nothing to do with how the data is transmitted.
The reason why coaches like Tedford and Howland get paid so much is because the amount of revenue they bring in for their schools is worth much, much more. It's the same reason Fortune 500 CEO's get paid millions because the value a good CEO can create for their company is often worth hundreds of millions if not billions of dollars. So paying their CEO just a few million is a relative bargain. Same concept with D1 football and bball coaches.
The justification is generally that these football programs pay for themselves with ticket sales, merchandising, and segregated fundraising. I know that at my private alma mater (Duke), Coach K makes many times the salary of President Brodhead and it's still a net positive income for the school.

Whether that's a business that universities should be in is a question for another day.
I've used BDD in a startup, and it increased my development speed. Here's what I did:

- I wrote the specs before I wrote the code. Essentially, I used Cucumber to define how users interacted with the site, and I used RSpec+Shoulda to define how low-level APIs worked. This rarely took longer than testing by hand: I just wrote something like "When I click on 'Sign in', Then I should see 'You are signed in.'", and that was it.

- I kept a watchful eye on the size of the tests. If the test-to-code ratio ever drifted far from 1:1, I figured out why and fixed it. A 3:1 or 5:1 ratio is a sign that your BDD/TDD process has gone way off the rails, at least in my experience. Common causes are (a) not using Shoulda to test models, and (b) relying on controller specs when you should be using Cucumber (or Steak).

- I used Cucumber for specifying user interactions, and RSpec for testing models. I only wrote controller specs for weird edge-case behavior that was a pain to test with Cucumber. Edit: And I virtually never wrote view specs.

- Refactoring was easy, because I could tear into the code and trust the specs to report any breakage.

I agree, however, about the speed of Ruby test suites. I hate hate hate waiting for specs to run. I get some mileage out of autotest and Spork, but not enough for my tastes.
Somehow I find it hard to get bent out of shape about "SENIOR BRIDGE ENGINEER" making 103,000/yr. That's hardly buckets of cash, particularly in CA. There are plenty of much more absurd salaries listed right there for you to call out...
> Python makes simple things hard.

Some examples might help here.

> It has no switch statements

Python uses if/else, hashtables, OO constructs instead http://www.python.org/dev/peps/pep-3103/

> no lambdas.

Python has lambdas, but their usage is discouraged in preference of explicit code blocks and named functions. You can use them if you must.

>It has significant white space

The indentation level of your statements is significant, but not whitespace in general http://www.secnetix.de/olli/Python/block_indentation.hawk

> There is no simple way to drop down to the command line which means I can't easily use it to replace the scripting I have to do on a day in and day out purpose.

Some people find Python usable for system administration. There is a book "Python for Unix and Linux System Administration" (2008).
This is the case in almost every state.
While I agree that the US has a serious imprisonment problem (jailing people for the wrong reasons), I have to believe that getting doctors to work in the prison system requires some significant financial incentives -- and most of these people seem to be medical professionals.
Winning football teams fill stadiums (selling tickets), get better ESPN coverage (more money) and keep alums happy (bigger donations). That position probably turns a profit when it's all accounted for.
That's not in the trunk yet ... it is queued.

There is also C#. It's been in testing for a while and there are a few known bugs. Should get worked out in the next release.
This is a case where the author put his needs over the needs of the organization.
Only real artists ship
Both Open Source Desktop and web startups give a lot out for free. Web startups have massively succeeded at times. It don't see why an Open Source Desktop startup couldn't succeed if it started out with the aim to disrupt rather than to copy.

What I would like to see is someone formulate a plan for a series of small and/or more modular tools that could be used instead for office purpose instead of a massive office suite.

Open source seems doom to lose in a race to create Microsoft-style monster applications. And this isn't to deny the usefulness of MS Office or Open Office.

But an approach that could play to the strengths of Open Source would be needed if you want to win.

Creating a good browser is possible if not easy because the browser is modestly well-defined application.

Inkscape is the best open source GUI app I know of. Indeed it's app that isn't bad. As far as I can tell, a factor that let's it be good is that it's objective and domain are really well defined.

It would be nice to see people focus Open Development modular tools with a standard, well-defined domain. Those are the apps that the most enjoyable to program too.
Dell Venue Pro Flash Light App Lets You Use Camera LED As Torch
> California bankrupt ?

Well at least now we know why ;-)
Looks like he's still reading websites via an HTML-to-email gateway; good for him!

Interesting that he mentions Diaspora, but not GNU Social.
It is naive to think that suicide experts would recommend better working conditions, creating unions, or investing in machines to perform mind-numbing tasks.

Suicide experts have been trained to treat the problem of suicidal thinking, not the potential causes. If someone is suicidal because of depression, they tell them to talk about it and take an antidepressant. They don't advocate to their boss that they would be better off if they got paid more so they could work less and had better food in the cafeteria.

What do you expect?
I suspect they were using .NET 1.x at the time, which would explain a lot.
I have heard that these top salaries get skewed because state employees tend to get a lot of "back end" compensation. So if it's your last year of employment, you collect unused vacation and sick pay. They also put in as much overtime as possible because it forces a higher pension due to averaging of the last few years of pay to determine pension amounts. So you will see a guy who maybe made 70k getting 100k+ during his last one or two years.
> Kudos to his manager for actually looking at the code and recognizing the problem.

In the majority of the cases however you deal with managers who lost understanding of anything but simple language constructs because all they did since becoming managers is management and no code development at all. At some point they start rejecting everything they don't understand. They justify their position by arguments of code clarity and maintainability. But they are misguided. To recognize readable and maintainable code you actually need to practice programming continually.

I dealt with such managers. They would tell me that a dozen of simple code lines are unreadable because they saw a new keyword they don't understand. But they would accept a hundred of code lines that do the same thing in which they can recognize all keywords. They wouldn't care about what the code actually does, nor they would care about what it takes to parse a hundred lines of spaghetti code.

It always fascinated me that some managers think they understand developing code better than developers they manage. I've had the best experience with managers that trust their developers to make decisions and the worst experience with managers that try to micromanage.
I've always found that nothing ever happens unless I do it myself.

I share this experience. Over and over again.

I've come to call it the 9-5 attitude. As a freelancer it's always a sobering experience to churn through a time-critical project (critical for them) and then have the remote guy drop out of skype at 6:00pm, every day, as if it wasn't their servers that are going to blow up if we don't get this done before the marketing-campaign on friday...

Of course not all companies are like this, but I've observed it even in (funded) startups where it's especially irritating.

I think it has a lot of do with a perception of ownership. As a freelancer I am my business and do my best to deliver high quality work.

As Employee #17 in someone else's company it seems to be more common to gravitate towards the path of least resistance; do just enough to keep those paychecks coming.
> It has no switch statements,

Opinionated langauge. You either use a if-elif ladder or use a dictionary to switch. I use dictionaries most of the times; not trying to defend lack of switch here but table driven code tends to be less fragile.

> It has significant white space

Significant indent. The only problems I have ever found with this is when I copy paste code in vim and try to auto-indent. Sometimes when the copy is not properly indented, it goes awry.

The limited lambdas are related to this. Other than copy pasting code and limited lambda as a related consequence, I can't think of any other issues it might cause.

> use it to replace the scripting I have to do on a day in and day out purpose.

Why would you necessarily want to do it? I assume you mean shell pipelines when you say command line scripts. Shell scripts, if you are on *nix, suit a particular class of problems very well.

Sure Ruby and Perl play nicely with command line scripts and I have worked on Perl & am familiar with Ruby, but I seldom resort to them - if it's a shell pipeline, sed,awk,grep and co are summoned. If it grows beyond that, then I open vim and write perl/python re-using the pipeline and adding some logic.
TDD/BDD assumes you know the problem and are coding to create a solution. In startups, however, you do not know the problem.

This seems like two ideas conflating into one. The business 'problems' (1) and the problem you're solving in a particular piece of code (2). These aren't usually directly related. For example, if I wanted to build a YouTube killer, the TDD process isn't relevant to the high level "problems" I want to solve (which, as you say, one might not know of yet).

TDD comes to play (from a developer POV) when I actually start to write some code that, say, transcodes a video or provides an authentication system. In those areas, the problem is obvious and contained and TDD can work well.

That means that odds are that you will never see this code again. You'd be a fool to spend any more time on it than absolutely necessary.

Which does not necessarily mean TDD is "a waste of time". If practicing TDD in a particular situation will result in fewer hours spent developing a feature, the upfront "cost" of those hours is not a waste of time if you spend more hours debugging your way through building a non-tested equivalent.

A developer should have a feel for which way works for them. In my case, I know that the time I spend is ultimately lowered through using some TDD principles (though not all) vs tiresome debugging of untested code. The reward cycle of TDD is commonly overlooked. "Code->Yay!->Code->Yay!" beats "Code->Code->Code->Code->2 hours of debugging->FFFFUU!!" any day.

"True" agile means ditching whatever isn't working. Pronto. There are no sacred cows. Everything is on the table.

Agreed, but that runs counter to making absolute statements like "TDD doesn't fit the mold of startups" and that "it's a waste of time." It can fit and it can save time (just not always, sure, or if you're 'doing it wrong' for your situation).
The vast majority of his salary is not paid out of state funds. According to this, most of the compensation is provided by Nike:

http://www.californiagoldenblogs.com/2010/12/3/1850306/thoug...
"However, even if I could browse a site daily, I couldn't afford the time to do it myself. I can barely keep up with the work I have to do."

A very valid point.
> Sure you can, but why would you want to? Reinventing the wheel is not fun.

Reinventing the wheel is not the opposite of using a framework. Remember the "favor composition over inheritance" principle? It applies here. Compose libraries rather than inheriting from a framework.

It just happens that PHP has a plethora of frameworks and a dearth of libraries.
This seems to set up some interesting parallels to the Tractatus, but I don't think it does so in a way that improves our understanding of software engineering. I'm tempted to put it in the "not even wrong" category, but I'm worried that may be too harsh, and I may need to go back and think on it some more.

Incidentally, computer-types may be interested to know that Alan Turing sat in on some of Wittgenstein's lectures on the foundations of mathematics, and they didn't quite see eye-to-eye.

http://www.amazon.com/Wittgensteins-Lectures-Foundations-Mat...

Edit: excerpt here: http://www.turing.org.uk/philosophy/ex4.html
I think even the true TDD "purists" would say you're doing it exactly right...

Robert Martin usually says "You are not allowed to write any production code unless it is to make a failing unit test pass."

When I'm writing code to solve a problem I've never solved before, I don't write tests. But then I scrap it and write tests first, implementing code to pass the tests. It may sound wasteful, but I have enough experience behind me to know that those tests come in mighty handy about six months later when I want to add in some crazy new feature I didn't think of before.

Heck, I even do that with new features - I'll branch, write it, see if it works, then branch again off the master and implement it again with tests. It's not much extra work really, and I often do catch little mistakes I made in the "prototype" version.

But it's taken me a long time to get used to TDD, and I feel like I'm still learning. I occasionally find myself over-testing. Like anything else, it's a discipline, but I find it so worth it.
> some significant financial incentives ...

Oh I understand that but a $500k increase from $200k to $700k ?
That "argument" makes no legal sense.
First of all, congrats on the site!

I've been tossing around a nearly identical idea for a few weeks, and had a good laugh (and better cry) after reading this post.

As I'm sure most will, I felt a bit of apprehension before posting, but went ahead and submitted my first idea a few minutes ago. It might just be the perfect outlet for those more off-the-wall ideas that I'm not too heavily invested in. I love the design and character of the site, and think you already have a great identity down. The illustrations really fit the idea-bouncing, brainstorming process that it serves.

Someone said it below, but i had also first clicked a lightbulb on accident with no idea of what it stood for. Might want to throw a little question mark with a description near it?

Looking forward to see how it progresses, best of luck!
Yes well, I could have used the same argument against the GPL back in the day. And really, I don't need to read through an article by someone who declared the Mono project "dead" a few months ago because he couldn't find the SVN repository. Or spams Reddit endlessly. Not to mention the years of insults and ideological attacks on various FOSS people.

In any case, you might want to look up the legal term estoppel.
One symptom of the BDD kool-aid is Cucumber. Cucumber is very useful if you've got a customer in the loop who doesn't speak Ruby. However, if everybody who is viewing/writing the tests speaks Ruby, then maintaining the Gherkin translations is a waste of time, and a "leaky abstraction". Webrat by itself presents a very clean, concise, readable syntax, so just use it by itself for integration tests, or use one of the other alternatives, like Steak.

http://mrjaba.posterous.com/acceptance-testing-and-cucumber-...