TeamDman

Important formatting has been lost on this page in section 14.

What alternative do you propose for downloading binaries off the internet, placing them in the "right spot" and doing post-install operations like updating PATH that dont have gotchas equivalent to running "untrusted" code like curl|sh?

I've found LLMs decrease the friction in enabling more pedantic lints and tooling. It is a quantity problem because enabling all the aggressive warnings in the compiler makes a lot of work, and its a quality outcome because presumably addressing every warning from the compiler makes the code better

I use Rust for command line applications.

I find that CLI is a great way to model problems. When I find myself doing something that has graduated beyond a comfortable amount of PowerShell, Rust is there for me.

I have a template I've been evolving so it's super easy to get started with something new; I just copy the template and slam Copilot with some rough ideas on what I want and it works out.

https://github.com/teamdman/teamy-rust-cli

Just today used it to replace a GitHub stats readme svg generator thing that someone else made that was no longer working properly.

https://github.com/TeamDman/teamy-github-readme-stats

Decomposes the problem very nicely into incrementally achievable steps

1. `fetch <username>` to get info from github into a cache location 2. `generate <username> <output.svg>` to load stats and write an svg 3. `serve` to run a webserver to accept GET requests containing the username to do the above

Means that my stuff always has `--help` and `--version` behaviours too

I enjoyed Dave Cridland's comment more than the article. The article is dismissive of AI and other technologies in an unsubstantiated way.

New things are happening and it's exciting. "AI bad" statements without examples feel very head-in-sand.

for 50,000 rows I'd much rather just use fzf/nucleo/tv against json files instead of dealing with database schemas. When it comes to dealing with embedding vectors rather than plaintext then it gets slightly more annoying but still feels like such an pain in the ass to go full database when really it could still be a bunch of flat open files.

More of a perspective from just trying to index crap on my own machine vs building a SaaS

See also: using Mathematica for drawing the circles like in the movie Arrival

https://youtu.be/r8nTifCIr0c

I found https://docs.rs/bstr/latest/bstr/#file-paths-and-os-strings to be useful

Neat! Have a repo?

Python dependency management sucks ass. Installing pytorch with cuda enabled while dealing with issues from the pytorch index having a linux-only version of a package causing shit to fail is endlessly frustrating

A good ecosystem has lockfiles by default, python does not.

Neat link, thank you for sharing.

Neat! Must be very satisfying for this to be working now. I wonder if it's feasible to get it working on a multi threaded runtime

Tried it out, very cool! Fun to see it chugging on a bunch of rows. Had a weird issue where it would recompute values endlessly when I used it in a table, but I had another table it worked with so not sure what that was about

If incentives to stay outweighed leaving, people would stay.

I was unable to find any section titled "disclaimers" other than one saying "The authors have no financial interest to declare in relation to the content of this article."

Is there something specific you are trying to point at?

It took much more than 24 words to achieve the final result, and also had to use emojis to convey what I wanted lol

Even still I couldn't quite get the result I wanted

Image link

https://chatgpt.com/share/67769bef-537c-800f-90ac-35a44747f0...

I've recently been summarizing entire directories into a single chunk of text for use with Gemini, the other day I overshot and ended up pasting 28 million characters into vscode. It handled it pretty well.

Is this the AWS thing you referenced? https://aws.amazon.com/what-is/automated-reasoning/

very neat but already hitting cases where it doesn't play nice with pwsh scripts, even using the shebang. Back to using a dir full of .ps1 files I guess lol

Swift does apparently, here's an example from ChatGPT

    enum Animal {
        case dog(name: String)
        case cat(name: String)
        case bird

        func sound() {
            switch self {
            case .dog(let name):
                print("\(name) says Woof!")
            case .cat(let name):
                print("\(name) says Meow!")
            case .bird:
                print("Tweet!")
            }
        }
    }

    enum Thing {
        case first(x: Int)
        case second
    }

    enum Outer {
        case ok(Thing?)
    }

    let value: Outer = .ok(.some(.first(x: 42)))

    switch value {
    case .ok(.some(.first(let x))):
        print("Matched with x = \(x)")
    case .ok(.some(.second)):
        print("Matched .second")
    case .ok(.none):
        print("Matched .none")
    }

Reading the history of the Grant Matcher puzzle has given names to some concepts that I have brushed against but haven't deeply explored.

https://capnproto.org/rpc.html led me to http://erights.org/elib/equality/index.html led me to http://erights.org/elib/equality/grant-matcher/index.html led me to (the submitted link) http://erights.org/elib/equality/grant-matcher/history.html

I mean, with a nonzero temperature, the randomness will eventually produce every combination of tokens in the corpus, so with a sufficiently large "all the time you want" you can produce limitless correct answers

Would probably try https://github.com/pola-rs/polars and go from there lol

The expansion-contraction of information as it passes between systems is interesting. Json takes more space than a binary protocol, but it is a more human friendly representation.

Programming languages are a moderately unambiguous way to describe procedures and transformations, but natural language can be more concise.

I wonder if language will drift and become more personalized with ai enabling easy translation between language islands

On the topic of AI web browsers, a feature to audit the people whose comments I read would be an interesting feature. Also made me think of: https://www.reddit.com/r/OutOfTheLoop/comments/94638i/what_i...

To avoid data loss in prod, you best be using

    lifecycle {
        prevent_destroy = true
    }

trying to get some old module to work in a new cloud environment where a bunch of assumptions about how things are done no longer apply

Square hole type energy. Just because you can coerce the code to run doesn't mean it's a good idea.

New environment, new assumptions, new code. Copy-paste what's relevant, but in a new project.

getting totally confused because what they see in the code doesn’t match reality

Terraform compares state to detect drift? When reality doesn't match code, you clobber reality or you update the code.

It Prevents Drift!

This is true if and only if, you only ever, ever, ever, create code to change things in your environment.

It at least makes drift obvious, even if it requires attention for it to be addressed.

code is, in my opinion, really not good at being documentation

Unlike comments, IaC "can't" be inaccurate after applying.

But in my experience, the effort to keep your code up-to-date is a sink for engineering time.

If the code is out of date, it's because you made a click change and didn't update the code. When this happens, terraform tells you exactly what changed in simple scenarios, and in more complex scenarios you can use import blocks to rein things in.

Yes it’s a clickbait headline. You clicked on it, didn’t you?

Got me good. The article is a good launchboard for discussion.

Overall, the IaC scene has plenty of room for growth. Terraform import blocks and code generation is helping reduce the problem of "I clicked in the portal now I gotta update the code" because you can sync both ways. Code updates infra, infra can be used to generate code.