386 karma · joined April 29, 2014
Anyone take a guess what those might be (honest question)?
In the past SIMD has been the primary way to accelerate audio and graphics related compute tasks, but with WebGL and shaders, JS users already have a very powerful vector processing unit at their fingertips.
If they're not old hat, and so on, and their business pays more taxes, why not branch off into Uber clones? If Uber does it, they can too.
Uber's drivers are in a similar position.
So what do we have here? Another example of pitting poor against poor, for the interests of one group of rich against another, emerging, group of rich.
I almost admire the skillful orchestration at play here, although probably I shouldn't.
A modern computer does more operations in a single second, than a small country can buy lottery tickets in a lifetime.
Many wildly unlikely things become quite likely with computers.
I'm slightly sick of these silly public letters. Why the hell either Netflix or said telcos feel like they need to bother the public with their internal problems, instead of solving them privately like adults?
This is not about net neutrality. It's about who foots the bill for upgrading the network to handle the capacity that Netflix users need.
Meter the damn traffic and let Netflix (and other heavy) users pay the telco and be done with it. God damn.
The category you define may be seen as arbitrary, first because existing filesystems have not stopped evolving. HFS, NTFS and so on have been significantly improved over time, including after 2005.
ZFS is a categorically different concept than said examples, in that it's distributed.
But the file system has not been shown to be the best (or let alone only) way to have distributed data, you can easily put that at a higher level, and retain the flexibility of defining your own protocol with the consistency, consensus algorithm and other properties you precisely need.
Why solve this at the file system and lock yourself to a single system-wide way of doing it, versus have the best solution for each part of the system? I feel like it causes more troubles than it solves.
People who would've found ZFS interesting on its own merit won't read about it, and those who are interested in Git would.
Uhm.
> "I’m not sure of the stability on Mac at this time. Using ZFS as a root file system on Linux is still slightly problematic at this moment."
And Windows? Never mind.
Ok, so the author wrote an article called "Who Needs Git When you Got ZFS", and then in the body of the article the conclusion is more like "Who needs ZFS When You Got Git".
ZFS does a bunch of cool stuff in a generic way as a file system, sure. But we already have apps doing it better in a way specific to real-world needs (i.e. Git), on more platforms, and I don't have to fear if I'll corrupt my boot volume if Git is buggy.
The best that can probably be done is to create a new language which is, say, a clean subset of Perl 6 and call it something new, focusing the message on how readable and intuitive it is.
We're not special. Like everything else in the world, developers follow Sturgeon's law.
I sympathize with the idea of creating a language mostly defined as a library of itself.
It's nerdy, it's neat, it's minimal, it's very Lattnerish.
But it has a fatal flaw: it assumes people will use that feature set in an intelligent, restrained, minimal way. For good.
And let's face it. Most of us devs are fucking morons. It took people only a few days to start abusing it. I wonder where we'll be a year from now.
And funny enough Objective-C is taking this quite seriously, being a very verbose language (the new Swift language also keep the verbose method names, enums and properties).
While Perl is exactly the opposite. There's a reason people jokingly call it a write-only language.
It has real implication on its usage. You use Perl for one-off scripts you intend to forget and maybe delete after you run them a few times.
While CPAN happened, I wonder how much Perl was an obstacle in multiple people joining to work on a single library (versus multiple people just downloading it and using it, big difference).
And the problem with that is that there’s just a tremendous amount of craftsmanship in between a great idea and a great product. And as you evolve that great idea, it changes and grows. It never comes out like it starts because you learn a lot more as you get into the subtleties of it. And you also find there are tremendous tradeoffs that you have to make. There are just certain things you can’t make electrons do. There are certain things you can’t make plastic do. Or glass do. Or factories do. Or robots do.
Designing a product is keeping five thousand things in your brain and fitting them all together in new and different ways to get what you want. And every day you discover something new that is a new problem or a new opportunity to fit these things together a little differently.
And it’s that process that is the magic."
~ Steve Jobs
This is why Apple doesn't make "vision" videos now, and it didn't during the Jobs years. During the period they did, they had serious problems in shipping any of the visions they have shown the world.
Microsoft is a bit like that. They know where the world is going, and Bill Gates himself knew from the very start where the world is going (short of a brief period where he conveniently ignored the Internet will happen). But they thought the fact they knew, that they had this cool idea and projection of how things will happen was giving them enough advantage. Nope.
It's risk-free to ship vision videos. They're like free T-shirts. There's infinite demand. But when it comes to shipping products based on them, most people can't live with the compromises and risk-taking a real product requires in order to ship.
With a new product you can't just look at the competition and confirm that what you have will work. You're on your own. Do you have the guts?
I'm not saying abandon Python for Java, I'm saying if you'll optimize Python, first optimize single-thread Python performance, before we get to parallel processing, because extracting performance out of parallel is hard, while languages like Java (and JavaScript recently) show they there's plenty more to be gained yet from that single thread.
I've seen 4 year olds understand English better than this.
There's an obvious disconnect between the complexity of some statements it makes, yet how disconnected from the question they are.
No human is simultaneously unable to process a question, yet make statements so complicated.
In other words, it feels pretty much like it's copy-pasting someone else's responses from a database.
Rewriting the original program in Java would make the program about 100 times faster... on one core.
Now let's see. We deal with hacked Python, with complex error-prone thread synchronization code in Python for 8x gain, or grab the 100x gain in a single thread in Java?
While I don't mind Python getting faster, threading should be the last thing to try before everything else is exhausted in order to make Python run fast in one thread.
The reason most of the PHP code is crap is not because PHP makes it impossible, but because a popular crap language with a low initial learning curve tends to attract a lot of crap programmers.
I'd actually say PHP has only gotten better over time, and every new release is better than the previous one. But you have a crap base (which PHP maintains religiously as not to break BC), and a crap community, and the software they write is crap. It's just what it is. The odd exception here and there.
You can overcome a horrible language, but that's not the problem (plus I'd argue PHP isn't the worst out there).
No, it's the crappy community around it. It's hard to overcome the horrible low quality PHP code libraries people write in PHP, because writing everything from scratch isn't practical in any language these days.
Composer is great and all (except for the lack of package signing, hey, who needs security, right?), but all Composer means you can install other people's PHP crap code more conveniently.
And while I wouldn't call the people behind Symfony "crap programmers", that framework is horribly overdesigned, slow, and comprised of an endless Inception of leaky abstractions.
It shows that a programmer can take all their experience and knowledge of design patterns, best practices and what not, and write a complete piece of turd.
Anyway I better run, because the modding of my posts here is showing I've angered the PHP fans.
So as I said I've been doing PHP. And I have yet to see one of those unicorns in PHP-land. In fact, my first gut reaction was that you're being sarcastic up there.
I mean, sure, it's impressive that this VM is 7 times faster than stock PHP, but Java is over 100 times faster than stock PHP.
What is the gain here? Not having to go out of you little shell and learn a new language?
Well the SQL server won't actually run an invalid query, so what's your point?
I'm not afraid of invalid queries. I'm rather afraid of valid queries like these:
"DELETE FROM Table"
Because depending on how abstract your ORM is, it's far easier to run something you really don't want to run on your SQL server. But at least it'll be valid, hey!
You both talk about the perils of dynamically building queries, yet proclaim the benefits of static syntax checks. You can't "statically syntax check" a dynamically built query. Even with ORMs. So pick one. Either you're building it dynamically, or if it's static there won't be "string pieces" to worry about.
Most of queries are defined statically: a query with several anonymous (?) or named (:foobar) parameters to insert literals. So none of those scary string concatenation problems even occur.
Regarding stray commas... please: listOfIdents.join(','). It's not rocket science. Plus, I'm not necessarily advocating you use string functions to build queries, there are many small helpers to be had when you need to build a complex query, but the point is to know when to stop, and not try to completely hide the resulting SQL from the user of such libraries.
It's one thing to use a query builder for those rare complicated dynamic queries, but an entirely different thing to lock down and hide the connection and have your hands at the mercy of an abstraction layer for your every query.
If you can't control when and how your database gets called, if you can't control select locking, and transaction isolation levels, if the vast majority of its functions and syntax is out of reach, you can only do the most basic of CRUD operations on SQL.
It's just ugly that we have a complex piece of machinery like a modern SQL database, with all those advanced querying and MVCC features packed in for people to use them in order to build fast and safe applications, and watch them use it like a little more than a file system.
It's like buying yourself a million dollar supercomputer so you can play Solitaire on it.
It's true, they don't have to be useless.
The problem is that people who end up writing most of those libs are:
1. People who have very superficial knowledge about range of features, semantics, and algorithms behind SQL.
2. People who are motivated by an irrational yucky feeling about code in strings (as if their Lisp/Python/Java/etc. source isn't just code in a string itself).
3. People who are typically very averse towards learning new technologies. They are blissfully unaware of all the ways they can persist their objects without "mapping" them. They know in depth and favor one application language, and they've stored data in SQL a few times, so let's do everything in SQL, because learning is hard, but writing abstractions is cool. It feels like an achievement.
There's also the usual for ORMs display of superficial understanding of transactions with a "with-transactions" global switch, as if transactions are something you can just sprinkle on top of your finished product like an exotic condiment, and get greater goodness. This is not how SQL works.
Even the "fine-grained" transactions interface doesn't expose common-place and crucial features such as transaction isolation levels, store points, selecting for update and lock in share mode. If you're reading this and thinking "this guy's just listing arbitrary niche features no one uses", then you have no business using or, god forbid, writing ORMs, because the first time you get serious traffic hitting your database you'll end up with inconsistent data state, and have no clue how it happened (blame MySQL? Sure, blame MySQL).
SQL ORMs feel oddly anachronistic in 2014. People have largely moved to persisting objects with databases built for persisting objects, leaving SQL databases to be used where they work best - for relational data queries, without quirky layers in between caller, query and results.
Plus... and I realize maybe it's just my bias against ORMs, but "an ORM for Common Lisp" reads a bit like "we ported AIDS to heaven". Just because you could do it, didn't mean you should've.
But Apple is not most phone vendors.
If the user has an iPhone they can buy the Lightning version, and if they use an Android phone, they can buy the micro USB version.
But chances are the user won't be switching the card reader from one device to another all the time.