The scams are insane, there are so many and they’re all good at convincing elderly people who are used to cold calls and call center talk.

Several people in my family have been hit and none of them are even that senile. They just got played for months before they actually executed the scam.

Worst one is they buy up helplines that are printed on old tech so when you call the “official” HP helpline on your decade old printer you get scammers pretending to be HP

Exactly, there is no “real AI”. It’s an oxymoron.

AI is a fine term because it’s artificial. It’s a facsimile. If they were serious it would just be I

I still think in development environments, limited LLM systems can be used in tandem with other systems like linters and OG snippets to help maintain style and simplify boilerplate.

I use Co-Pilot at work because I do development on the side and need something to help me bash out simple scripts really fast that use our apis. The codebase we have is big enough now (50,000 ish lines and hundreds of files) so it tends to pick up primarily on the context of the codebase. It does still fallback to the general context pretty often though and that’s a fucking pain.

Having the benefits of an LLM trained on your own code and examples without the drawbacks of it occasionally just injecting random bullshit from its training data would be great.

GameNGen can interactively simulate the classic game DOOM at over 20 frames per second on a single TPU.

Wow, it’s almost as fast as my Motorola Droid 1 at playing doom, but used 10000x the power.

What they’ve basically done is the opposite of compression. They got an LLM to take a pretty well optimized bit of code and make it a massive buggy model.

You’re right, it would return a list containing the first element of the sliced list.

So:

lst[:3:3] == [lst[0]]

Well, technically a sequence containing the first element of whatever sequence you sliced. Take advantage of implementing magic methods and you too can abuse slice notation with your classes.

It’s functionally identical to list[0] so you could definitely just refactor your code to use list[:3:3]

Even better is to create a decorator and just wrap the offending functions:

def shut_up(func):
    def call(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            print(f"shit's fucked, but I'll be quiet about it")
            return
    return call

@shut_up
def add(x: int, y: int):
    print(x + y)

add(1, 2)
add(-1, 2)
add(1, "2")

>>> 3
>>> 1
>>> "shit's fucked, but I'll be quiet about it"

Or if you want to attempt to salvage it:

def shut_up(func):
    def call(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            try:
                return func(*map(int, args), **kwargs)
            except Exception as e:
                print(f"shit's really fucked, I even tried to fix it for you")
                return None
    return call

You just have to do it manually in Python or rely on systems like mypy to get ‘static’ checking.

It can be useful to rely on duck typing though if you don’t want to have to re-implement or inherit from an existing base class to use a higer order function.

If the function is written in a way where all it needs is specific methods or parameters from its input objects, you can really save on interface bloat.

But if someone is used to writing statically typed code and has to deal with that it can create a lot of confusion and I always end up writing a ton of override signatures either in my code or in a .pyi sidecar so whoever is using it can still get some form of feedback that what they’re doing is okay. Or at the very least putting that information in the docstring so people can read the docs as they’re using the function.

c, b, a = ('unpacking', 'prefer', 'I')
print(a, b, c)

It’s funny how Python spent the past like 6 years developing the type hinting system (which is a massive improvement from no typing don’t get me wrong) only to start re-introducing duck typing again with the Protocols.

The one thing I’ll always love about it is the ability to override builtins and do dumb things like call ‘sum(cats)’ where cats is a list of cat objects and have it like print out meow to the terminal for each cat in the list.

Shit like that makes it perfect for internal tools.

Plaintext and a simple kanban board are all you need.

I’ve been using one called Planka and it’s great. Incredibly minimal and all important info is documented elsewhere so it can just be used for organization.

Love using a basic SQL database for data warehousing (we need it for billing purposes and SQL records give us a lot more freedom to set up visualizations and data dashboards).

All day to day communication is either in person, over chats, or though plaintext files and comments left in project directories.

I remember helping a friend wrote one in R and Python like 10+ years ago when we were in highschool to predict the MISO energy market.

Some dude paid us like $3000 to make one for him because he wanted to buy a $10k solar farm in Oklahoma so he could speculate on grid futures…

Weird, that seems to be one of the only ones that shows up. Even searching hexbear returns results for prolewiki and the gitlab first

Are you using pcpartpicker? That site is pretty good about flagging potential issues in a build. They have measurements and power ratings and slot configurations for basically everything so they’ll flat a build that has incompatibilities

So… When you’re blanket banned from food stores where do you get your food?

I guess you just have to steal it.

Agreed, I still think physical knobs and buttons should never be removed. I’m just saying that if there is going to be screen controls the screen needs to be big enough that all controls can be accessed on one screen and not through submenus.

The only thing that might save it is the size of the screens (mentioned in the article). The problem with most Western fully touchscreen “infotainment” systems is that they use tiny screens with laggy interfaces. Because the automakers don’t know how to make this stuff and contract out to the lowest bidder like they always have with stereo equipment, only now that stereo is also integral to the car’s operation.

If the car and the interface are designed from the ground up to be readable and responsive, I think there is a way to pull it off (again as mentioned in the article). Having physical interfaces for basic operations related to safety and things that are messed with frequently (volume, shifting, AC, lights, signals, wipers) is a must though because a 2d interface can’t fully take advantage of our 3d spatial awareness.

It’s just another layer of UI on top of windows XP. You still hit XP dialogs when you have to do anything useful. Now you just have to get there through 11 -> 10 -> 7 -> XP and if you really need to do something useful you’ll hit a DOS prompt at some point.

You can, but the current draw is massive and woud fry most household wiring if you’re doing fast charging.

You also need that in DC which means additional hardware needs to be installed. The wire gauges for the ones that charge a car in 30 minutes or less (needed for long distance travel) are huge.

Home setups are usually meant to charge a car overnight not in minutes.