How does refraining from collecting sales tax make Amazon look cheaper than Barnes and Noble? The sticker price doesn't factor in the sales tax; on an item-by-item comparison, the prices would look the same if B&N could match Amazon.
Based on this observation, I find the explanation that Amazon's not interested in spending the money to track state and local sales tax policies to be more plausible.
I wonder if there's correlation between below-average physical activity and insomnia? I assume that a lot of coders---by necessity of their task and the tools they use---spend most of a week sitting as opposed to, say, a mail carrier or store clerk. Given that we're a species that evolved to leverage mobility for our survival, it's not a stretch to imagine that our bodies developed a dependency on lactic acid buildup and other "fatigue toxins" as one of the signals that sleepytime is at hand.
Has anyone done this study? It seems like a pretty straightforward study to do if some grad student out there is looking for a paper.
Thanks to the general availability and utilization of vaccines against smallpox and polio, massive improvements in sanitation and emergency response, and long-term cardiac therapy, the death rate due to cancers is radically up.
Cancer is a horrible disesase. Which one of those changes should we not have made to end up in the situation we're in today?
My experience with the legal system has been limited to a handful of vehicular violations and one tour of jury duty. But from that limited perspective, I cannot see why the justice system should minimize useful facts.
Apart from the laws that protect other rights incompatible with perfect knowledge.... As a maxim, justice should never hide from evidence.
Is it possible that the difference between 1984 and the world into which we could be moving is that Big Brother recorded all motions and activities of the citizenry, but the reverse wasn't true?
I've heard this approach described as a failure continuation, and it's a good approach. It's much easier to do in a language that allows for easy creation of closures. Such a system wouldn't be impossible to construct in C++; you could create an ErrorHandlers object that is passed as the last argument of every method and contains instances of some kind of "RestartCase" object. But I cringe at the amount of boilerplate that would be required to support such an approach.
Property values are significantly lower in Pittsburgh, which makes property ownership easier. And the top-quality colleges in the city continue to graduate excellent candidates for tech company employment.
Although a graduate can ship out west, the lower costs in Pittsburgh make the path to ownership shorter. I'll be interested to see if the economic downturn will give graduates pause when thinking about shipping themselves three timezones away into an expensive location, when the cheaper prices in Pittsburgh could offer a lifestyle with less debt.
Slightly off-topic, but if you're installing ODE on Windows, you're in for a world of hurt. I never had the chance to try any other dynamics packages that build on Windows, but I'd recommend shying away from ODE; this is a "devil I know, devil I don't" situation where the devil I know is pretty evil.
You'll find that ODE can be downright Windows-hostile in pieces of its implementation that have nothing to do with GNU toolchain issues. Take a look at http://www.ode.org/old_list_archives/2003-October/010046.htm... for the most common problem; they don't care that the stack has different restrictions in Windows and Linux. You'll also find ODE to be downright thread-hostile; the entire library is non-reentrant (they built their own non-threadsafe layer on top of malloc inside the engine; you can't trust any two functions to be callable from separate threads, even if they have logically nothing to do with each other).
ODE is the first physics package most people seem to suggest, but I think it's more trouble than it's worth.
I'm sure I'll get accused of having no sense of humor, but I have to observe that from a usability standpoint, this is unhelpful. It gives me no clue as to what I've done wrong, it wastes my time, and it offers me no help in correcting my behavior. I might install this on my personal machine for fun, but as a system administrator I have no business touching this.
Responding to invalid input by actively mocking the user is about the worst decision you can make for discoverability. It's this kind of user interface thinking that can lead to a toolchain being rejected regardless of how powerful or useful the tools could be.
I think this is the flip-side of the startup coin that many people forget about. The quote from the article that stuck out most for met was "But most of all: nothing is more motivating and inspiring than the sense of ownership and self-direction only a startup can provide."
Having decided to walk away from the startup I helped to found, I couldn't disagree more. The three things mentioned by larsberg are three things I'd grown to sorely miss. In particular, no-one is around to teach me test-driven design, and when I'm already putting in 120% during the day, I'm deadened to the desire to self-learn through books and scavenging on the internet.
There are similarities between Facebook and AOL. But one significant difference is the interface. AOL had a proprietary client to access its service network. It made sense at the time, but it was often clunky, had not-insignificant bugs, and generally behaved like an application separate from the rest of my user experience. The client also wasn't nearly as ubiquitous as a web browser (though AOL CD's were so common that we used them as coasters and frisbees).
Facebook itself may be a closed network, but it's a closed network running in an open client---my web browser, which works on all my computers and my cellphone. Since the Facebook team doesn't have to build the end-user software, they can focus on their core competencies of the network and the user experience inside the browser. That takes a lot of the complexity off of them that AOL had to embrace (in my experience, the Mac client was never as reliable as the Windows client, for example).
Facebook could go into the business of making its own client apparatus (such as a branded phone), but why bother? The web is serving quite well for them as a transport medium. I think that AOL suffered badly when the state of the internet became "There are these closed networks, and then there is everything else, and you need two end-user clients to access the two separate systems." As walled-in as facebook is, I still use the same client to access it as I use to access the rest of the web, and hyperlinks inside facebook and the larger web can still interoperate between each other seamlessly. That's an architectural strength that AOL didn't get to leverage.
For the record (though as other commenters have pointed out, this rant on LabView is off-topic): LabView is a very successful tool that is used by many programmers in various fields, not just instrumentation. LabView does have compiler errors and syntax error highlighting; they don't look the same as in a text-focused language, but since G is a programming language, it has its own syntax and errors can occur.
Programming languages are an abstraction. G is just another abstraction. I've used BASIC and C compilers with terribly cryptic, useless errors too; the errors had more to do with flaws in the compiler and IDE than the language itself. If errors in LabView are cryptic or obtuse, I would assume something similar.
I believe that I see your point, and I would agree that the verbosity of HTML leads to sharability, and that is a strength.
But the verbosity is also one of its weaknesses for large projects; it adds a great deal of overhead in terms of keeping track of the tags, especially if the HTML needs to be re-arranged. And with no language-supplied rules for how much whitespace to use or where (beyond "all adjacent whitespace is compressed"), there is too much flexibility for a large team to work smoothly. My usage case doesn't mesh with your example, because I'm working in an environment with version control and multiple developers. The guy using Notepad will be told to get a tab-aware text editor, because his changes will mangle the whitespace in the file and lead to unnecessary noise when he commits.
When structure in your whitespace is already desired (to avoid making your version control noisy), you can leverage the fact that you are structuring the whitespace to make it a semantic element. This greatly decreases typing, makes the code easier to eye-scan, and allows details such as proper closing bracing to be left to the compilation tool and not to the developer. I agree with commenters who have noted that HAML has been proven useful for some developers.
I would categorize both SHPAML and HAML as tools that let you be more productive with HTML.
They are functions you can make up on the spot. That's usually the extent of my explanation.
Surprisingly, most of the people I talk to assume that the "fancy" parts of closures (such as variable value capture and upvalues) are the way such a construct should work and require no further explanation to use them. People who are surprised by capture (and assume, for instance, that the variable will take on the most recent value assigned to it by outside code instead of "remembering the value when the closure was made") get a more lengthy computer science-esque explanation. But I generally find that explanation to be unhelpful if a person can't see why closures are useful; "An anonymous function with some teeth" is often how people I talk to come to closures first, so it's how I let them think about it until the model is no longer helpful.
I can't help but wonder if it's a mistake to try and push widespread adoption of Linux distros in the desktop space. It's possible there's insufficient money to be made in that space--Apple is a hardware company; Microsoft is a de-facto monopoly but rumor has it that they're going to have to struggle to recoup costs on their desktop OS in a world that cares less and less about the details of the host system.
Maybe the right solution for desktop adoption is "If you want to run Linux on your desktop machine, that's neat. But don't think you're going to be pushing Windows off of your neighbor's desktop."
Based on this observation, I find the explanation that Amazon's not interested in spending the money to track state and local sales tax policies to be more plausible.