The logic behind the voice controls sounds pretty questionable, but it’s supposedly backed by data showing that users spend billions of minutes talking in Microsoft Team meetings, according to Mehdi — so they’re already used to talking on the computer, right?

Do they really reason like this? Oh my. That’s stupid. And here I was thinking Microsoft employs clever people.

Tankie is a pejorative label generally applied to authoritarian communists, especially those who support or defend acts of repression by such regimes, their allies, or deny the occurrence of the events thereof. More specifically, the term has been applied to those who express support for one-party Marxist–Leninist socialist republics, whether contemporary or historical. It is commonly used by anti-authoritarian leftists, anarchists, libertarian socialists, left communists, social democrats, democratic socialists, and reformists to criticise Leninism, although the term has seen increasing use by liberal and right‐wing factions as well.

https://en.wikipedia.org/wiki/Tankie

This is in beta, not available for all users and you can also disable it easily: https://support.ecosia.org/article/994-ai-overviews

As far as I know they are using Bing. They’ve started building their own search index last year in a partnership with Qwant.

It find it unfortunate that you are unwilling to continue this discussion. I can only recommend to you to read more deeply about this topic in order to form a well founded and critical opinion, before judging things you do not seem to comprehend sufficiently.

Let me know as soon as you’d like to continue this matter. I am always open for a good discussion and good arguments.

(I am not sorry for “necroing”, sometimes I’m just not in the mood and/or don’t have the time to reply to various comments. But that’s the beauty of discussion platforms: it’s always possible to pick it up at a later time.)

Well, in that case I wonder why you were criticising the field of AI. Doesn’t seem to be substantiated.

Is it though? By which definition?

What is “thinking critically about thoughts”?
And what is an “independent thought”? Aren’t our brains not just reacting to sensory inputs and dictated by the way our brains are wired?

Maybe we should go even further and clarify what a “thought” even is.

Are animals, who lack the higher cognitive functions, that humans have, therefore not “intelligent”? Are mentally impaired people no longer to be considered “intelligent”? If so, where is the line to be drawn? What are the specific definitions and criteria to correctly distinguish intelligence from non- or pseudo-intelligence?

Not my wording, but the one from the paper I have linked.

only one in 20 graduates remains in the country to work.

It appears Lithuania also struggles with attracting foreign students at all, given they’ve only got 20 foreign students. /j

Good question! I have read a bit more about it and this does indeed heavily depend on the respective compiler implementation. Depending on the compiler, it may prefer default if-else ladders for few cases. For more, dense cases, LUTs may play a larger role. For less dense cases binary search might be chosen.

I inspected the generated assembler code of your (slightly extended) example via https://godbolt.org/

The code I used:

void check_uv();
void check_holograph();
void check_stripe();
void check_watermark();

void switch_test(int banknoteValue) {

    switch (banknoteValue) {
        case 5000:
            check_uv();
            check_holograph();
        case 2000:
            check_stripe();
        case 1000:
            check_watermark();
    }

}

Using x86-64 gcc 15.2 this leads to a couple of cmp followed by je instructions, so “compare” and “jump to label if equal” which basically is a typical if-else ladder. I get the same for x64 msvc v19.43.
Changing the cases to 1, 2 and 3 instead of 5000, 2000 and 1000 does not change the outcome.

Increasing to 23 different but incrementally increasing cases (cases 1 to 23) does not change the outcome as well for gcc. But here msvc has introduced a performance optimization: it decreased the input value by one to get a range of 0 to 22 and then created a jump table, so a LUT with execution addresses. (I am not going to detail the assembler commands logic here, but you can use the C++ code below and take a look yourself. :) )

So even in this simple example we can already see how different compilers may implement switch cases differently depending on its structure. Even though gcc chose the apparently less efficient solution here, usually one may trust on the compiler choosing the most efficient switch implementation. ;)

As far as I know, we would not even get the chance of similar optimizations if choosing if-else ladders directly instead of a switch-case structure. It would be interesting to put this to a test though and see whether some compilers translate if-else ladders equivalently with the performance benefits that can currently come with switch structures.

The inflated code:

void check_uv();
void check_holograph();
void check_stripe();
void check_watermark();

