HNHacker News
TopNewBestAskShowJobs

drewcrawford

4,834 karma · joined June 13, 2008

AI tooling and systems/SDK engineer · Rust, WebAssembly, Swift/Apple platforms · wasm-bindgen contributor · building AI Bot Mafia (botmafia.games) · sealedabstract.com · github.com/drewcrawford
submissionscomments
drewcrawford··on Add .txt As the Extension of Your Readme file
> the solution then to me is ditch backwards compatibility.

Backwards compatibility is a visible problem, but it isn't the True Problem with creatorcodes/metadata. The true problem is that a world with metadata is an unstable equilibrium, because what if just this once we get it wrong.

* Consider the case that the file's author got it wrong

* Consider the case of Python and RPython (or .js and .json, or .txt and .md) where a file can belong to multiple classes. Further consider the case where a system has a Python interpreter but not an RPython interpreter installed (or a JavaScript interpreter but not a JSON parser, or a text editor but not a MarkDown editor, or...)

* Consider the case where a document was saved with Excel 2013, but just happens to only use Excel 2010 features, because who really cares about whatever the heck they add in each new Office release

* Consider the case of a container format, like mkv or mp4, that does not alone completely describe the format of the data it contains

* Consider the case of sometimes-interchangable formats like m4a and m4b, mp4 and m4v, etc.

* Consider the difference between a storage format (.sqlite3) and the data that it contains (.localstorage, Firefox/Profiles/places.sqlite, ~/Library/Mail/V2/MailData/Envelope Index)

* Consider the case that that one day somebody just wants to make a "monkey-fighting file without filling out this monday-to-friday questionnaire" and either the "no really, it's a file" creator code is accepted by the International Body of Creator Codes, or it isn't and so there are five incompatible implementations.

As soon as you tolerate any of these (and probably the list is a lot longer than this), we are right back where we are now: trying to guess what kind of file it is by poking at it with a stick. Backwards compatibility is a red herring.

drewcrawford··on Add .txt As the Extension of Your Readme file
> are so badly designed

Why are they badly designed? There are a huge amount of bright OS hackers in the world, and a huge amount of mindshare on the problem. When the culmination of all this effort continues to be hilarious[1], I can only conclude that the problem is less tractable than we expected.

And in fact, that is what the people who work on the problem say[2]: that it is not tractable.

[1] http://en.wikipedia.org/wiki/Bush_hid_the_facts

[2] http://blogs.msdn.com/b/oldnewthing/archive/2007/04/17/21583...

drewcrawford··on Starting a consulting business. Can I get some feedback on my new site?
Relevant experience: I am you, except for native iOS dev.

This website is written for another software developer to read. Your primary customer will be a larger (than you) Ruby/Python shop that has more work than it can handle. You will be working closely with other, more trusted-by-management software developers who are sort of vetting you, and may be trying to angle for a hire. These companies are just large enough that they have better lawyers and better paperwork, so disputes can get hairy. Also, they will be protective of the relationship with the ultimate customer/client, so the success of the project really hinges on how well the people above you have captured the requirements. That said, the sales process will be easy and familiar, because you have a career of experience already selling yourself to other software developers.

Is that the customer you were shooting for? If so, good job!

drewcrawford··on Rework git core for native submodules
This is one of the nicest disagreements I have ever had. If we don't already, we should compare notes and find something to work on together, because when two people can disagree but still understand each other, that is where you make progress on complex problems. :-)

> Yes but .gitignore only configures your git client, the gitsubmodules say something about the repository instead.

This feature is often used to configure the repository, and I in fact use it that way. By way of example, https://github.com/new operates under the assumption that you use .gitignore to configure a repository. Perhaps it is best to say that config files offer flexibility in this dimension, whereas a link file is more rigid.

> It could even be delayed until there is another compatibility breaking change.

I believe that perhaps the discussion on the point of backwards incompatibility has been framed in a way that is nonproductive. Of course, once one has decided on a course of action, it is proper to consider how to reduce the impact of that decision. I agree with you that there are a wide variety of harm reduction strategies available here.

But these inquiries only become relevant once one has decided that the patch is in general an improvement in some dimensions. As an outside observer, I do not see an improvement.

