URL: https://inthesetimes.com/

RSS:

The post In These Times first appeared on 🍙.

URL: https://www.leftvoice.org/

RSS: https://www.leftvoice.org/feed

• Haley Stevens’ Endorsement of Republican Mike Rogers Signals Deep Divide within the Democratic Party
• Gen Z Shakes Up Europe: A Portrait of a Generation Storming Heaven
• The Fragmentation of MAGA and the Crisis of Trumpism
• Nurses Fought Back and Won: Sarah Dowd Reinstated With Full Back Pay
• Ballot Questions in Massachusetts Showcase Need for Workers Democracy

The post Left Voice first appeared on 🍙.

URL: https://geesemag.com/

RSS: https://geesemag.com/feed.xml

• Yes, Communism! Part II: Communism is more American than Trump 
• Yes, Communism! Part I: An American Communist Talks Back
• Carceral Municipalism and the Socialist Left’s Rehabilitation of the Prison-Industrial Complex (Part 2)
• Carceral Municipalism and the Socialist Left’s Rehabilitation of the Prison-Industrial Complex (Part 1)
• To Steal an Election: The War on Mail-In Voting

The post geese first appeared on 🍙.

URL: https://jacobin.com/

RSS: https://jacobin.com/feed

• Life Beneath the Melting Glaciers
• How Workers Can Govern in Zohran Mamdani’s New York
• Let Andreas Malm Speak
• 100,000 California State Workers Struck Last Month
• The US Electorate Is Permanently Mobilized and Unable to Move

The post Jacobin first appeared on 🍙.

Move as much of the correctness problem as possible from “the LLM has to remember to do it right” into “the language makes wrong programs difficult or impossible to express.”

Recent research supports this direction: type-constrained generation, for example, has been shown to substantially reduce compilation errors in LLM-generated TypeScript and improve functional correctness. (DOI)

Features I’d prioritize

The really interesting ones are the last few layers.

1. Algebraic data types + exhaustive matching

Instead of:

status = 0   // maybe pending
status = 1   // maybe success
status = 2   // maybe failure

you have:

Status =
    | Pending
    | Success(Data)
    | Failure(Error)

Then:

match status:
    Pending       -> ...
    Success(data) -> ...
    Failure(err)  -> ...

If the LLM adds another variant, the compiler can point out every place that needs updating.

This creates a very useful feedback loop for an LLM:

model makes change → compiler identifies consequences → model fixes consequences.

That is much better than expecting the model to mentally discover every consequence.

2. Refinement types

This is even more powerful.

Instead of:

age: Int

you could have:

age: Int where 0 <= age <= 150

or:

NonZeroInt

or:

Index(array.length)

Now the language carries some of the meaning of the program, rather than merely its data representation.

Refinement types explicitly add logical predicates to ordinary types, allowing the type checker to enforce properties about values. (DOI)

This is particularly attractive for LLMs because it turns:

“Remember that this value must never be zero.”

into:

“The compiler won’t accept a value that violates this.”

3. Contracts

You can go another step:

fn divide(a: Int, b: Int) -> Int
    requires b != 0
    ensures result * b == a

Now the LLM doesn’t have to reason solely from comments and function names.

The interface itself describes the correctness conditions.

Some newer language experiments explicitly combine contracts, refinement types, ADTs, and compiler verification for this purpose. (GitHub)

4. Explicit effects

This is an underrated one.

Imagine:

fn calculate(x: Int) -> Int

versus:

fn calculate(x: Int) -> Int
    effects { IO, Database }

The second tells the LLM that calling this function isn’t just computation—it has externally visible consequences.

You could potentially distinguish:

pure
IO
network
filesystem
database
mutation

This makes action at a distance much harder.

Several newer AI-oriented languages are explicitly experimenting with this sort of design, including explicit effects, ownership, and algebraic errors. (GitHub)

The really interesting design principle

I would actually organize the language around a hierarchy:

Syntax
   ↓
Types
   ↓
Data invariants
   ↓
Resource invariants
   ↓
Effect invariants
   ↓
Behavioral contracts
   ↓
Tests / formal verification

At each level, the language gives the LLM more information and fewer ways to be wrong.

For example:

Int

is weak.

NonZeroInt

is stronger.

UserId

is stronger still.

ExistingUserId

is stronger.

And:

ExistingUserId
    requires user.exists

starts getting into actual behavioral verification.

There’s another feature I’d put unusually high on the list

Make the compiler’s error messages extremely machine-readable.

For an LLM, this:

error[E042]:
  expected: NonEmptyList<User>
  found: List<User>
  at: users[37]
  reason: list may be empty
  suggested fixes:
    - check for empty list
    - use `head?`
    - establish `length > 0`

