I'd guess that some years and we are predestined to see a triumph of #AI exploitation.

I'd guess there's opportunities in that area for behavioral exploitation, making it do unwanted things.

Even more so there's opportunities for scavenging "confidential leaks" from large LM's, to downright reverse engineering. Sometime in-house codebase might be seeded by mistake to a public LM...

Or hackers could exploit your network and instead of copying any data they would use LM as an indirect path to scavenge good quality enough information to meet the goals.

If I was working on offensive security like for some intelligence department, I'd put a lot of resources on exploiting the AI assistants for instance. Exploiting that functionally would open countless doors.

#infosec

@railmeat @cuchaz

Actually this nails pretty much what is wrong in politics/federal/legislation etc. side of this.

It is all about "a consumer must be able to pick a web browser". I think much more effective legislation tool for EU commission etc. would be to enforce the browser sync feature to be interoperable. Cross-browser interoperable.

That would lead into browser vendors to making a common standard for sync and world would be a better place, and more open for competition. E.g. then any open source web browser could adhere to this standard, including some antique like w3m for instance. Or browser made for old home computer.

@railmeat @cuchaz

Actually this nails pretty much what is wrong in politics/federal/legislation etc. side of this.

It is all about "a consumer must be able to pick a web browser". I think much more effective legislation tool for EU commission etc. would be to enforce the browser sync feature to be interoperable. Cross-browser interoperable.

That would lead into browser vendors to making a common standard for sync and world would be a better place, and more open for competition. E.g. then any open source web browser could adhere to this standard, including some antique like w3m for instance. Or browser made for old home computer.

Of all of call codebases I've seen, compiled and successfully tested including Symbian OS, AOSP, Chromium etc. I think just as a build #Servo is one of the worst I've seen so far. It has a nice site, progress and everything but IMHO getting nice and easy build should be a primary target.

I'll give another shot tomorrow on compiling that mess :-)

I tried for fun to do my first trials on macOS because I thought that it is Rust so everything must be great. Was a mistake that I still regret ever doing that. I don't even want to begin how badly planned it is. I'll give it a shot with my Fedora system next time.

I already said this once but if you do your work in #GNOME, for most casual business use GNOME Web is a functional tool. And it has the #Firefox sync.

I turn Firefox on, only on my leisure time. The name rings to me like s.. night club in 1st place.... i.e. not something I should eagerly use for committing any business.

Has been pretty obvious equation in my case longer than the ad-gate.

It reminds to be seen ofc whether/if Mozilla starts to do same with Firefox as Google did with Chrome, i.e. I would not hold my breath of the sync feature working forever in this open manner.

Fedora turns on Firefox prototype advertiser measurement crap by default. You probably want to turn it off. People might want to file bugs for other distributions if they've done the same.

https://bugzilla.redhat.com/show_bug.cgi?id=2297635

#firefox #privacy #fedora #redhat #linux

Like at one point trend was **** *** university degrees and open learning etc lore

Now it is like "let's replace degrees with company appointed certificates".

I find this both quite fascinating and humorous. Like comedy writing itself.

with all these #AWS, #Azure etc. developer certificates around, I wonder if there is a "zero certificates for life" #certificate that I could apply for somewhere?

My apartment is about 7 min walk from central railway station of Tampere and I get these all the time. I really have to fight myself of not fuzzing in...

In States I've yet to find a place that would serve carbonara with guanciale. Even in some fine restaurants it is quite often just bacon and pasta.

One of the best foods ever: Georgian national dish hatsapuri. Competes strongly with Portugalian street food classic prego in my charts.

@aks And also in any major open source platform: it is all about decision making and argumentation. Code itself is totally 1% club.

@aks In kernel or any other big open source project, we have had that privilege of getting code for free for decades. So we've had AI privilege before modern AI industry even existed, or even anyone pursued of that opportunity even in distant dreams. That is sort of how open source works or is the core idea.

@aks Like think of "AI assisting with writing code"

Then I'd like think that why not make better constructs so that extra computational power required for AI is pursued for something more useful computation. So from that gist I think tools should be thought off.

For me the sign that e.g. a programming language needs an AI assistant, it is not about AI replacing a human as a programmer but that there is something inherently wrong in the tool or ecosystem in the first place. This is not same as saying that ML's etc would not have any good purpose use.

@aks See the comment about 2D maze. I've found it in many cases a pretty nice tool test. If it becomes too tedious to implement, the language has no opportunity. And preferably it should be written without auto-complete or any other possible additional helpers.

@aks I’ve actually quite excited on getting back to vim from neovim but have done also some experiments like this Haskell one from 2010-11. Let’s just say that I did not pursue a career as a Haskell programmer after this ;-)

Looking back 2D maze is actually pretty good test probe for any language. It has a algorithm, I/O and graphics so it gives me fairly good evaluation how much I like or dislike a language :-)

module Maze where

import Control.Monad
import Foreign
import qualified Graphics.UI.SDL as SDL
import System.Random
import Data.List
import Data.Array

