Are you insinuating those 1970s fonts takeout fonts aren’t actually how Chinese people communicate? I knew they were AI!

But what if your PR was created as half chat, then an agent, then some more chat planning, possibly in a new chat to clear the context? I think my teammates would find my inner monologue rather confusing at times.

The sequence of commits I present a purely optimized for reviewing, and not an actual record of what happened. I’m not going to read another person’s 100 turn slop factory, because they couldn’t express their change in one paragraph.

Yeah, my solution to this problem has been to get Claude to use jj to create a clean commit history. Each commit serves a single purpose and includes what drove the decisions we made. You lose the noise and still have the meaning.

So I'm a little unclear as to benefit of this. It sounds...wasteful?

What does jj specifically enable for that workflow?

It drastically simplifies the process.

Redescribe, reorder, split, squash, abandon commits is trivial.

Auto-rebasing is fantastic, fix a conflict once and not have to keep correcting.

You can rebase individual commits, ranges of commits, etc. You can also rebase trees I.e. forking branches with a common ancestor, with a single command.

The operation log also makes it feel super safe. You can always undo a jj operation or restore to a past state

Too bad there’s such a lingering culture of Windows and creaky Lenovos and Dells around it. I’m sure it can be different, but I’m not taking my chances ever again. Simply not worth my sanity.

That is not my experience. Sure, the background of .NET is windows, but in the last decade or so it opened up to other platforms, and so many shops prefer deploying their .NET based applications to linux for multitude of reasons. Along with this comes linux oriented culture. So windows culture is not tied to .NET per se, more so tied to certain shops I would say. Speaking from anecdotal experience, I have no numbers on this :)

It is different. I do nearly 100% of my .NET development on macOS, only dropping into Windows to support .NET Framework users of open-source projects I work on, and we deploy exclusively now on Linux containers. The apps I maintain haven't touched a Windows server in years. My colleagues (and OSS co-maintainers) use a mix of macOS, Windows, and Linux. I use Rider instead of Visual Studio.

The only time I've been forced into a "culture of Windows and creaky Lenovos and Dells" recently was on a Java project. (Anecdotally, of course. Java has a similarly cross-platform culture as a whole.)

Not sure when your last foray into the .NET ecosystem was, but every since it is xplat and unified (.NET 5 probably) it is a real joy. I use VSCode as IDE for C# on my mac, and deploy to Linux.

I've been using .NET almost exclusively on Linux since it was called .NET Core 2.0, and development platforms other than Windows do feel like second class citizens. Any time you venture into anything remotely advanced, the tooling is usually Windows only.

"Everything" expects you to use MSSQL, even if today there's ok official support for PostgreSQL and SQLite. Most "thought leaders" of various sorts are on Windows and expect you to use it. This pervades throughout the ecosystem.

Can't see this ever changing as it's not in MS' interest to turn other operating systems into good .NET development platforms.

I can't even remember the last time I used MSSQL with .NET. I'm embarrassed that I worked on projects now that were paying huge sums for licenses when .NET works so absolutely well with every other DB.

These days I just use EF with Sqlite on 99% of my projects.

I do all my dev in .NET on a mac, using Postgres and Sqlite only, so I don't relate to your experience at all. It's dead simple for me and I'm not even that good of a developer.

I used .NET for many years with Postgres on a huge project. Honestly, I don't know what you mean. Can you break down "Everything" a little. What is it that expects MSSQL? Who are the thought leaders pushing it?

I'd say Microsoft's revenue related push with .NET these days is to try to subtly nudge you into Azure (where MSSQL is rare and Windows is virtually non-existent). But, I also think they know they will kill .NET if they go overboard with it as the competition is strong.