I can see the logic that if it is true that git-add-and-friends have omitted support for submodules on the basis that such support is difficult, this patch could solve that problem. But I have not been convinced of the premise; there is no citation of the people who maintain the UI tools making claims of difficulty. Furthermore, Junio seems to argue at least that add's behavior is by design, I do not know enough about it to know if that is a sensible design, but it does suggest to me that the problem with UI tooling is not a function of implementation difficulty, but there is perhaps some design or ideological reason for the behavior of these tools that explains the state of them today.

The other problem that I have is as follows: if I accept the premise that the trouble with git-add is a matter of implementation difficulty, it seems to me that the trouble can be resolved at some other tool layer rather than in the FS proper. So if the hypothesis underlying the patch is correct, it seems to me that one should adopt the implementation that doesn't break compatibility over the implementation that does.

It is unfortunate that the matter of backwards compatibility was raised early and vociferously in the thread, because as you have pointed out there is a lot that can be done about backwards compatibility that doesn't address the real merits of whether the idea is good or bad. (Although I can understand why compatibility would be at the top of any maintainer's mind.) Perhaps this exchange between Junio and Ram. is an example of two people being far enough along their own lines of inquiry that they are having trouble making any sense of one another.

drewcrawford··on Rework git core for native submodules
There are a complicated set of problems that are preventing us from understanding each other. I am going to do my best.

> weird configuration file

One of the disputes here is that the maintainers are of the opinion that config files are actually good, on the face of them. They point to examples of well-settled uses like .gitignore to claim that config files are The Git Way.

It may very well be that configuration files are in fact weird, or are weird in this particular case, but since the convention is and has been for git's history that config-files-are-good it would require a well-reasoned essay to move the needle of discourse on this subject, not just to use "they are weird" as a claim to prove something else.

> This 'True Rejection' is essentially rejecting the merit of refactoring code.

I don't want to get into a big meta-meta flamewar here, but there are many people who do reject the merits of refactoring working code, for some definitions of "refactor", for some definitions of "working", and this has been the subject of many popular essays, most notably Spolsky et al. This is another place where moving the needle of discourse would require writing a well-reasoned essay that quotes the appropriate authorities, and it is not sufficient just to appeal to a particular view of the merits of refactoring as a claim to prove something else.

> Hardlinks and symlinks are both features in their own rights.. [this] is a superficial change.

This is another one of those thorny semantic problems that are preventing us from understanding each other. There is a sense in which it is superficial, and another sense in which it is a substantial change. If you are using "git add", or are implementing it, it is a superficial change. If you are writing subtree-merge or git-submodule or something that really needs to understand the storage of submodules, it is substantial.

And so they are both features in their own right, in the sense that: git-add-and-friends will want to access things with a certain pattern, and git-submodule-and-friends will want to access things in a very different pattern. This is why I suspect the solution here is to have two distinct APIs, that access the same underlying storage mechanism. And if it makes sense to continue to support something very much like the old API, it probably does not make sense to redesign the FS to look like the new API.

Of course, there is a lot of resistance in the git community to have two ways to do the same thing. So when I say "I suspect the solution is to have two APIs" I mean only that it would address most of the objections raised thus far, not that it would actually be implemented in mainline.

> Everything the current submodules do could be achieved using the proposed solution. (As he repeatedly has to make clear to Linus and Junio)

And as Linus and Junio have repeatedly made clear, merely doing everything the current implementation does is not within a few galaxies of meeting the burden for breaking FS compatibility. The compatability-break burden is extremely high.

drewcrawford··on Rework git core for native submodules
I am not a git maintainer, but as someone interested in improving submodules I can try to summarize the thread.

Submodules are difficult to use in practice for a wide variety of reasons. There are serious, complex proposals that have made it into git-contrib to build a "better" submodule, but for various reasons these have produced systems that merely make the tradeoffs in a different way that some people prefer.

This is not like any of those proposals. His problem is that "git add" "git diff", etc., don't "understand" submodules. It would be as if ls, cd etc. don't "follow" symlinks, so that you had to navigate to the correct directory yourself before you can use standard unix tools.

This is a serious problem, but his solution is essentially "we should use hardlinks instead of symlinks". That is, he wants to take the code that understands submodules out of the individual tools, and pop them in the filesystem somewhere where they are "shared" among more of the tools and don't have to exist in any of them.