data Cell = Cell {
    top :: Bool,
    left :: Bool,
    visited :: Bool
} deriving (Show, Eq)

type Maze = Array (Int, Int) Cell

newCell = Cell {top = True, left = True, visited = False}

newMaze :: Int -> Int -> Maze
newMaze rows columns = listArray ((0, 0), (rows - 1, columns - 1)) (repeat newCell)

genMaze maze (r, c) (seed:seeds)
    | visited (maze ! (r, c)) == True = maze
    | otherwise = foldl traverse maze' ((permutations neighbours) !! index)
    where maze' = maze//[((r, c), (maze ! (r, c)) { visited = True })]
          locs = [(r - 1, c), (r + 1, c), (r, c - 1), (r, c + 1)]
          ((_, _), (rmax, cmax)) = (bounds maze)
          neighbours = [(r', c') | (r', c') <- locs,
                        r' >= 0 && r' <= rmax, c' >= 0 &&  c' <= cmax]
          index = seed `mod` (length neighbours)
          moveTo maze (r, c) (r', c')
              | visited cell'  = maze
              | r' < r = maze//[((r, c), cell { top = False })]
              | r' > r = maze//[((r', c'), cell' { top = False })]
              | c' < c = maze//[((r, c), cell { left = False })]
              | c' > c = maze//[((r', c'), cell' { left = False })]
              | otherwise = error "Invalid move"
              where cell = maze ! (r, c)
                    cell' = maze ! (r', c')
          traverse maze' (r', c') = genMaze (moveTo maze' (r, c) (r', c')) (r', c') seeds

hline :: Int -> Int -> Int -> SDL.Pixel -> SDL.Surface -> IO ()
hline x y width (SDL.Pixel pixel) screen = do
    screenWidth <- return (SDL.surfaceGetWidth screen)
    pixels <- castPtr `liftM` SDL.surfaceGetPixels screen
    forM_ [0..(width - 1)] $ \dx -> do
        pokeElemOff pixels (y * screenWidth + x + dx) pixel

vline :: Int -> Int -> Int -> SDL.Pixel -> SDL.Surface -> IO ()
vline x y height (SDL.Pixel pixel) screen = do
    screenWidth <- return (SDL.surfaceGetWidth screen)
    pixels <- castPtr `liftM` SDL.surfaceGetPixels screen
    forM_ [0..(height - 1)] $ \dy -> do
        pokeElemOff pixels ((y + dy) * screenWidth + x) pixel

main :: IO()
main = do
    startRow <- randomRIO (0 :: Int, rows - 1)
    startColumn <- randomRIO (0 :: Int, columns - 1)
    seeds <- replicateM (rows * columns) (randomRIO (0 :: Int, (max rows columns)))

    maze <- return (genMaze (newMaze rows columns) (startRow, startColumn) seeds)
    SDL.init [SDL.InitEverything]
    screen <- SDL.setVideoMode screenWidth screenHeight 32 []

    hline 0 0 screenWidth whitePixel screen
    hline 0 (screenHeight - 1) screenWidth whitePixel screen
    vline 0 0 screenHeight whitePixel screen
    vline (screenWidth - 1) 0 screenHeight whitePixel screen

    forM (assocs maze) $ \((r, c), cell) ->
        if (top cell) then do
            hline (blockWidth * c) (blockHeight * r) blockWidth whitePixel screen
        else do return ()

    forM (assocs maze) $ \((r, c), cell) ->
        if (left cell) then do
            vline (blockWidth * c) (blockHeight * r) blockHeight whitePixel screen
        else do return ()

    SDL.flip screen
    eventLoop
    SDL.quit

    where
        eventLoop = SDL.waitEvent >>= checkEvent
        checkEvent SDL.Quit = return()
        checkEvent (SDL.KeyUp _) = return()
        checkEvent _ = eventLoop

        blockWidth = 32
        blockHeight = 32
        rows = 16
        columns = 16
        screenWidth = columns * blockWidth
        screenHeight = rows * blockHeight
        whitePixel = SDL.Pixel 0x00FFFFFF

@aks It is actually a problem with many new comers to software industry. Always looking for better tools, and not enough focus on solving the *actual* problem, no matter what the tools or languages are :-)

Like CoPilot writing your Rust syntax shenanigans for you because it is too terrible mess for a humanbeing to write it by hand, is IMHO a "cult classic" of moden software development.

@aks Stuff that Ueber has done with Zig is amazing tho. This is not the same that I would disagree with the "Rust-decision", just saying that it is now industry-proven tool. I consider Ueber as "industry-proven" in this context.

@aks Because we have to deal with Rust in any case I'm just trying to make best of it I guess 🤷 So it is like "C++ thing" for me I guess. It is sort of like best practices modern C++ enforced by the compiler with a new syntax, isn't it?

@aks No and I hate learning new languages tbh :-) Latest I've learned before Rust was Python in 2005. Rust is sort of more "have to deal with" than whether it is in my own preferences,