I'm sure you know more about this than me, but EF works fine with SQLite for a project I work on. There are limitations, but I think there's a difference between the idea of EF deliberately not implementing some features for SQLite and SQLite itself not having support for some EF features (which is the reality I'm familiar with).

SQL Server is the flagship database project on the Microsoft side and that team surely has some imperative to facilitate the EF vision. It simply must be less of a priority for the PostgreSQL and SQLite maintainers to do so. Is that really a valid dig on the .net ecosystem, though?

Incidentally, I'm seriously considering dropping EF. The ability to apply migrations is nice. I find the means of authoring them to be arcane and capricious. Not having to write every simple query is nice, but it gets really hard to do complex or high performance stuff. After a decade of using this thing, I find myself fighting the Entity tracker more and more and now I'm seriously questioning if it's really all worth it.

I use EF now - but only for the string interpolation in Database.SqlQuery and Database.ExecuteSql. We don't use POCOs but instead use XML and JSON with Linq.

It's really the navigations that make EF a problem. I've built a typed object graph database on top of Sqlite that works really well specifically because it's in Sqlite, so the overhead of the 1+N query problem with recursively descending navigations isn't a big problem. But it requires lazy loading and that requires all the navigation to happen inside a single service scope and that makes sequencing some things get difficult (can't just pass the results around willy nilly).

The navigation system in EF is where all of the pain points originate. All of my troubles with getting the migration generator to work are because I'm trying to express rather complex relationships. For example, to store a record representing a property on an object, I need to have two foreign keys from the Properties table to the Types table: one for the type of the property and one for the type in which the property lives. Types themselves have many relationships to other types: their base type, interface types they implement, generic type parameters, constraints on generic type parameters (actually, haven't even implemented that one as is too much).

I'm generally happy with the performance and expressivity of the system I've developed so far, but damn, it came with a lot of pain.

To be fair, in EFcore (other than EF) lazy-loading and auto-navigation is not on by default - you opted in at some point (with all its trade-offs). EFcore differs from traditional EF that they removed a lot of the magic or made it opt-in, and you can use EFcore as a very basic/thin query engine similar to Dapper.

I think for most projects, add an ORM only after you start getting really annoyed and understand what you are trading.

He didn't say you can't use Linux or MacOS, he said there's still a culture of being Windows and Microsoft only across .NET shops. As an ex .NET dev I can confirm, the community is quite close minded, language is awesome.

I think it's changing a lot recently. Our eng team of ~150 has been fully macos for several years now and we've deployed to Linux for ten.

This.

The community is being diluted by…a different demographic!

Including the internal Microsoft community

do you mind sharing the company name?

Why do I care if other shops are Windows-only? The language and ecosystem are phenomenal and Linux support is first-class.

> As an ex .NET dev

Just curious.. what language(s) are you using now?

I landed in a web3 Node, Typescript startup so... Not great. But it allowed me to see an entirely different world so I can't complain.

Note that Linux often runs on Lenovos and Dells, some of which may be creaky. I guess you are saying you prefer macOS.

I do .NET dev exclusively on a mac completely within Visual Studio Code and it's by far the easiest and most enjoyable framework and ecosystem I've had the pleasure of working in. I couldn't be happier with it.

Have you tried Rider?

Obviously, don't use it if you don't want to and don't have to. It is not worse than Go or Java however which is its only meaningful competition.

We've banned this account for repeatedly posting abusive comments and ignoring our appeals to stop. If you don't want to be banned, you can email us and demonstrate an intention to observe the guidelines. https://news.ycombinator.com/newsguidelines.html

> You don't blame a knifemaker for somebody getting cut by a sharp knife. AI is a knife. Very handy, very dangerous. We have to use them safely, that's all there is to it.

If I grossly neglected to maintain live deadly bacteria in my containment facility, am I absolved of blame? Since, you know, the bacteria is the real bad guy who should be put in jail?

Until everybody’s AI talks to everybody’s AI and tokens will be churned with no utility, and all the valuable business meetings will happen face to face behind closed doors.

Yeah. We are definitely headed to a world where, more than ever, success is determined simply by whether or not you're allowed through the closed door.

> The letters you already know, telling you what they sound like

So… letters?

If you think a cryptographically signed image can’t be JPEGed 5 times and shared on Facebook for misinformation then here’s a relevant XKCD for you:

https://imgs.xkcd.com/comics/security.png

No no the invisible hand of the market will fix it, you see. Car manufactures will become so big and pay so many taxes that we could pave every road with rail.

The cool thing about polars is that you can conditionally collect expressions over many layers of business logic, and then compute the result at the end. Doing this in SQL ends up in a hodgepodge of strings and trimmed ends to please the syntax. You can also pretty effortlessly write quite complex conditionals directly in polars, and bridge it easily to the surrounding python.

I find that SQL is only easier to read with minimal abstraction, but as soon as the project gets bigger SQL becomes an unwieldy island of different that has served its purpose after we’re done with reading/writing the data.

This sounds interesting! Do you have a specific example by any chance or blog post/doc references?

It’s just the lazy/expression part of the API, which is really the bread and butter of polars, rather than just being “replacement syntax” for pandas. This allows you to tap into abstraction that SQL can’t keep up with:

  import polars as pl

  # 1. Base Dataset
  lazy_df = pl.LazyFrame(
    {
      "store_id": ["S01", "S02", "S03", "S04", "S05"],
      "revenue": [5000.0, 2400.0, 15000.0, 900.0, 3200.0],
      "margin": [0.45, 0.30, 0.60, 0.15, 0.50],
      "tx_count": [120, 45, 300, 20, 85],
      "returns": [5, 12, 45, 2, 8],
    }
  )

  # 2. Define Layer Abstractions
  def get_kpi_layer() -> list[pl.Expr]:
    return [
      (pl.col("returns") / pl.col("tx_count")).alias("return_rate"),
      (pl.col("revenue") / pl.col("tx_count")).alias("avg_order_value"),
    ]

  def get_threshold_layer(thresholds: dict[str, list[float]]) -> list[pl.Expr]:
    return [
      (pl.col(col) > limit).alias(f"is_{col}above{int(limit)}")
      for col, limits in thresholds.items()
      for limit in limits
    ]

  def get_interaction_layer(numeric_cols: list[str]) -> list[pl.Expr]:
    return [
      (pl.col(a) / (pl.col(b) + 1e-5)).alias(f"ratio_{a}per{b}")
      for i, a in enumerate(numeric_cols)
      for b in numeric_cols[i + 1 :]
    ]

  def get_segmentation_layer() -> list[pl.Expr]:
    return [
      pl.when(pl.col("margin") > 0.4)
      .then(pl.literal("High"))
      .otherwise(pl.literal("Low"))
      .alias("margin_profile")
    ]

  # 3. Consolidate and Execute Single Graph Pass
  thresholds = {"revenue": [1000.0, 5000.0, 10000.0], "tx_count": [50, 100, 200]}
  numeric_cols = ["revenue", "margin", "tx_count", "returns"]

  expr_pool = [
    *get_kpi_layer(),
    *get_threshold_layer(thresholds),
    *get_interaction_layer(numeric_cols),
    *get_segmentation_layer(),
  ]

  final_df = lazy_df.with_columns(expr_pool).collect()

awesome, thanks!

Well, I prefer the polars version. And now if I want to reuse the CTEs elsewhere, I have to reach out to another tool like DBT or hand roll something to do string manipulation.

... does it? I don't think it does, even in this form.

And now write it such that all the conditions and transformations are injected into the string (somehow) rather than written in explicitly. Much worse.

Really? You've written out all the ratios and thresholds manually. If a user wanted to change the set of thresholds the polars way is far superior. In what way do you consider this better?

I don't know if my code is just "complex", but I find that Luna on max ignores the surrounding style and completely ignores logical consequences of a change, like just writing `del arg1, del arg2, ...` instead of dropping it from the surrounding code. All LLMs make questionable decisions at times, but Luna requires so much guidance that it's faster to just type it out yourself. What kind of routine tasks can one accomplish with such a model?

Do you have code formatters, linters and static analysis?

I can get extremely dumb models to get our code style correct because of those guard rails and a specific style document.