In the sense that it and its ecosystem is high maintenance. When I call something names I do not do that lightly, but Wordpress is probably the single piece of software that has caused me the most problems over my 20 year IT career. You simply cannot put Wordpress into a customers hands, let it run for 5 years and expect it not to blow up in one way or another.
Just today I spent three hours to manually fix a page where a customers site was defaced after they installed and then uninstalled a translation plugin. I had to write a script that manually check every single instance of translatable text there is on the website.
This is a question for the sake of curiousness; the article writer shot a couple of pictures of young black kids. I can't find any mention in the article, but is this just coincidence or is this commonly done becauses the darker skin is hard to shoot correctly?
It's relatively common and mostly a problem of exposure, especially in group photos. In general you want higher exposure for darker skin tones so that the camera resolves more detail, but at the same time you don't want the background overexposed.
Good one, yes. It was like that in Objective-C, and in the early versions of Swift. I know you know this, but it's useful to summarize for myself:
Basically inheritance is the wrong tool for this kind of stuff. NSMutableArray inherits from NSArray, so it can be passed to anywhere NSArray is expected (upcasting).
So you design your classes and expect them to be immutable, but you can't use NSArray anywhere. Because otherwise, it'll be mutable after all. You can do a runtime check as a workaround.
(I truly believe OOP should only be taught in computer science as a relic).
You just misinterpreted what NSArray is. It’s not an immutable type, it’s a read-only type. As others already mentioned that’s different things. If you have a read-only variable and exclusive access to it, then you can rely on immutability as well. This is what Rust has, for example. Many languages use this definition as well as it’s much more useful than having some sort of pure immutable type guarantee (which some languages do have with const).
Another language that uses this is Kotlin: List is a read-only type. MutableList is a subtype of List. You can get a “const” List by only keeping a reference to the value via a List binding. This can be worked around via casting and reflection, but even in Haskell you can do unsafe things that mutate a immutable value, so I don’t think that undermines the idea.
Certainly, these aren't new standards and have been available on Android. We like to offer a split page when a foldable is used in a book pose and avoid having anything (especially interactive elements) in the middle.
Init can become a hassle. And I'm not the only one, I remember listening (to a podcast?) where Chris Lattner himself remarked that there were many nitty-gritty details to the init phase of objects.
reply