What is this mysterious device that requires specific libraries and kernel modules? So I can state the fuck away from the device and the brand
What is this mysterious device that requires specific libraries and kernel modules? So I can state the fuck away from the device and the brand
Use uBlock Origin. Not AdBlock, not AdBlock Plus, not any other crapware. Looking at AdBlock website they have a blurb about only keeping anonymised data and never selling it and yada yada yada, because it goes against their company ethics.
Company ethics. AdBlock is owned by a company. A for-profit entity. How do you think they make their money? Either they sell the data they have gathered (why does an ad blocking extension need to gather user data?) or they have agreements with ad companies.
Compare the websites of AdBlock and uBlock Origin. The first thing on uBlock Origin website is a link to the publicly available source code. That’s trustworthy. AdBlock’s website has a handpicked list of 5 star reviews.
TL; DR: please switch to uBlock Origin and ditch AdBlock, they (the company behind AdBlock) likely have agreements with advertisers (including Google and YouTube) to make money. Your data is being harvested by using AdBlock. You cannot look at the code for AdBlock. AdBlock is not trustworthy.
Since my previous example didn’t really have return value, I am changing it slightly. So if I’m reading your suggestion of “rewriting that in 3 lines and a single nested scope followed by a single return”, I think you mean it like this?
int retval = 0;
// precondition checks:
if (!p1) retval = -ERROR1;
if (p2) retval = -ERROR2;
if (!p3 && p4) retval = -ERROR3;
// business logic:
if (p1 && !p2 && (p3 || !p4))
{
retval = 42;
}
// or perhaps would you prefer the business logic check be like this?
if (retval != -ERROR1 && retval != -ERROR2 && retval != -ERROR3)
{
retval = 42;
}
// or perhaps you'd split the business logic predicate like this? (Assuming the predicates only have a value of 0 or 1)
int ok = p1;
ok &= !p2;
ok &= p3 || !p4;
if (ok)
{
retval = 42;
}
return retval;
as opposed to this?
// precondition checks:
if(!p1) return -ERROR1;
if(p2) return -ERROR2;
if(!p3 && p4) return -ERROR3;
// business logic:
return 42;
Using a retval has the exact problem that you want to avoid: at the point where we do return retval
, we have no idea how retval
was manipulated, or if it was set multiple times by different branches.
It’s mutable state inside the function, so any line from when the variable is defined to when return retval
is hit must now be examined to know why retval
has the value that it has.
Not to mention that the business logic then needs to be guarded with some predicate, because we can’t early return. And if you need to add another precondition check, you need to add another (but inverted) predicate to the business logic check.
You also mentioned resource leaks, and I find that a more compelling argument for having only a single return. Readability and understandability (both of which directly correlate to maintainability) are undeniably better with early returns. But if you hit an early return after you have allocated resources, you have a resource leak.
Still, there are better solutions to the resource leak problem than to clobber your functions into an unreadable mess. Here’s a couple options I can think of.
defer
Example of option 1
// precondition checks
if(!p1) return -ERROR1;
if(p2) return -ERROR2;
if(!p3 && p4) return -ERROR3;
void* pResource = allocResource();
int retval = 0;
// ...
// some business logic, no return allowed
// ...
freeResource(pResource);
return retval; // no leaks
Example of option 2
// same precondition checks with early returns, won't repeat them for brevity
auto Resource = allocResource();
// ...
// some business logic, return allowed, the destructor of Resource will be called when it goes out of scope, freeing the resources. No leaks
// ...
return 42;
Example of option 3
// precondition checks
void* pResource = allocResource();
defer freeResource(pResource);
// ...
// some business logic, return allowed, deferred statements will be executed before return. No leaks
// ...
return 42;
Example of option 4
int freeAndReturn(void* pResource, const int retval)
{
freeResource(pResource);
return retval;
}
int doWork()
{
// precondition checks
void* pResource = allocResource();
// ...
// some business logic, return allowed only in the same form as the following line
// ...
return freeAndReturn(pResource, 42);
}
Bad advice. Early return is way easier to parse and comprehend.
if (p1)
{
if(!p2)
{
if(p3 || !p4)
{
*pOut = 10;
}
}
}
vs
if(!p1) return;
if(p2) return;
if(!p3 && p4) return;
*pOut = 10;
Early out makes the error conditions explicit, which is what one is interested in 90% of the time. After the last if you know that all of the above conditions are false, so you don’t need to keep them in your head.
And this is just a silly example with 3 predicates, imagine how a full function with lots of state looks. You would need to keep the entire decision tree in your head at all times. That’s the opposite of maintainable.
Does Israel have a free press?
If this was cpp, clang-tidy would tell you “do not use else after return”
I don’t know how null works in swift, but assuming it coerces to bool I’d write
if (a) return a;
return b;
Used discord on Firefox within the last week, no issues detected.
Disable all your plugins and check if this still happens, a few months ago I ran into an issue where every tab would load for a good few seconds before actually opening, even super lightweight stuff. Turned out to be caused by an addon that was umantained because the maintainer passed away.
Don’t remember which addon it was, but I can try and remember / search if you are interested.
Where do you live where banking sites don’t follow industry standards, even for web development?
I’ve never had a problem with a website outright not working on Firefox, although in some cases features are restricted which usually just require a user agent change (like huddles on slack).
Do you have concrete examples of websites that outright don’t work on Firefox?
Both work flawlessly for me. In fact, discord on Firefox works much better than the standalone app specifically for calls.
Sounds to me like something is broken or misconfigured on your system.
My logitech G900 is plug n play on all my linux installations.
The same is true for the inexpensive logitech mouse that I have as backup (although it’s a piece of shit of a mouse and what made me decide to avoid logitech like the plague going forward).