is vastly more useful than:

Type mismatch.

In other words, the compiler becomes part of the LLM’s reasoning system.

That’s an important distinction. You don’t necessarily need a language where the LLM magically writes perfect code. You want a language where:

the LLM can cheaply propose code, and the language can cheaply tell it exactly what is wrong.

Research on constrained decoding is moving in essentially this direction: rather than merely asking an LLM to generate valid code probabilistically, the generation process itself can be constrained by the language’s formal rules. One 2025 study found that type-constrained decoding reduced compilation errors by more than half. (DOI)

If I were designing an “LLM-native” language

I’d probably combine:

Rust

• ownership
• borrowing
• strong static types

Haskell/ML

• algebraic data types
• pattern matching
• type inference

Idris/Liquid Haskell-style systems

• dependent/refinement types
• proofs

Effect systems

• explicit side effects

Design by contract

• preconditions/postconditions

LLM-specific additions

• extremely regular syntax
• minimal number of equivalent idioms
• highly structured compiler errors
• machine-readable AST
• automatic test generation
• incremental compilation
• explicit interfaces
• APIs whose types encode as much semantic information as possible

There are already projects explicitly exploring this premise—for example, Almide describes itself as a statically typed language optimized around LLM code generation, while Promise is designed around explicit ownership, effects, errors, and “one obvious way” to express things. (GitHub)

The deeper idea is that programming languages for LLMs may want to optimize not for human typing speed, but for the ratio of semantic information conveyed per token and incorrect programs rejected by the compiler.

That’s a potentially very different programming-language design target from conventional languages.

Yes. I’d expand the comparison to include the major mainstream languages plus several languages that are especially interesting from the “LLM-friendly language design” perspective. The 2025 Stack Overflow survey includes Python, JavaScript, SQL, Java, C++, C#, TypeScript, PHP, Rust, Go, Lua, Kotlin, Swift, Ruby, Dart, and many others among its surveyed languages. (Stack Overflow Developer Survey)

Here is the table in the format you requested. “Has it” means the language provides the feature in a meaningful built-in language/type-system form; “doesn’t” means it lacks it or requires a library/convention rather than the language enforcing it.

* TypeScript’s strictNullChecks can provide strong null checking, but JavaScript interoperability and escape hatches mean it isn’t equivalent to Rust/Elm’s guarantees.

The languages I’d include in the experiment

For what you’re investigating, I’d divide them into four groups:

Mainstream languages

• Python
• JavaScript
• TypeScript
• C
• C++
• Java
• C#
• Go
• Rust
• Swift
• Kotlin
• PHP
• Ruby
• Dart
• Lua

Functional/type-system languages

• Elm
• Haskell
• F#
• OCaml
• Scala
• Clojure
• Elixir
• Erlang

Systems/newer languages

• Zig
• Nim
• D
• Crystal

Languages specifically interesting for extreme correctness

• Ada/SPARK
• Idris
• Lean
• Coq
• F*
• Dafny
• Liquid Haskell
• Koka
• Pony

The distinction is important because the most popular languages aren’t necessarily the most useful ones for investigating LLM-oriented language design. For example, Rust is especially interesting because its ownership and borrow-checking system gives the compiler substantial ability to reject incorrect programs; Stack Overflow’s 2025 survey also reports Rust as the most admired programming language. (Stack Overflow Developer Survey)

If our ultimate goal is to answer “Which language features actually make LLM-generated programs more correct?”, I’d narrow the next table to perhaps 25–30 features and put each language as a column. That would produce a much more useful matrix:

That matrix would let us do something particularly interesting: look for combinations of features that give an LLM the strongest compiler feedback loop and therefore potentially make an LLM-native programming language substantially more reliable.

The post ChatGPT: Language Features that Help LLMs first appeared on 🍙.

Static, expressive type systems

Types act as a machine-checkable specification the model can read before writing anything. Function signatures tell the model what goes in and out, so it doesn’t have to guess. Features that help most:

• Sum types / tagged unions and exhaustive pattern matching (Rust, OCaml, Haskell, Swift, Kotlin sealed classes). The compiler forces every case to be handled, which is where LLMs often slip.
• Option/Result types instead of null and exceptions. Failure paths are visible in the signature rather than implicit.
• Generics with clear constraints, which prevent whole categories of mixing-up-types bugs.

Note that the type system helps twice: once as context while generating, and again as a filter afterward. In a true one-shot setting only the first benefit applies, unless you count “compiles” as part of correctness.

Explicitness over magic

