The point is that even showing up costs time and possibly travel expenses. Court proceedings are slow, so without a lawyer, you'll spend days of your time in court fighting the case.
It's possible to defend yourself without a lawyer. People have done it successfully. However, to be successful, you have to spend a lot of time learning, understanding and using the law to your advantage, and it's usually not worth it. Even lawyers will hire other lawyers to defend them, if they're defendants in a case outside their area of speciality.
There's a pervasive attitude that representing yourself without a lawyer lowers your chance of winning, though there are no hard statistics either way.
If you don't show up at all, you'll almost always lose. In many cases, if you fail to show up, the judge is required to rule in favor of the only party that showed up. Even if that wasn't the case, if the judge is only listening to one side of an argument, they're likely to agree with that side.
Because that's just not how the legal system works, at least not in the United States (Kik Interactive is located in Canada, npm Inc. is located in the US, so it's possible for Kik to file a lawsuit against npm in the US.)
Full disclosure, I'm not on Kik's side here. I think they should have let Azer keep the kik npm module. I'm just trying to explain why npm could be legally threatened.
Kik sent npm a request to take down a package with their trademarked name. If npm declined, they could have filed suit against npm. They would not have to prove that their trademark was valid before doing so. Even if they didn't have a trademark, they could file the case, knowing they would lose. It would be a very short case. Npm's lawyers would have to submit evidence that Kik didn't own the trademark, and the case would be dismissed.
But the important part here is that they would need to show up to court with lawyers, and this is not free. This is why (again, at least in the US) legal threats from big companies like Kik to small developers (or other individuals, or even smaller companies) like Azer are so threatening and offensive. Even if the company is in the wrong, and the small developer is in the right, the cost of hiring a lawyer and going to court is so expensive that you're better off just letting them have their way, even if they're wrong.
> I have no idea what the right thing to do is in this situation, but having all those possibilities gives the compiler a better chance of producing faster code. When you introduce message passing, you basically forbid all of those optimizations, because now the function might be swizzled, go pass a "minX:Y:" string to objcMsgSend to find out what pointer we should jump to today.
> Swift already does have a way to opt-in to message passing, it's called the @objc flag (and performSelector:). It works fine, but it's extra work to opt into it and use it. But, I don't think that's bad given that it disables so many useful optimizations.
You could keep some of these optimizations if Swift's message-passing mechanism preserved type information. This would make it slower than objc_msgSend, but you could still keep a lot of cool optimizations. Some optimizations would still not be possible, and extensive use of function pointers does tend to frustrate branch prediction, but I feel that for most apps, this would be fast enough.
> Finally, I fundamentally and strongly disagree with Michael about method swizzling and OSX extensibility. Adding PGP to Mail via hooking functions sounds like an incredibly deranged idea. The suggestion that programs should cooperate with a badly-misguided reverse engineering effort by disabling optimizations that make the program faster for the other 99% is just insane. The way to approach this is to build new kinds of extensions that provide known, safe, documented extension entrypoints for hooking arbitrary code. Yes that is more work, and yes it requires actually talking with people and convincing them of your point of view, but so do most things.
I think this is a great argument, but unfortunately it's not where OS X is today. As I mentioned, app extensions may be a step towards a more workable solution, but today, the ability to add PGP to mail using method swizzling is important to thousands of Mail.app users. If 10.11 comes out and Mail.app has been rewritten in Swift before we have a good alternative to method swizzling, we'll have lost a lot of tools that make the Mac a powerful platform.
This is true, and why I also filed bugs asking for a robust reflection and dynamic method compilation. Thankfully, they were duplicates.
But not all of the cases can be accomplished using these techniques, and even those that can, it's often more code.
The ability to reason about which methods are getting called at runtime has been a powerful tool since the beginning of iOS development, and in Mac and NeXTStep development before that. It would be a shame to lose it.
I described that radar rather poorly. If you look at what I described in the radar, I basically want them to ship the swift compiler as part of the core OS, and an eval function would compile its argument and load it into the current process using the dynamic linker. I definitely do not want interpreted Swift.
Swift is certainly a language that relies on compiler optimizations. I don't want to change that.
From the linked Wikipedia article on Dynamic Dispatch:
> C++ compilers typically implement dynamic dispatch with a data structure called a virtual table that defines the message to method mapping for a given class (C++ as such has no notion of a vtable).
Both the term "dynamic dispatch" and the term "message passing" are overloaded, but I used the term "message passing" to differentiate it from vtable dispatch, which I talk about in the article.
I'm not criticizing Swift for being a statically-typed language. I'm only criticizing the way it calls methods.
I suppose it depends on what you intend to use Swift for.
My argument is that Swift will be primarily used to write high-level apps. For these apps, message passing is almost never a bottleneck. Swift is not going to replace the optimized C and C++ code, especially for the really low-level stuff.
But even if Apple does decide to rewrite all the Core* frameworks et. al. with Swift, there's still an argument that Swift should use message passing by default, and a way to opt in to vtable and direct dispatch for performance-critical code. For higher-level apps, message-passing is a lot less useful if it's opt-in.
As for the IRC and Latin conjugation, yes, those problems can be solved in other ways, but those other ways involve more (mostly glue) code. Trading more code for execution speed is the wrong tradeoff when performance is good enough.
You're correct I want to stick with Objective-C, but not that I have little experience with functional programming. I love functional programming. I love most of Swift. But for the specific problem domain of Mac and iOS apps, I love Objective-C. It makes working with GUIs much easier than anything else out there, and the ability to method swizzle Mac apps is great for third-party add ons.
It's possible to defend yourself without a lawyer. People have done it successfully. However, to be successful, you have to spend a lot of time learning, understanding and using the law to your advantage, and it's usually not worth it. Even lawyers will hire other lawyers to defend them, if they're defendants in a case outside their area of speciality.
There's a pervasive attitude that representing yourself without a lawyer lowers your chance of winning, though there are no hard statistics either way.
If you don't show up at all, you'll almost always lose. In many cases, if you fail to show up, the judge is required to rule in favor of the only party that showed up. Even if that wasn't the case, if the judge is only listening to one side of an argument, they're likely to agree with that side.