Musings of a Mad Man

@gleb_alexandrov I think there's some cool ways they could integrate as "peek around corners". But nominally if you're not moving, it's just wasted computation.

How this technology hasn't yet made its way into mainstream games? In some ways its WAY more accessible vr.

@ConanOBrien may be the last TV personalty in Hollywood that realizes his job is to put on a show. The last egoless entertainer in a sea of narcissism.

Imagine that? An industry obsessed with viewership putting on a dated award show that charts its own irrelevancy. Perhaps the industry would do better to not share their own demise so publicly.

@squared_echo @Shoestring_Lab @notgrubles Yeah, it's a stupid law. But unfortunately for others, the best software research in the world is grown from there. So it cannot be ignored.

@FreeToMuseMad @Shoestring_Lab @notgrubles Also, afaik these "people" if we can call them like that were elected So the blame goes to this fucking californians

Legitimately considering a non-systemd Linux, or just going BSD at this point. This is so contra to FOSS.

@squared_echo @Shoestring_Lab @notgrubles Yes. The software industry would have no issues if suddenly all California based developers could not use linux...

@FreeToMuseMad @Shoestring_Lab @notgrubles "law is the law" And it's California "What are the developers supposed to do?" Idk not comply with California law, who give a fuck about them

@Shoestring_Lab @notgrubles The law is the law, and its enforcement is arbitrary and capricious. What are the developers supposed to do?

@notgrubles They just reverted it, but this issue isn't going away. We're going to have to fight the people trying to bring this BS into the Linux ecosystem.

@FFmpeg But I think of you every day.

We would politely ask that FFmpeg and "thought leadership" never be used in the same sentence again.

@andrey_kurenkov I think you're missing the point. Most language syntaxes are designed to be understood. The question we're asking is how well can an AI understanding a language which is *not* meant to be understood. It's a different goal, one which a lot of people have.

This research is basically clickbait... These 'esoteric' languages (Brainfuck, Befunge-98, Whitespace, Unlambda, and Shakespear) in the benchmark are not just ones with less training data online, they are also just **much harder** and **less efficient** to do anything productive with, and failing to even discuss this is crazy. Saying that if you can solve something in python you should be able to generalize to these languages is akin to saying that you should be able to generalize from tasks in python to assembly. It's obviously not the same difficulty level to do tasks in python vs assembly. So is low scores on the benchmark due to lacking "ability to generalize computational reasoning to novel domains", or due to the increased difficulty of the task due to the language of choice? Somehow this question is not addressed in the paper not noted in the limitations, as far as I could find. For reference, here are the languages (info from wikipedia): * Brainfuck: The language only consists of 8 operators, yet with the 8 operators, <>+-[]. Here's 'hello world': >++++++++[<+++++++++>-]<.>++++[<+++++++>-]<+.+++++++..+++.>>++++++[<+++++++>-]<+ +.------------.>++++++[<+++++++++>-]<+.<.+++.------.--------.>>>++++[<++++++++>- ]<+. * Whitespace: 'only whitespace characters (space, tab and newline) have meaning – contrasting typical languages that largely ignore whitespace characters.' See first attached image for 'hello world' code. * Befunge-98: a stack-based, reflective language in which programs are arranged on a two-dimensional grid. "Arrow" instructions direct the control flow to the left, right, up or down, and loops are constructed by sending the control flow in a cycle. Hello world: >25*"!dlroW olleH":v v:,_@ > ^ * Unlambda: 'a minimal functional programming based on combinatory logic, an expression system without the lambda operator or free variables. It relies mainly on two built-in functions (s and k) and an apply operator (written `, the backquote character).' `r```````````.H.e.l.l.o. .w.o.r.l.di * Shakespear: 'A character list in the beginning of the program declares a number of stacks, naturally with names like "Romeo" and "Juliet". These characters enter into dialogue with each other in which they manipulate each other's topmost values, push and pop each other, and do I/O. The characters can also ask each other questions which behave as conditional statements. On the whole, the programming model is very similar to assembly language but much more verbose.' See second image for just part of the hello world. I don't want to be mean to the researchers, I do like the idea behind the research, but the way it's presented feels so misleading to me that I can't help but feel the entire effort is either in bad faith or very poorly thought out.