LLMs do best when the code says what it does locally. That means:

• Few implicit conversions and coercions (JavaScript’s == and Python-style truthiness are classic trip hazards).
• Explicit imports and clear module boundaries, so the model doesn’t hallucinate where a name comes from.
• Minimal metaprogramming, decorators that rewrite behavior, monkey-patching, and macros with surprising expansion.
• Explicit error handling and resource management (Rust’s ownership, Go’s if err != nil, RAII, with blocks) rather than hidden control flow.

Immutability and controlled side effects

Immutable-by-default data (Rust, Clojure, Elm, Haskell) means the model doesn’t have to track what mutated what across a long function. Purity or effect tracking narrows the things that can go wrong to the function’s inputs and outputs, which fits neatly in what the model can hold in mind at once.

Local reasoning and small semantic surface

Languages with fewer ways to do the same thing (Go is the archetype) produce more predictable output. If there’s one idiomatic way to loop, handle errors, or structure a package, the model’s training data converges on it and it rarely picks a wrong variant. Compare this to C++ or Perl, where the valid dialects vary widely.

Strong conventions and standardized tooling

A single canonical formatter, package manager, and project layout (gofmt, cargo, mix) removes decisions the model could get wrong. Stable, well-documented standard libraries help too, since the model can rely on APIs that haven’t shifted between versions.

Safety guarantees that remove subtle bug classes

Memory safety, no data races (Rust), bounds checking, and no undefined behavior remove errors that are hard to see by reading the code. C and C++ are the opposite: code that looks right can be wrong in ways neither the model nor a casual reviewer will notice.

Executable specifications inside the language

Contracts, refinement types, dependent types (Idris, Lean, Liquid Haskell), and property-based testing hooks let you state what the code should do in the language itself. These are still niche, but they’re the most direct way to make “correct” checkable rather than hoped for.

The counterweight: training data volume

All of the above competes with a practical factor. A language the model has seen enormous amounts of (Python, TypeScript, JavaScript) will often yield working code more reliably than a theoretically safer but rarer language (Haskell, Idris, newer languages). This is why TypeScript is a sweet spot: lots of training data plus a decent type system. Rust is a strong case too, though borrow-checker errors are a common first-shot failure, since lifetimes require global reasoning.

Rough ranking of “helpfulness” by feature

1. Rich static types with exhaustive matching
2. Explicitness and lack of implicit behavior
3. Immutability and limited side effects
4. Small, conventional language surface
5. Abundant training data and stable libraries

If you’re choosing a language for LLM-generated code specifically, TypeScript, Go, Rust, and Kotlin tend to be good practical picks, each for different reasons. Python is very reliable for short scripts but gives up the safety net as programs grow.

A few caveats on the table:

• “Has it” is sometimes a matter of degree. Python’s match exists but isn’t checked for exhaustiveness, and TypeScript can approximate exhaustiveness with never checks but doesn’t enforce it by default.
• Some languages appear in both columns of different rows for good reason. Rust has proc macros (so it’s listed as heavy on metaprogramming) but also excels at nearly everything else here.
• Languages with the most checkmarks aren’t automatically best for one-shot generation, since training data volume still matters a lot.

The post Claude: Language features that help LLMs first appeared on 🍙.

To get the Mail offers, go to Proton Mail, and then click the “space usage” stats in the lower left corner.

To get the Drive offers, go to Proton Drive, and click the space usage stats in the lower left corner.

Here’s a peek at the two options:

Mail Plus gets you full featured mail, but only 15GB of total storage.

Drive Plus 200 gets you webmail-only, and 200GB of total storage.

I’m going to get the Mail Plus package, because my personal goals include:

• Reducing my online footprint, to avoid risks related to having data sitting on a server.
• Reducing how much I spend.
• Moving email off of the online platforms when possible.

The post Proton Pricing: Mail vs. Drive first appeared on 🍙.

The post Crossword Puzzle first appeared on 🍙.

1. Jack in the Box – Free Jumbo Jack

• Trigger: Dodgers pitchers record 7+ strikeouts in a game.
• Offer: Free Jumbo Jack with purchase of a large drink.
• Redemption: Use code GODODGERS26 in the Jack in the Box app or at participating stores.
• Status: Active today — Dodgers struck out 9 batters in their last game lahomewin.com.

2. McDonald’s – Free 6-Piece Chicken McNuggets

• Trigger: Dodgers score 6+ runs in a home game.
• Offer: Free 6-piece McNuggets with a $2 minimum purchase.
• Redemption: Look for the deal in the McDonald’s app under “Rewards & Deals.”
• Status: Not active today — Dodgers scored only 3 runs in their last game lahomewin.com.