There are many objections to this proposal. The chief one seems to be that this does not seem to directly address any particular problem. I think Ramkumar perceives that the reason git add/diff/rm don't support submodules is as a metaproblem "it is too hard to add submodule support to arbitrary tool". Whereas the git maintainers are saying "It is possible to add submodule support to arbitrary tool." So that's the initial standoff.

Another problem is that this requires a filesystem change, and that is essentially the most stable part of git that breaks incompatibility with other versions. If you read Linus's rants, you know that he generally applies an enormous amount of scrutiny to breaking compatibility. And so from his desk, you would need not just one clear benefit, but an overwhelming number of them, to break the contract like this.

But what I suspect is the True Rejection here is that this will pan out like all the proposals before it: to be different, but not strictly better, than the current implementation. To return to the POSIX analogy: we have both symlinks and hardlinks, and which one is better depends on what you are doing, there is no "one true link". If you replace all the symlinks with hardlinks, I think you will run into trouble with the hardlinks too.

Finally, it is unfortunate that the flamewar is about the monolithic patch rather than about some of the principles that led to the patch. I think Ramkumar has had (at least) two very good insights: that "git add" and friends should understand submodules a lot better than they do, and also that they should have this understanding by way of consuming some API that understands them rather than incorporating separate code for submodules into every tool. These strike me as a concrete improvement over the existing system, and I wish that the energy that leads to huge unusable patches like this could be redirected into usable ones.

drewcrawford··on Busyness is Not a Virtue
This is a fine article if you already believe that busyness is bad. The trouble is that busy people are, by definition, people who think being busy is a feature not a bug.

For example, we can spin the wheel and play bug-or-feature:

> And when you start sounding like an appliance, it makes it hard to connect with you.

Bug or feature? Depends on your personality, depends on who's connecting with you.

> This is one of the easiest outs for stuff I don’t want to do.

Bug or feature?

Another sentiment I see in TFA and the comments is that saying "I'm busy" is a euphemism for "I don't care about you" so people shouldn't say it. But this analysis assumes that the heaviest rock is for a person not to be rude. I suspect that in many cases that if you remove the method for a polite brush-off, you could get an impolite brush-off instead. Nothing has been done to address the underlying motivation behind saying "I'm busy".

If you find yourself in the author's shoes being frustrated by how other people are too busy for you, I might recommend reading some sales books and figuring out how to make proposals that are more agreeable to others. Writing a blog post about how other people need to change will not help you solve that problem.

drewcrawford··on Linode NextGen: RAM Upgrade
The barrier-to-entry on AWS is in fact infinitely lower than on Linode:

http://aws.amazon.com/free/

The ongoing TCO of AWS is much higher than Linode, of course. But that's precisely my point: you want to capture customers at birth, incubate them into adulthood, and then charge them a lot of money now that they can afford it.

drewcrawford··on Linode NextGen: RAM Upgrade
The problem is that most projects make (possibly their only) hosting provider decision from a position of being unprofitable.

Thus when you segment the market by "people who can afford $20-100/month", you are also segmenting the market by the correlating variables "people who are mad at their current host" and "people who can spare several days to migrate their infrastructure".

As a member of that class who migrated to Linode, I can attest that the size of that market is nonzero. But I can also attest that a great many projects start and remain on AWS and lowendbox where the barrier to entry is much lower, and even as a satisfied Linode customer I continue to start and continue to maintain many projects in those environments.

drewcrawford··on ZFS on Linux 0.6.1 released: Ready for wide scale deployment
> The only time disk encryption is valuable is when the machine is off or the disks are being transported.

I'm thinking about the case where you have a computer in the home or office environment, e.g. the burglary attack vector. It's not just notebooks that get stolen.

I'm also considering the corporate or government espionage vector, where you have a reasonably skilled on-site attacker trying to read or modify the disk contents. In this case you are typing the keys in on boot, and you either ignore the RAM extraction attacks (which are difficult to execute in practice for non-academic attackers) or you can mitigate them by storing in L1 cache and so on.

Datacenters have unusually high physical security, and in addition I don't generally store highly sensitive data there (my work doesn't involve PCI compliance etc.) Whereas I do have PCI-level data about myself on my own computers.

drewcrawford··on ZFS on Linux 0.6.1 released: Ready for wide scale deployment
The big thing missing from the OSS implementations that Oracle 11 has got is FDE.