void switch_test(int banknoteValue) {

    switch (banknoteValue) {
        case 1:
            check_uv();
            check_holograph();
        case 2:
            check_stripe();
        case 3:
            check_watermark();
        case 4:
            check_watermark();
        case 5:
            check_watermark();
        case 6:
            check_watermark();
        case 7:
            check_watermark();
        case 8:
            check_watermark();
        case 9:
            check_watermark();
        case 10:
            check_watermark();
        case 11:
            check_watermark();
        case 12:
            check_watermark();
        case 13:
            check_watermark();
        case 14:
            check_watermark();
        case 15:
            check_watermark();
        case 16:
            check_watermark();
        case 17:
            check_watermark();
        case 18:
            check_watermark();
        case 19:
            check_watermark();
        case 20:
            check_watermark();
        case 21:
            check_watermark();
        case 22:
            check_watermark();
        case 23:
            check_watermark();
    }

}

That falls into the “very desparate” part. As long as there are companies that have better recruitement processes it will help if most people prefer those over others. If all of these companies reject an applicant then this applicant might become “desparate” and turn towards worse companies. So it’s more the mass of people that influence the market and can therefore improve its conditions.

Typewise.

https://play.google.com/store/apps/details?id=ch.icoaching.typewise

Once you get used to it, it is very good. Nice large buttons, fast typing, strong privacy (e.g. EU based, on-device-only learning for next word suggestions), customizable, and you can also get the pro version forever with a single purchase instead of using the subscription model.

There was a similar study / survey by Microsoft (idk anymore if it was really them) recently where similar results where found. In my experience, LLM based coding assistants are pretty okay for low level complexity tasks, creating boilerplate code, especially if it does not require deeper understanding of the system architecture.

But the more complex the task becomes, the harder they start to suck and fail. This is where the time drag begins. Common mistakes or outdated coding approaches are also used rather often instead of newer standards. The deviations from the given instructions are also happening way too often. And if you do not check the generated code thoroughly, which can happen if the code “looks okay” on first glance, then finding bugs and error sources due to this can become quite cumbersome.

Debugging is where I have wasted most of my time with AI assitants. While there is some advantage in having a somewhat more capable rubber duck, it is usually not really helpful in fixing stuff. Either the error/bug sources are completely missed (even some beginner mistakes) or it tries to apply band-aid solutions rather than solving the cause or, and this is the worst of all, it is very stubborn about the alleged problem cause (possibly combined with forgetting earlier debugging findings, resulting in a tedious reasoning and chat loop). I have found myself more often than I’d like to arguing with the machine. Hallucinations or unfounded fix hypotheses make this regularly worse.
However, letting the AI assistant add some low level debug code to help analyze the problem has often been useful in my experience. But this requires clear and precise instructions, you can’t just hope the assistant will cover all important values and aspects.

When I ask the assistant to logically go through some lines of code step by step, possibly using an example, to nudge it towards seeing how it’s reasoning was wrong, it’s funny to see, e.g. with Claude, how it first says stuff like “This works as intended!” and a moment later “Wait… this is not right. Let me think about it again.”

This becomec less funny for very fundamental stuff. There were times where the AI assistant told me that 0.5 is greater than 0.8 for example, which really shows the “autocorrect on steroids” nature of LLMs rather than an active critical thinking process. This is bad, obvio. But it also makes jobs for humans in various fields of IT safe.

Typing during the whole conversation is naturally also really slow, especially when writing more than a few sentences to provide context.

Where I do find AI assistants in coding mostly useful, is in exploring APIs that I do not know so well, or code written by others that is possibly underdocumented. (Which is unfortunately really common. Most devs don’t seem to like writing documentation.)
Generating documentation for this or my own code is also pretty good most cases but also tends to contain mistakes or misses important mechanisms.

Overall in my experience I find AI assistance useful and see a mild productivity speed boost for very low level tasks with low complexity and low contextual knowledge requirements. They are useful for exploring code and writing documentation, but I can not really recommend them for debugging. It is important to learn and know how to use such AI tools precisely in order to save time instead of wasting time, since as of now they are not really capable of much.

German politicans also propose this. But no one will go on strike, because we would rather be a bit grumpy and complain why nobody is doing anything against this.

Why the fuck do we have so many football pitches? /j

“Google stands for free and open internet”

https://blog.google/outreach-initiatives/public-policy/keep-internet-free-and-open/

Aged like milk.

Next up: Slovakia changes the constitution to enforce a flat earth world view, because scientific facts are ignored and they’d prefer to stay idiots.

/j: joke
/s: sarcasm
/i: irony

Easy:
You take GPU. And then you put GPU.
Understood? /j

Das Budget wurde um 8% gekürzt. Ich denke, es handelt sich dabei auch mehr um eine Konsequenz genereller Sparmaßnahmen und weniger um ein hirntotes Kopieren der Trump-Regierung.