3. Panda Express – $7 Panda Plate

• Trigger: Dodgers win a home game.
• Offer: $7 two-entree Panda Plate (code DODGERSWIN in Panda Express app).
• Requirements: Panda Rewards membership; one plate per account per day.
• Status: Not active today — last triggered before a home win lahomewin.com.

4. Habit Burger & Grill – Free Double Char

• Trigger: Dodgers turn a double play in a 2026 regular-season home game.
• Offer: Free Double Char with $8+ qualifying purchase.
• Redemption: Use code DODGERS26 in the Habit app or MyHabit account.
• Status: Not active today — last triggered before a double play lahomewin.com.

5. AMPM – Free Hot Dog + Soda

• Trigger: Dodgers steal a base in a home game.
• Offer: Free hot dog + 16 oz Coca-Cola.
• Redemption: Through the AMPM app at participating Los Angeles County stores.
• Status: Not active today — last triggered before a stolen base mealsteals.co.

Current Angels Food Deals

The Los Angeles Angels’ official partner offers are active: McDonald’s gives free medium fries after wins, and Del Taco offers free tacos after 5+ runs at home mealsteals.co+1.

1. McDonald’s – Free Medium Fries

• Trigger: Angels win (home or road) MLB.
• Redemption: Next day, with a $2 minimum purchase in the McDonald’s app.
• Requirements: Must be registered in the McDonald’s Rewards program under the public Angels partner terms mealsteals.co+1.
• Area: Greater LA/Orange County DMA.
• Tip: The offer appears in the McDonald’s app under “Rewards & Deals” — no code needed.

2. Del Taco – Free “The Del Taco”

• Trigger: Angels score 5+ runs in a home game mealsteals.co.
• Redemption: Next day, with any purchase through the Del Yeah! Rewards app (no code required) mealsteals.co.
• Area: Greater LA area (LA, Orange, Riverside, Ventura, San Bernardino counties) www.irvinesrealtor.com.
• Tip: Check the Del Taco app before ordering, as availability can change season to season.

3. Juice It Up! (Seasonal)

• Trigger: Angels record a save in a home game www.irvinesrealtor.com+1.
• Redemption: Next day, via a code in the Juice It Up! app (exclusive reward) www.irvinesrealtor.com+1.
• Area: Angel Stadium, Anaheim.

Lakers season is over, but here were the past deals

Current Lakers Fast Food Deals

The Lakers’ main fast food deal right now is a Jack in the Box promotion tied to Lakers game results, with two free tacos available through the Jack in the Box app.

Active Lakers Deal

• Promotion: Jack in the Box – Two free tacos with any drink purchase.
• Trigger: Lakers win and opponent scores under 111 points.
• Redemption: Must use the Jack in the Box app; code may vary by season. Public posts have shown different codes in past years, so check the app before ordering mealsteals.co.
• Frequency: In the 2025–26 regular season, this trigger happened in 25 of 82 games (30.5%), including 13 of 41 home games mealsteals.co.

Other Lakers-Linked Offers

• DoorDash NBA50 (League-Wide): $5 off $15+ DashPass orders the day after any NBA player scores 50+ points in a regular-season game. While not Lakers-specific, it’s a common post-game option if you’re ordering Lakers tickets or snacks mealsteals.co.

How to Redeem

1. Check the Jack in the Box app for the current code and terms.
2. Ensure the Lakers have met the win + opponent score condition.
3. Order your drink and tacos through the app to claim the free items.

Tips

• Deals are sports-triggered, so they only activate after a Lakers game ends.
• If you’re in Rosemead, Jack in the Box locations are nearby; use the app’s map to find the closest.
• For the best chance, watch the game and check the app right after the final buzzer.

If you want to be notified instantly when a Lakers deal fires, Meal Steals tracks these triggers and sends alerts without requiring a sign-up mealsteals.co.

LAFC Fast Food Deals & Promotions

LAFC fans can currently claim free or discounted food at Chick-fil-A SoCal and Ono Hawaiian BBQ after specific game outcomes, with redemption tied to the LAFC app or online ordering.

1. Chick-fil-A SoCal – Free Chicken Sandwich

• Trigger: LAFC wins a home game at BMO Stadium.
• Redemption: Claim in the Chick-fil-A app before leaving the stadium, then redeem within 3 business days at a participating Los Angeles-area location LAFC+1.
• Requirements: Must be at BMO Stadium, app open, location services enabled, and claim by 11:59 PM on game night mealsteals.co.
• Item: Free Original or Spicy Chicken Sandwich.
• Active period: Aug 11 – Nov 7, 2026 www.dealsonmeals.app.
• Tip: Check the Chick-fil-A app before the game to confirm the offer is live.