It's possible with dmcrypt and LUKS, but you void most of the reasons for using ZFS. encryptFS is also a possibility, but it's both much less secure (an attacker can run ls) and also drops a few ZFS features like dedup.

Meanwhile, Solaris 11 has FDE that actually works, and there seems to be no serious FOSS effort either to reverse engineer their work, or to design something better.

In 2013, no software developer should be storing things without FDE unless they have unusual physical security measures. That makes FOSS ZFS a non-starter for most of the people who would use it.

drewcrawford··on Frustrated with iCloud, Apple’s developer community speaks up
Core Data does look pretty awful if you compare it to an arbitrarily awesome imaginary library.

All you're doing in this post is phrasing problems that are fundamental to data storage in core-data specific verbage, and calling them a grievance against Core Data. But they're not. There's no other magical solution that somebody could write that does it any better.

For example:

> Since the abnormal objects are spread throughout your code, and they're tied to non-thread-safe NSManagedObjectContexts, concurrency becomes rather difficult.

Concurrency is difficult independently of how you go about it!. The fact that concurrency continues to be hard is not Core Data's problem. The question is, is it easier or harder to use Core Data's primitives to achieve concurrency than it would be doing everything from scratch? I think it's easier. But Core Data against magic is not a fair comparison; a fair fight is between [hard problem with off-the shelf tool] against [hard problem without any tools].

Or this one:

> Since Core Data objects are abnormal objects, one must produce a considerable amount of boilerplate just to define new model objects.

Again, the choice is not between [boilerplate] and [no boilerplate]. As you've correctly pointed out, the mapping between on-disk and in-memory is a hard problem, and the solution will involve writing code that bridges the two worlds. The question is, is [boilerplate that's defined over 10 years of Cocoa convention] superior to [boilerplate that I invented from scratch to solve my problem]? I'm going to claim, 90+% of the time, that you want door A. Perhaps you really do want door B occasionally. But there is no door C with a boilerplate-free existence.

> After using it myself for a large project and struggling with all of these issues (and more), and watching another team do the same on their own project, I'd never make use of it again.

And as a person who has worked on probably over two dozen Core Data applications, I would not touch any codebase that had this philosophy with a ten-foot pole. Concurrency, boilerplate, memory/disk impedance mismatch are the same problems wherever you go. It is perfectly fine to say "I don't like using CD syntax to solve these problems" as a personal preference. But it is another thing entirely to say that CoreData is "broken" because one is either unable or unwilling to solve these same problems we solve every other day of the week in a slightly different syntax than one is used to, particularly when that syntax is generally accepted as a platform standard.

To use an analogy, it would be very poor form to try a Ruby project or two and conclude that ActiveRecord is terrible and that it "falls over" once you step outside "simple use-cases" and that you would never do another Ruby project unless you were emitting postgres queries by hand. There are not a lot of Ruby developers who would sign up to work on that project.

drewcrawford··on Reinventing the Airline Industry
> Think about how terrible a bus is, and how most of us use cars because it's an immensely better experience.

Yeah but most of America is basically stuck in one at least twice a day, so you have a massive demand to make them comfortable. Whereas with a plane, your middle-class American gets in one 2-3 times a year and is willing to suck it up.

In order to be comparable to cars, you not only have to hypothesize an order of magnitude shift in cost to match cars, but also an order of magnitude shift in demand to match cars. While I fully admit that there is that sort of demand in limited markets (for example, commuting programmers to the valley), these markets are not on the same chart as car demand. I do not really see what could possibly motivate ordinary people to travel 600 miles twice per day.

Meanwhile, as you've been trying to leapfrog the car market, it has not remained stagnant. If you are a knowledge worker, a self-driving car is an effective substitute for flight, since the impact of additional passive travel time is negligible. (Even non-knowledge workers need sleep, so it will be of benefit to them too.) At the distances I generally travel (regional US), an uninterrupted block of 8 hours in a vehicle is actually preferable to a 2-hour block flying, so I would actually pay less to travel by plane.

drewcrawford··on A parable about problem solving in software development
This was a very strange story to see, because my life is almost a mirror image of the author's. Except my harebrained ORM-powered RPC message-queue rest-was-too-slow experiment is working so far. Consider this a counterstory.

The author lists two problems with the old system: code re-use and speed. But he doesn't really say how the solution is going to improve on the status quo, other than just by throwing programmers at the problem and hoping they improve on REST. Now maybe they had clear solutions and maybe they didn't--but the post doesn't say.

