meltyness

He doesn't use the internet any less either, though.

The Rust<->Typing axis mentioned as a blindspot definitely resonates.

As a novice in the language, the amount of type-inference that good Rust incorporates can make things opaque, absent rust-analyzer.

I mean, granted, but there's models, right? Surely some combination of the assessments made by financial firms and government is objective, right?

Yeah you can lint for "array-access." Logic written using iterators (streams for Java folk, comprehensions for python) doesn't fail in this way. Also still gens to very fast assembly like "looping and accessing" but with the added benefit of unambiguous terminating conditions, unless you go with fallible forms, which you can use to introduce ambiguous terminating conditions. Or if some other random access pattern is needed, implement the appropriate trait.

If you look at Lattice's design (YC W16), it suggests that the current trend in performance management is to put everyone on a PIP. This is really more in line with what constitutes "at-will" employment.

... but will the model learn when to interrupt you out of frustration with your ongoing statements, and start shouting?

it seems like for the obvious use-cases there might need to be some sort of limit on how much this component knows

Also, you "assume bad faith"? What is this?

BTW I'm probably talking to myself here, but I'm a pretty avid follower of USG activities, I think that something like this shows clear value:

https://playbook.usds.gov/

Despite the slightly pessimistic view I expressed about the general character of the most starred 18F repos which I also distinctly admitted was probably a myopic view in light of their breadth.

Not really, GSA is smart, I mean, it's 1200 repos.

For clarity though, I would think software engineers would prefer to engineer their software with software, and not a bunch of disparate rules of varying quality communicated to people passively.

I can't look at the current state of this and without wondering if it's tokenizer-dyslexia. I wonder if AI performance growth has been borrowed from overfitting and pruning the tokenizer of invalid sequences and leakage the entire corpus, a cardinal sin of making valid predictions.

That's fine, cloud was a flawed principle to begin with.

It's a bad news on Friday kind of economy out there.

I disagree on the quality. Google trends reflects a general decline of Indeed popularity, which could lead to fewer postings.

However yeah, places aren't really hiring. Absurdly gerrymandered roles and specific tech stacks point to probably more backrubs than hiring. Which is fine, if you want crony mcauthorized knuckledragger, take him, your product, your marketing, your teams, your contracts, and your whole history, and gtm.

That's probably too obscure coming and going.

Django users who would still consider an RIIR web framework, and those who are even aware of the guitar player.

Iterators, type safety, built-in CI & CD & Linting, and the borrow checker are exactly for lazy developers in my opinion.

Who wants to fight with C?Make Bazel Ninja?

When focusing on using iterators and FP, it begins to feel correct, because it begins to remove this sort of construct from the code, so then iterators are merely the logical way to adhere to DRY.

Lets go with 'layoff' or 'release' unless that's somehow worse than 'fire' in this context.

Also what if the machinery of this arm of government isn't (currently) optimizing the sum of risk-adjusted damage due to mudslides and fires? How do you propose we start over?

As much as I would like to suspect that "Edward Helmore" might have some background in Civil Engineering or statecraft more generally, it seems he's just a New York-based author who writes for a British publication, maybe he's not the best to defer for about the consequences of this area...? I mean, it's not joke, people lose homes in fires and mudslides, and it's not like Trump doesn't know this, but if the current regime isn't optimally preventing or responding to these, then your options are pretty much to just try again.

I guess this is kind of in the docs.

> The compiler prefers to capture a closed-over variable by immutable borrow, followed by unique immutable borrow (see below), by mutable borrow, and finally by move. Composite types such as structs, tuples, and enums are always captured entirely, not by individual fields. It may be necessary to borrow into a local variable in order to capture a single field [...][1]

Definitely would prefer to avoid this type of concern though. Closures are neat for filters and terminating behaviors, but I've gotten bit by these rules before, myself. Definitely best to use the parameter arguments to be sure about what the closure is gonna receive. Can achieve OK semantics with

  move |mut stat: &mut Stat| { ...

and then

  println!("num {:?}", f(stat))

[1] https://doc.rust-lang.org/1.80.1/reference/types/closure.htm...

The provisions here don't seem like an unreasonable ask, really:

https://statutes.capitol.texas.gov/Docs/BC/htm/BC.503.htm

I think Texas has some recent law that could be interpreted as being against twinning tech / deep fakes like the voice cloning. ¯\_(ツ)_/¯ seems like a good time to "ask the lawyers" and "not make a not political statement"

Even a passing glance it would be immediately clear that it's not a real risk of any sort.

It's a tool box of demos with the following:

Segment Anything 2: Create video cutouts and other fun visual effects with a few clicks.

Seamless Translation: Hear what you sound like in another language.

Animated Drawings: Bring hand-drawn sketches to life with animations.

Audiobox: Create an audio story with A1-generated voices and sounds.

You can't buy proprietary software. You can buy a specification. "my computer does this". If you're building software under agile, the outputs should be a hierarchical specification clearly traceable to code, the specification should remain clean, it could be simply the GUI in some rare, simple cases but that may be short lived, often the docs are an important part of the specification. Ideally, just a handful of high-level user stories that do not close.

Without a spec, the world falls into disarray and chance, next you need QA tests, and security auditors, and red teams, salespeople, solutions engineers, tech support, training, and a cascade of managers who try and translate "want" into "does" and "when" and to understand and accept the results. Architects and seniors who are both domain experts and skilled coders as the single truth on what the GUI is even supposed to mean. Taking on varying levels of risk with contracts, hires or expanding and contracting the previously mentioned R&D units. That's not software anymore, that's consulting. It's so expensive and unsustainable that it's only a matter of time until you're the leg that gets gnawed off, which is inevitably the result, when burn and panic (or other negative factors) leads you away from turning pain points (like issues, training, or difficult usage) into ice cubes for a cocktail.

Is adopting the manifesto a violation of the manifesto?

The one that had the gaffe about surreptitiously providing employee access to customer data? Yeah, yikes.

Does anyone know if tokenizers are pruned? That is, if a token doesn't appear in the corpus is it removed from the model? That would imply a process that leaks information about the dataset.

Right but, this isn't merely FFI code, those are via Bindgen, this is the abstraction intended to be provided to all DMA driver authors as the API, as I understand it.

Seems like the preferred interface would be a purely functional block that provides the access.

Obviously forcing callers to free means adding lints and docs. Returning borrows leaves the likelihood of entering into explicit lifetimes hell and such in calling code.

A functional interface like (paraphrasing)

  // pub fn apply_op(&mut self, FnMut(&mut T, &bindings::dma_addr_t... ))

Keeps pandora inside the box.

Not the Rust abstraction. If mutation is needed, you'd write closures into the interface, or provider borrows. It's definitely weird to barf out ownership of half of the fields.

E: I guess it sort of depends whether the handle is Copy semantics or not.

E2: I guess they're correctly leaking the resource, but I question whether they should, protections like that are kind of the whole point of using Rust to begin with.

  The caller takes ownership of the returned resources, i.e., will have the responsibility in calling `bindings::dma_free_attrs`.

Hm, doesn't this violate RAII? Does this need to be public?

While not as strict, you can filter lints by their description and apply a policy to your crate https://rust-lang.github.io/rust-clippy/rust-1.84.0/index.ht...