2. Ono Hawaiian BBQ – $5.99 Chicken Plate

• Trigger: LAFC scores the first goal of the first half at a home game.
• Redemption: $5.99 Chicken Plate Lunch the next business day using code LAFCSCORES via online ordering for registered users mealsteals.co+1.
• Requirements: Must be at a participating Ono Hawaiian BBQ location in the Greater Los Angeles area.
• Note: This is a limited-time, online-only redemption.

3. Other LAFC Promotions

• Planet Fitness: Sign up for a Classic Membership for $1 down with code BLACKANDGOLD LAFC.
• Hotel Indigo Los Angeles Downtown: Stay and Dine package with LAFC-inspired menu credit LAFC.
• Theme Nights & Giveaways: Events like Noche LÁFC and Hello Kitty Night are also part of LAFC’s promotional calendar www.getpromonight.com.

How to Redeem

• Chick-fil-A: Use the Chick-fil-A app to claim in-stadium, then redeem at a participating restaurant.
• Ono Hawaiian BBQ: Order online with the code LAFCSCORES the next business day.
• Check before you go: Terms, codes, and app requirements can change during the season

LA Galaxy Fast Food Deals

When LA Galaxy scores at home, NORMS Rewards members can get a free stack of Buttermilk Hotcakes at participating NORMS locations scoregrub.com+1.

How the deal works

• Trigger: Galaxy scores at least one goal in a home match.
• Redemption: Free stack of Buttermilk Hotcakes for NORMS Rewards members.
• Window: Valid within 48 hours of the goal being scored scoregrub.com+1.
• Location: Any Southern California NORMS restaurant (e.g., NORMS in Rosemead and other LA-area locations).
• Method: Redeem in-app via the NORMS Rewards app after the trigger, then dine-in or order to-go at a participating NORMS location scoregrub.com.

How to get the deal

1. Download the NORMS Rewards app (Apple or Google Play).
2. Check the app after a Galaxy home game to see if the offer is active.
3. Redeem in-app and follow the prompts to get your free hotcakes.

Tips

• Only available for Galaxy home games with at least one goal.
• Must be a NORMS Rewards member to qualify.
• Deals are time-sensitive — act quickly after the trigger.
• If you’re in Rosemead, NORMS locations are close to the stadium and other LA-area spots.

Los Angeles Rams Fast Food Deals

The Rams have several active fast food promotions, including interception-based rewards at Carl’s Jr. and 4th-down stop perks at El Torito, plus stadium combo meal discounts.

1. Carl’s Jr. – Famous Star Picks

• Trigger: Rams defense records an interception during a game Los Angeles Rams+1.
• Reward: Free Famous Star® (limited-time collectible) via the Carl’s Jr. app.
• Redemption: Only in the Carl’s Jr. app (online ordering or in-restaurant with My Rewards registration).
• Code unlock: 2 days after the qualifying game.
• Validity: 1 week from unlock in the app.
• Tip: Some community posts note a variant with a large drink purchase, but official terms are interception-based Slickdeals.

2. El Torito – Rampage Nachos

• Trigger: Rams defense stops the opponent on 4th down mealsteals.co.
• Reward: Free Rampage Nachos with any food purchase.
• Redemption: Mention “RAMS NACHOS” at the El Torito location.

The post 2026 Dodgers, Angels, Lakers, LAFC, Galaxy, Sports Team Triggered Fast Food Deals first appeared on 🍙.

Symptoms: tried to open a vault in a folder that has restricted permissions. The vault starts to open, but you get an “EACCESS permission denied” error. You cannot remove it from the vault list, because the vault is partially open.

Solution: Start up Obsidian with a special “Obsidian URI”, and it’ll start with the “open vault” dialog.

flatpak run md.obsidian.Obsidian %U obsidian://choose-vault

My command looks that way because I am running Linux MINT, and installed the Flatpak version of the program.

From there, you can remove the vault from the vault list. You can then restart Obsidian, and it won’t try to open the problem vault.

Ref: https://forum.obsidian.md/t/how-to-use-the-choose-vault-uri-action-in-linux/112087/5

You can write your blog posts in Obsidian, and then paste them into WordPress. Here are some features that work:

Test test. One Star, Two Stars, Three Stars, Obsidian Link.

code

	code

Text with footnote.^[1]

• Bullet List
• Bullet 2

1. Number List
2. Number 2

• Task List
• Task 2
  

Heading 3

Table test

1. Footnote︎

The post Obsidian Notes first appeared on 🍙.