I sympathize with the author's problems. But I also started with specific clarity about the problems and strong solutions about how in practice to improve. For example, the speed problem for my use case was very specifically that latency was too high. Latency was too high specifically because of fast-lived connections, the SSL handshake, and TCP overhead. So I designed a system very specifically around long-lived connections, a non-SSL based crypto layer, and UDP. It's a full order of magnitude faster; it actually changes the way you use network calls because they are so cheap now. As time has gone on I have extended the speed improvements, but it was way better than the status quo on day one.

Similarly for code reuse, I had a very narrow set of problems surrounding reusing across client/server only very specific parts of very specific classes. As a result, rare is the change that requires moving client and server in lockstep. I don't think I did it in the month of February. And the productivity gain was great from day one.

I am the first to admit that I've had some bugs in the complicated pipeline that require Deep Magic to comprehend. I have one or two open right now. But, if you have a 10x runtime improvement and a 3x development improvement, spending a day or two learning the ins and outs of Deep Magic is not the worst thing you can do.

I think the moral to this story, if there is one, is don't fly by the seat of your pants. Don't write a system that is faster, write one that is exactly 92.56% faster by the application of two specific techniques. Don't write an RPC system that eliminates the barriers for sharing arbitrary code, write an RPC system that eliminates two particular barriers for classes that meet three known requirements that most people in the organization are annoyed about. If you don't know where you're going, you will never find out if you get there.

drewcrawford··on A Mac Pro Mini
As a person who used a hackintosh as a primary development machine, the problem is more that it is difficult to keep a hackintosh up to date, and due to Apple's aversion to backwards compatibility, this poses a significant problem for generating executables that will be accepted by a toolchain released 30 days ago.
drewcrawford··on (Presumably) Apple engineer comment on Lightning AV adapter design
Well, there was a big whoop about the thinness of the connector when they announced it being necessary for very thin devices. Can we manufacture non-brittle connectors with center pins that are 1.5mm thick?
drewcrawford··on (Presumably) Apple engineer comment on Lightning AV adapter design
Still not an EE, but as I understand it, if you are creating your own controllers and you also control how the cable is shielded, pin count doesn't matter much except for power.

Traditionally it's been easier for most hardware makers to double the pin counts than to build controllers that run at twice the clock rate and also make everybody use fancy cables. But traditionally not everybody has PA Semi across the hall to build chips for you and years of experience selling $50 cables to consumers via direct retail. So I'm betting that the usual economics of the consumer data interface market don't apply to Apple.

drewcrawford··on (Presumably) Apple engineer comment on Lightning AV adapter design
> If they can't even do 1080p lossless right now, they are in much deeper trouble for the future.

Let me try and shed some light on this mystery. Consider this rumor. Also, I am not an electrical engineer, so I may be talking out of my ass.

As best as I can tell, Lightning is not (yet, anyway) a real protocol like Firewire, USB, etc. What it is so far is USB with a different connector and some negotiating chips.

So when connect your lightning-USB cable to your iPhone, your iPhone squawks and says "What is this?" and the cable says "I'm USB". The iPhone then sets its pinout to USB mode and off you go.

What's so great about this, why not just use USB? I think the secret sauce is that Apple wants to surreptitiously invent new pinouts with faster data rates, without consulting any standards bodies and having to rally industry support on TVs, computers, et al. They just build some new controller to push Lightning at 2Gbps+, put it in new iPhones, and build active cables that spit out HDMI or UHDTV or USB3 or whatever it is the kids are doing these days. The active cables degrade gracefully for hardware running at the slower data rate.

What I think you are seeing right now, is the dry run with the off-the-shelf controller. Get manufacturing ramped up. You need this to plug your phone into a computer anyway. But it's just the tick. Wait for the tock.

Now the only thing that puzzles me is why they settled on 8 pins, when USB3 is 9. Obviously they wanted an even number so you could plug it in every which way, but you would think stepping up to 10 pins would let them use off-the-shelf USB3 controllers instead of USB2. Maybe they can do USB3 on 8-pins somehow, or maybe the tock will be ready fast enough that it's not worth it.

Further reading: http://brockerhoff.net/blog/2012/09/23/boom-pins/

drewcrawford··on Rap Genius (YC S11) responds to Heroku’s call for ‘respect’
> this is the kind of performance we're getting out of a single Heroku dyno on a dynamic page with no caching

