But to pick nits, it could be argued that you're using md5 as a trial/error "compression algorithm" without including its source.
986 karma · joined December 12, 2010
But to pick nits, it could be argued that you're using md5 as a trial/error "compression algorithm" without including its source.
Back in the day internet connections were so terrible that it was unbearable to do much more than to download a document and display it. Hence, HTTP and HTML. Arbitrary TCP streams existed but in practice performance and latency were very limiting, so nobody cared that HTTP had no support for streaming.
Eventually the underlying tech matured and the standards followed suit. Slowly. But that's the price of interoperability.
I too find it amusing how these concepts keep getting "rediscovered", but in hindsight it's not surprising.
I don't see any reason to put this stuff back into module interfaces when we already have module.exports -- and we can already use http.createServer on localhost if we want a (real, externally-compatible) HTTP interface to a module.
It's shitty communication all around, but how else are people supposed to react?
No, they won't. Bitcoin is built upon decades of battle-hardened industry-standard cryptography. The day someone cracks SHA you'll have a lot more to worry about than your Bitcoin wallet.
The only security problem with Bitcoin is people building insecure systems around it. Which of course has nothing to do with Bitcoin.
But that's a big theoretically. This is almost certainly malice.
And it would almost certainly have gone unchecked if the developer had only hidden the BS generator script on the server side.
But as others have pointed out, that's probably asking too much given the state of this code and given that the main page 403's but they left the BS script serving.
Clickwrap is a blurry legal line, but you more or less are "signing" a license agreement by installing Windows.
And nonetheless the "OEM edition" that you get is potentially very different (license-wise) from the custom-negotiated contract that Dell is bound to when they order two hundred thousand licenses from Microsoft.
This is plain wrong. Microsoft dictates licensing with its customers and it certainly has the right to license on different terms to different customers.
And in fact they do exactly this with OEM's already.
MSFT is certainly within its rights and capabilities to include in their licensing dealings with OEM partners terms that prohibit pre-installing what they deem "crapware". And asking them to enforce this restriction (whether a good idea or not) is nonetheless reasonable.
But obviously Google gets to call the shots with their own services. They only answer to their customers, who aren't whining about this.
As I understand from the article, there is no extra dilution here. The shareholders are simply selling more of their shares.
You're the product because FOSS developers make money almost exclusively through consulting and support. By using Ubuntu you're putting yourself into that pool.
So you could think of Linux distros as a means of producing support customers, and I don't think that's too far removed from reality.
Looking through the docs, the main difference I see is that this is opting for a comparatively heavy-core approach which contrasts with Node's ruthless minimalism + third-party modules.
For example:
-file system access is convoluted with HTTP handling: req.response.sendFile()
-pieces of web framework functionality by default, but no full solution (RouteMatcher)
-integrated WebSockets with a novel but unconventional accept/reject API
-heavyweight SockJS integration
It will be interesting how all of his plays out. And I'm definitely interested in hearing evidence for claims such as
> a run-time with real concurrency and unrivalled performance
For those like me who are curious what the RNG missed, here's the data list:
I take it you haven't experienced the innards of a huge company before.
This is the classic stink of a broken management onion. Maybe I'm jaded but I don't find this kind of corporate bullshit surprising anymore.
It was all interesting and new for the first few months. The team was going through chaotic transitions at the time, so I was shuffled around many challenging projects, all with tight deadlines and technical brokenness up the yin-yang. Luckily for them, this kind of environment was my forte.
Being the workaholic hacker I've always been, I spent day and night slaving away trying to fix everything. Processes, tools, bugs. I broke the daily build a couple of times but surprisingly, nobody gave me heck about it; I was earning a reputation as the new guy who got shit done. In retrospect, I was probably deliberately thrown into the projects that seemed hopeless and bug-ridden because I actually cared about this stuff.
And I realized I was the only one who cared.
The day I received my "Gold Star" (which was actually far more than the $1K the author got), I remember walking by a sign someone had posted that said "Change the world or go home". And then it hit me -- nobody here believed this except me. Everything was a business case analysis. Shit remained broken and bug-ridden because some key stakeholder needed it to work that way on their even more broken systems. Meetings about when to schedule the next meetings. Blame being thrown around abstract "teams", so no actual person had to be accountable when the shit hit the fan. It was all so pointless. Sure, it made money, and I was taking a happy slice. But I didn't care about money. I cared about changing the world.
I deliberated for a day or two, then sent in my resignation.
What followed was several weeks of escalation and meetings with higher-up execs trying to convince me to stay with the company, explaining their idea of where the division was headed. The problem was that everyone literally had a different idea of what that was. It just did more to convince me that this was sinking ship, and they saw me as a plug.
Needless to say, I broke free, and I don't touch Microsoft products anymore. I saw the brokenness from the inside, and I have no faith in the byproducts of their "processes" and managerial wankery.
I'm doing the startup thing now, which in retrospect I should have been doing in the first place. And I couldn't be happier.
I've been romanticizing this kind of dynamic client-hopping execution in my head for a long time, and I even tried to implement it once. The biggest problem is that it's a provably impossible problem to solve! If your language is Turing-complete, it reduces to the halting problem.
You can make guesses (as Opa does) and cover the simple cases with code analysis, but in practice such attempts have devolved into inefficiency and synchronization problems once you start implementing nontrivial systems over fallible interfaces such as the web. It all brings to mind FGCS[1], and how that just didn't work.
So I'm confused as to why we need another language which is like JS but not really, that compiles to Node (which it doesn't, but the author wants to give it a shot).
Sharing server and client stuff in Node is already trivial. So are RPC's (dnode) and realtime streaming (socket.io). And for the sake of security/perf, this separation works very well.
Not to detract from the accomplishments here -- the type inference looks awesome, and I started off as a "compilers guy". But... why?
I've been programming my entire life and I still wouldn't be able to tell you if a Python class follows best practices simply because I don't know enough python.
The problem is that a non-programmer can't quantify what makes a good programmer any more than a non-mathematician can tell who writes the best topology proofs.
I suppose anyone can get a feel for who "gets shit done" and who doesn't, but then you're measuring something much less tangible than "programming".
Doesn't work unless you teach people about security, which is difficult. We have padlocks next to URLs but it's amazing how many people are still willing to send CC info over HTTP.
> SPAM is often in the eye of the beholder.
There's a lot of grey area, but when a particular string has a 99% unread/deleted rate, you can make statistical inferences. An enormous percentage of email falls into this category, and it's why "spam filters" exist and generally do a good job.
Nitpicky, but it actually returns BSON, which is based on JSON but has more data types.
I completely agree, and I think you understand the issue.
I'm just not convinced that any meaningful definition of app-specific "security" can be achieved concurrently with the kind of simplicity that underpins your value prop.
If I have to go and cook up logic validation, ACLs, and who knows what just to make sure my app isn't trivially broken by anyone with a JS console, aren't I basically doing the server-side programming that your pitch says you're trying to eliminate? Except in a less familiar fashion?
I'm not saying this is unfixable; I hope you have novel insights, and I want to be wrong. But I've always been sceptical of the free lunch.
I know exactly what you mean, because that's what I thought a year ago. I was going on and on about this to everyone. Mea culpa.
Then I actually tried node and learned the functional side of JavaScript (I don't mean the semantics, which are very simple; I mean powerful LISPish design patterns). Now I don't think about callbacks anymore, because I have a functional toolkit that mostly hides them.
You say asynchronous coding makes simple algorithms annoying to write. So let's have an example. Read two files -- in parallel -- trap I/O errors and warn about them, otherwise merge and sort the files by line, write the result to a third file, and warn about I/O errors there as well. Simple enough?
My solution is 8 lines, formatted. It was very pleasant to write.
fork(
['lines.txt', 'lines2.txt'].map(function(name) {
return fs.readFile.bind(fs, name);
}),
check(console.warn.bind(console), function(a) {
fs.writeFile('linesOut.txt', a.sum().split('\n').sort().join('\n'), check(console.warn.bind(console)));
})
)
If you've seen enough JS to deduce what the lib definitions for fork() and check() might be, then this code will seem obvious -- almost trivial. Otherwise, you will probably claim shenanigans or 'spaghetti' because it doesn't look like insert favorite programming language/framework here.So it saddens me to hear people whining about this aspect of node -- partly because it recalls my own naivety, and partly because I know from experience that they're missing out on something great.
> "If the rewards go down over time, eventually it won't be profitable to mine bitcoin." > Yes.
No. Because the other part of mining is that you get transaction fees for it. Mining isn't a luxury, it's necessary for the network to function (otherwise double-spending isn't prevented). So as time goes on and less coins can be made by mining, transaction fees will increase to compensate and keep mining profitable.
> Also, computational power gets cheaper with the passage of time.
But, mining does not get cheaper because the network (by design) adjusts the mining difficulty to keep the incoming block rate constant. So in relative terms, mining will never become significantly more or less expensive with time.
> The largest caveat I see there is the part about more of them being demanded.
Not a problem. This is solved because bitcoins are infinitely divisible (up to 8 decimal places currently and this can be extended if needed). So if there's more demand, the value of coins increases but you can still trade them in whatever meaningful quantities you like. This isn't something you can do with cents, but you can trade one millionth of a BTC just fine.
On the one hand, it solves the problem of seeding the network with coins. Otherwise, how could you kick this off in a fair way?
Secondly, mining "solidifies" transaction blocks, which acts as transaction verification for the network. Mining basically acts as prevention of "double spending" of coins.
Finally, mining keeps the money supply scarce (necessary for any currency) because despite everything just being bits, you can't just fake new coins without expending enormous amounts of computing power -- you need to prove you've done the work by solving hashes.
The bitcoin wiki has pretty good technical explanations of all of this.
http://news.ycombinator.com/item?id=3782072
and I'm trying to get over the dissonance between what you said there and what you're saying here.
The only person to lose karma is the one that gets downvoted.
And as amazing as Stripe is, getting working Bitcoin payments is even easier: generate key, show to your user, and query your daemon for payments.