@nicbarkeragain Yeah, I think all of the left-handed people are from before compilers could intelligently warn you about it. I used to be a left-handed guy for years, then GCC/Clang became useful.

Programmers: do you have a consistent preference for which side you put the literal on in a comparison? // Right-hand side if (someValue == 1) {} // Left-hand side if (1 == someValue) {}

@Umit_Torun @Scivf4 I worked on them for self driving cars, it's not a big issue. Of course, you can design a device which intentionally injects points into a LiDAR to deceive it. But it would be very complicated. It's AS complicated as demodulating a polarized radar signal.

@FreeToMuseMad @Scivf4 All true but in a highway, there can be hundreds of them. Its a big security issue.

LiDAR, the laser tech that lets self - driving cars see the world in 3D

@Umit_Torun @Scivf4 But it's also important to recall that RADAR is a wave front, LiDAR is a collimated beam. RADAR interferes more because its signal fills the entire world, rather than single line of site.

@Scivf4 LIDAR's like RADAR's emits elecromagnetic waves and listens echos. Now think it like every car have a radio transmitter at the same frequency (IR). It will not work.

The lidar receiver is only working 1/50th of the time, any signal it receives outside of that window it cannot see. The likelihood of two lidar interfering with each other is rather low. But it does happen. When it does, it looks like a random stray point, its always ignored.

@NRA @magenamusa @NRA This reminds me of when the SAJBD in South Africa helped teach Jews how to use firearms in self-defense.

NRA instructor Rabbi Yossi and @MagenAmUSA are empowering Jewish Americans to exercise their Second Amendment rights to defend themselves and others. NRA is proud to support this mission advancing education, training, and responsible firearm ownership among Jewish gun owners.

@BrickCenter_ I'm out here getting double doubles and people are talking about newtonian mechanics man. Newtonian mechanics? You talking about Newtonian mechanics?! Not the double double... newtonian mechanics.

Deandre Ayton is DONE with this team 😭

@yarnf40580 @fawadhsdev @corsix The original point of this post was that programmers don't understand type theory in a purely mathematical sense. You have demonstrated this.

@FreeToMuseMad @fawadhsdev @corsix The type signature *does* tell you this.

Speaking as someone who studied joint mathematics and computer science, this right here is how you tell apart the mathematicians from the computer scientists.

@ScientificPeach @fawadhsdev @corsix That's T -> U . Because dropping properties may not be homeomorphic.

@fawadhsdev @FreeToMuseMad @corsix Yeah perhaps the type system in rust is more strict but in ts you could have an object of type t, with some optional properties, and this function could drop those optional properties and return that object with the dropped properties and return the same type as the input

@fawadhsdev @corsix That's not what that type signature says. You're describing the identify function (which *does* have the same signature). But that function signature does not specify it is an identity function.

@FreeToMuseMad @corsix Your example assumes T supports + 1. But the original signature has no trait bounds. For an unconstrained T, you cannot do anything with it except return it. That is the whole point.

@fawadhsdev @corsix The type signature tells you nothing. For example this is fully valid... fn mystery<T>(a: T) -> T :: a + 1

Type theory moment. fn mystery(a: T) -> T You cannot inspect T. You cannot transform T. You cannot construct a new T. So the only valid implementation is returning a. The type signature already tells you the implementation. That is the kind of constraint good type systems give you.

@corsix Is he just talking about the identify function?

@DuaneRankin Ivica has been a real problem for the Suns since he was in LAL. Dude is a great center.

"Go hard and do what you do." Rick Carlisle on Ivica Zubac (left ankle sprain) set to make his Pacers debut. #Suns #Pacers