If you need to use bash a lot just to learn 2 "keywords", then it's not a good language.

I have looked at bash scripts in the past, and even written some (small amount). I had to look up -z and -n every time. I've written a lot more python than bash, that's for sure. But even if I don't write python for a year, when needed I can just write an entire python script without minimal doc lookups. I just need to search if the function I want is part of syd, os or path.

The first time I want to do an else if my IDE will mark it red and I'll write eliffrom then on, same thing if I try to use { }.

If a bash script requires at least one array and one if statement, I can write the entire thing in python faster than I can search how to do those 2 things in bash.

Well, to get a boolean out of a bit array you have to do some operations. So at first it doesn't make it more performant. Compilers probably don't automatically make them bitarrays because of that.

However, the memory savings means less cache used. And a cache miss is way more expensive than those bit operations. So they should be more performant. I'm sure someone out there has done the actual research and there's a good reason why compilers don't make all booleans bitarrays.

Guys, the fact that 35 is not less than half of 60 is part of the joke. The test he failed is a math test.

I hate both of them. The first one is very clunky with all the ". The second one is not self-docummenting at all, and it makes some enums impossible.

For example, you can't represent:

 undefined

    
enum A {
    B(u32)
    C(u32)
    D
}

  

It would be

 undefined

    
A {
    | u32
    | u32
    | ()
}

  

Also, the pipe is very awkward to type, specially depending on keyboard layout. Since it's a rare character. If you need to separate between enums and struts and really don't want to use the enum and struct keywords, you can use different delimiters, like:

 undefined

    
A [
 u32,
 u32
]

B {
 u32,
 u32
}

  

To counteract this, I usually accept it right away and move on. But then I feel weird. Like, should I compliment back? It now feels weird that the compliment was over so fast. I don't think there's a good way to accept a compliment.

In my experience, this shows up if I mention an attached file somewhere in the email.

In my experience, nobody really knows what OOP is, everyone has a different definition.

Most of the "OOP" features are implemented in languages that are not OOP. The only one that is to me an OOP-exclusive feature is class-inheritance. So IMO OOP=class inheritance.

There is plenty of criticism about inheritance, specially among rust lovers. Since rust implements other features associated with classes, except class inheritance. Such as: methods (and self keyword), interfaces (traits), default interface method implementation.

Anti-OOPs usually argue that encapsulation and interface is a much better alternative to class inheritance.

Some things class inheritance is criticized for:

Diamond inheritance problem: If there is class A. B and C inherit from A and override its methods. D inherits B and C without overriding them. What implementation should D inherit? B or C? Same happens if only B or C overrides.

Encourages having multiple layers of abstraction: it's not uncommon to see huge inheritance chains. MyCustomList -> OrderedVector -> OrderedList and Vector -> List -> Collection -> Iterator. Just by looking at MyCustomList, you don't know the entire chain, you just see "OrderedVector". You have to follow many nested links until you can know it all, and then you have to retain that knowledge along with tens of other inheritance chains.

Not ideal for performance: Inheritance encourages designs where the compiler will need to add a v-table to classes. These tables make implementation of OOP patterns much easier, but they require additional overhead when calling methods. Note that v-tables are not OOP specific, rust needs them also for trait objects. However, rust encourages designs with small amount of trait objects.

Not as intuitive as claimed: People are taught OOP with simple examples involving real-world objects like: car -> vehicle -> object. However, these situations are rare except in some specific cases like UIs, video games, simulations. In most other cases, you are dealing with concepts rather than objects. And even when you're dealing with objects, it's not a clear cut. Sometimes it might happen that bicycle -> car. Even though not intuitive, in some situations this may be a useful inheritance. But when bicycle inherits car, it no longer resembles the inheritance-chain of the real world, so that's extra work for the brain.

Don't need sudo or anything pre installed for vscode either. It will send the server to the machine via SSH and then run it automagically.

You can do that with vscode too. And probably many IDEs.

The only real reason for which you would need to use vim in such cases is if the target computer can't run the vscode server, which I've never encountered yet.

If I have to search something in a repo, I just clone it and use my IDE. GitHub search sucks, but I don't think it's possible to have a web experience that is on par with an actual environment an IDE.

I guess that's another way to avoid the overflow problem

C:

 C

    
int increment(int i) {
    return (int) (1[(void*) i])

  

However, if you wanna go blazingly fast you gotta implement O(n) algorithms in rust. Additionally you want safety in case of integer overflows.

 rust

    
use std::error::Error;

#[derive(Debug, Error)]
struct IntegerOverflowError;

struct Incrementor {
    lookup_table: HashMap<i32, i33>
}

impl Incrementor {
    fn new() -> Self {
        let mut lut = HashMap::new();
        for i in 0..i32::MAX {
            lut.insert(i, i+1)
        }
        Incrementor { lookup_table: lut }
    }

    fn increment(&self, i: i32) -> Result<i32, IntegerOverflowError> {
        self.lookup_table.get(i)
            .map(|i| *i)
            .ok_or(IntegerOverflowError)
}

  

On mobile so I don't even know if they compile though.

Not really. When you pirate a movie you get the whole thing. Just as if you paid for it.

A succulent leaf, however, needs years to become the size of an actual plant they would sell.

It's even less damaging than pirating.

Some people would not select google though. And google can't afford people knowing that there's competitors to Google! So better fuck everyone over by just disabling the integration.

They make ruggedized phones. I don't think they make normal ones.

That's the thing. The reason El Salvador was so effective in eliminating crime is because they don't care about imprisoning innocent people.

You can't have the effectiveness without the collateral damage.

Which one is preferable? I don't know. But you can't eat the cake and have it too.

It's not all about the impact. It's also about the chance or impact. If you're going at that speed on pedestrian zones, you'll eventually hit someone, or be very close to doing so. Pedestrians go in any direction, and can change at any time in an instant. If you go fast, no matter how fast your reflexes are, they won't be fast enough to brake in time on pedestrian zones.

The roads not being safe for non-cars is not the problem for pedestrians. Use the bike lane in those cases.

It is hard. Not everyone knows what colors are a problem for colorblind people. There are also many types of color blindness.

Time to +18 super Mario 64 DS

"wasted" is completely relative. I would pay 30-50 euros for a cool design of a GPU.