If you read the original article[0], you would know that this is a problem that only affects apps with large number of dynos.

I have not done queuing theory in a long time, but my initial sense is that the math on this one will be generalization of the birthday problem [1], which is Wiki-notable on the sole basis that the probability of sharing a birthday (or in our case, the probability of queueing a request) is far, far higher than ordinary people anticipate for N above 23. Assuming I've captured the essence of the problem correctly, you would see a sharp drop in performance when you start to saturate about 20-30 dynos.

Given that there's an entire Wikipedia article on the sole basis that the behavior of these mathematical functions are nonintuitive, I think it is pretty fair to give RapGenius a pass at being surprised by the math as well.

[0] http://rapgenius.com/James-somers-herokus-ugly-secret-lyrics [1] http://en.wikipedia.org/wiki/Birthday_problem

drewcrawford··on How to calculate your hourly rate
> It's your responsibility as a consultant to pick your clients carefully.

In the mobile industry, (and the web dev industry as well), the market functions on the basis that 90% or so of projects won't make the return, and the industry is carried by the 10%. In some sectors (consumer) this is higher, in others (B2B) it's lower, but it's about the right frame of reference give or take for most projects that ordinary people on HN perform.

Now if you are a professional investor a 90% failure rate is easy because you just do 20 projects at once and you're fine. Similarly, if you are a large size consulting shop you're basically an investor with other people's time, so same story, just do 20 projects and 2 or so blow it out of the park and the rest are a waste and you get the quarterly bonus.

However, if you're an individual or a couple of guys in a broom closet somewhere, 20 projects is a very long time. Unless you are independently wealthy and can just float many years of work, you can't make any money. And if you are independently wealthy, you have a higher chance of success becoming the large consulting shop or being a professional investor (or starting your own startup) than you have doing lots of free projects for other people.

So what you are saying is nice in theory but for the average mobile/web developer thinking about contracting they don't have the volume necessary to assume the risk that the market ordinarily bears for development projects.

drewcrawford··on Msgpack can't differentiate between raw binary data and text strings
Simple, yes. Efficient, no. For example, msgpack can encode a 2-byte binary blob in 3 bytes. tnetstrings takes eleven bytes, for no appreciable benefit in decoding time.

Also there's this gem:

> You are not allowed to implement any of the following features: UTF-8 Strings

glances at title of article

drewcrawford··on Msgpack can't differentiate between raw binary data and text strings
For me the advantage of msgpack is simplicity / efficiency in parsing the response.

If you are decoding a JSON string, you run over the string twice: first to search for the terminating quote character so that you know how much memory to allocate, and second to copy the string.

Whereas with msgpack, it's more like pascal-model strings where you know the length of the string up front; you can do it one pass. You also get some structural hints that make more of the parsing a parallelizable problem, whereas with JSON it is very difficult to get any benefit out of more cores.

This may not make any difference if you are serving up an API request or three to x86 computers with broadband, but they make a lot of difference if the data you're working with is large relative to the bandwidth or latency of the pipe or the CPU power available on the other side of it.

drewcrawford··on Msgpack can't differentiate between raw binary data and text strings
Bikeshedding at its finest.

I ran into this issue a few months ago, on a cross-platform project involving four languages that each take a distinctly different view about strings from the other three. Although this situation is a common objection to supporting strings in the issue thread, it took just a couple of hours to extend msgpack to support strings in a reasonable-enough-for-me way on each platform.

The proposals in the thread are a lot better than mine. And I suppose it's pretty antisocial / arrogant for me to just roll my own implementation without consulting anybody. But in three years[0] of talking about the problem, nothing had gotten done. Meanwhile, my code shipped a long time ago.

I do this a lot--fork people's projects to solve my problems and don't merge back changes--and I feel guilty for not being more participatory with the project maintainers. But the fact is that the expected cost of getting embroiled in a flamewar like this is high (whether it is over architecture, whitespace convention, "behavior by design", "Jim's already working on that", etc.), whereas the benefit to me of getting my changes merged upstream is essentially zero. So my antisocial behavior continues to be positively reinforced.

Does anyone else have this problem? Or do people just enjoy flamewars more than I do, or have the persuasive skills to avoid them?

[0] https://github.com/msgpack/msgpack/issues/13

