706 karma · joined July 4, 2014
Yes, piling more people into the box of fighting for a single-digit percent of a single-digit percent of the wealth in the US is rarely great for anyone, but the root problem is not the people being added but the minuscule scraps they're forced to fight for while the rich get richer.
Barring outliers like NYC, the US is centuries away from even population density _parity_ relative to most of the rest of the world.
The most successful of the early 0.0 power alliances was fueled in part by having a developer who revealed his identity to the alliance leadership, funneled limited rare items (blueprints) to them which were used to fund the alliance's growth, and abused their GM powers to threaten other alliances.
The revelation was a massive blow to the playerbase's faith in CCP and the CSM was established in large part to increase the transparency and communication between CCP and the playerbase, as some of the foul play was long-suspected but the concerns unheeded.
If my home media library gets wiped out by hardware failure, replacing it would be an annoyance but not a disaster. Anything that would be a disaster is covered by at least two cloud services.
There have been dozens of cases in the past few years in which police have been sent to medical emergencies and responded with unwarranted and fatal violence towards the people they should have been helping. That's not even counting cases like Kenneth Chamberlain Sr, in which there was no emergency, officers were notified of this shortly after arriving, and they proceeded to assault and murder a man who had done nothing wrong in his own home anyway.
Calling 911 for assistance for a mentally ill family member can literally be a death sentence, and that is an intolerable state of affairs.
15 years ago I didn't mind spending hours (days weeks) tweaking config files to get everything about my distro absolutely perfectly customized, now I just want it to work out of the box and get out of my way so I can get real work done.
Cinammon also has the nicest workspace management of any desktop environment I've tried, which is a solid bonus since it's probably the DE-specific feature I interact with most on a day to day basis.
Things like having to elaborate hacks to get sub-voxel shapes and imperfect precision with rendering intersecting edges seem like limitations of any voxel based design, while the crude handling of lighting and reflections and very short LOD distance seems to be intentional limitations for performance reasons (and understandable given average voxel counts in player-created areas).
The FBI continues to disproportionately expend resources on environmental groups despite no cases of loss of life from green direct action, while admitting themselves that right-wing militias present a greater domestic threat than even the dreaded foreign terrorism they're so happy to prove they're protecting us from by spending years deliberately radicalizing and then entrapping harmless fools.
Law enforcement motivations cannot be ever trusted when it comes to your privacy.
Shared Hosting has many downsides, but it still fills an incredibly important niche for businesses for whom a web presence beyond a Facebook page is needed but real managed hosting is completely out of their price range.
Having a fixed relative ratio of font sizes for h1-h6 makes no sense because heading tags (as all html) are structure, not style. They are used to indicate the relative importance of heading text within a page and/or section, and should have a semantic css class appropriate to their role applied.
Depending on how a page is structured, a h2 may be a section heading, or an article heading, or a page sub-heading, or many other things, and each of those roles may call for very different styling relative to a h1 page heading.
On May 14, 2007, the staff of Sigil Games Online were told to meet in the parking lot at 4:30PM and to take with them what they would need for the rest of the day. The employees were told that the launch of the game had not gone well, the company was in financial trouble and they were selling the company to Sony Online Entertainment. Director of Production, Andy Platter, then told the employees "You're all fired."
Over those couple of years IBM went from using almost all of the sizable campus it had built to just one small section, renting out the rest. DFW was otherwise undergoing massive growth at the time though, so the cuts were readily absorbed by Dell, MS, and many others (my father went to AMR). It wasn't like in the early 2000s when virtually everyone in DFW was downsizing or closing and as a fresh college graduate I was competing for entry-level jobs with admins with 10 years at MS.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend compiled file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane. Extend in sass isn't really any different than using traits in oop languages, it's an incredibly useful pattern when employed correctly.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend compiled file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane. Extend in sass isn't really any different than using traits in oop languages, it's an incredibly useful pattern when employed correctly.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend compiled file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane. Extend in sass isn't really any different than using traits in oop languages, it's an incredibly useful pattern when employed correctly.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend compiled file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane. Extend in sass isn't really any different than using traits in oop languages, it's an incredibly useful pattern when employed correctly.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend compiled file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane. Extend in sass isn't really any different than using traits in oop languages, it's an incredibly useful pattern when employed correctly.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend compiled file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane.
Regarding side effects, they're easy to avoid if you structure your main file in a logical way. For generic extension, your library of base classes (both actual classes and silent classes) should be included before your components which extend and build on them, therefore any inherited styles come before (and can therefore be overwritten by) the extending component but never the other way around. When extending a component, the extending objects should always be in the same file and come after (e.g. .gallery followed by .gallery-foo and .gallery-bar which both extend .gallery). If full blown objects/components are related enough to extend, they're related enough to be in the same file.
Avoiding extend file size bloat mostly comes from sane nesting behavior that you should be following regardless. Adding single selectors to an extended rule is almost always going to be smaller than inlining/mixing that rule, even for simple rules.
Discoverability is always going to take a hit with extend, yes, but in my opinion dryness, single-point-of-change, and compile size are far more important than in-file discoverability, assuming your project layout is sane.