drewcrawford··on Sony announces PS4 with 8-core x86 processor, 8GB GDDR5 memory and DualShock 4
> the gaming market is growing overall.

False: http://business.time.com/2013/02/11/game-over-why-video-game...

drewcrawford··on Sony announces PS4 with 8-core x86 processor, 8GB GDDR5 memory and DualShock 4
I don't understand what you are saying. According to Apple's 2012 10K filing, both the iPhone and iPad lines independently, each year, net more than Sony's entire market cap.

How can there be any question of mobile game hardware surpassing hardcore gaming in profitability in the next console generation when it has already occurred?

If you're Activision or Blizzard, sure, the money is still in selling $60 titles. But in terms of hardware manufacturers like Sony and Microsoft, the ship has sailed.

drewcrawford··on I Was a Political Prisoner at Birth in North Korea
You reach a certain point where the weight of the evidence suggests that the received wisdom of imminent collapse isn't correct. With North Korea, we (should have) reached that vantage point in about the mid-90s.

The NK regime has survived, to date: two major power transitions, the financial collapse of its protecting superpower state, the worst famine in modern history, a full-scale ground and air invasion by a world superpower, a widely-known and well-documented human rights record that would shame Nazi Germany, openly kidnapping foreign citizens to be trained as spies and other major diplomatic kerfuffles in the same league that have previously started wars, and I think the longest and most severe economic isolation in the history of the United Nations.

We're told breathlessly with each new development for the past 50 years that collapse is surely just around the corner. But I can think of very little that would seriously test the regime beyond what they have faced so far.

drewcrawford··on Codeq. Code quality as a service
This isn't static analysis.

Compare the output of a "real" static analysis tool that finds logic bugs[0]

https://www.dropbox.com/s/md35ca9mjrny4o1/Screen%20Shot%2020...

With their whitespace recommendations

https://codeq.io/github/tianyang-li/rna-seq-len-est-0/master...

Which seem to mostly be a wrapper around autopep8: https://github.com/hhatto/autopep8.

Even Pylint / Pyflakes would be more "static analyzer" than this tool, although it's a stretch.

[0] In this case it trips an assert, so the bug can't "really" happen. Still, it's pretty impressive stuff.

drewcrawford··on Automatically Blackballed
You're making an error that many programmers make when they reason about the law. The law is not a set of rules about technology. The law is mostly about intent. The technology that is used is for the most part, as we programmers commonly say, "merely an implementation detail."

For example, the law says that you have to have a license to make a derivative work, and it is this particular law that is "the source of the GPL virus" in this situation. But whether or not you are making a derivative work does not have much to do with what bits of technology you use. Of course, the questions are related because choices of technology can make the question about whether you are creating a derivative work more believable on one side than the other. But if you making technology choices in the hope and on the sole basis that it has some impact on whether or not you are creating a derivative work, you are practicing cargo cult law, just the same as if you erase the experimental results table from your paper and hope it changes the gravitational constant. You're reasoning in the wrong direction.

Just as random aside, this is the same kind of thinking that led to the predominance of magnet links instead of torrent files. There are some technical reasons to prefer one over the other, but some people seem to believe there is a legal distinction when there is not. The magnet link is just as legal or illegal as the torrent file it replaces. The question is whether one is engaged in contributory copyright infringement, not whether one does it with URLs or not.

drewcrawford··on Achievement Unlocked
It occurs to me that the value of YT today is primarily the network effect / discoverability. Between the video tag, availability of cheap flash video players, and CloudFront/S3, the cost to create YT has fallen dramatically, and there are even things for ordinary people to self-host like VideoPress.

My suspicion though is that robustness to DMCA complaints is an "unfeature"--you don't need it until you do. Like an insurance policy or backup equipment, you're convincing people to pay now for something they might need later, which is a hard thing to sell.

drewcrawford··on Congress Is Quietly Abandoning the 5th Amendment
There are two problems with this analysis. The first is that the Constitution is not a "contract" with which Americans "collectively bargained away" anything, because modern Americans were not alive at the alleged time of bargaining away things, and being alive is a prerequisite for making a contract. To believe in constitutionalism is essentially to not believe in governance by the consent of the governed.

The other problem is that even if it was a contract, we seem to ignore it, because we pass the laws described in the article. So it's not a very effective system.

← PreviousPage 12 of 29Next →