To clarify, I mean writing scripts that generate or modify classes for you instead of manually writing them every time, for example if you want to replace reflection with a ton of verbose repetitive code for performance reasons I guess?

My only experience with this is just plain old manual txt generation with something like python, and maintaining legacy t4/tt VS files but those are kind of a nightmare.

What’s a good modern way of accomplishing this, have there been any improvements in this area?

  • tatterdemalion@programming.dev
    link
    fedilink
    arrow-up
    8
    arrow-down
    1
    ·
    7 months ago

    I’ve never needed to use a template processor to generate code. Usually a macro system built into the programming language is better for this. I think template processors are more commonly used for generating text documents.

    What problem are you trying to solve?

    • Cyno@programming.devOP
      link
      fedilink
      arrow-up
      2
      arrow-down
      1
      ·
      7 months ago

      The most common usecase is generating data models based on the database, mostly using t4 files so far. We have a non-standard way of defining some parts of it so the default MS tools don’t quite cut it (like ef dbcontext scaffold). I’ve been looking into roslyn but it seems like it might be more trouble than its worth, but default t4 doesn’t even have a proper editor and syntax highlighting so its a low bar atm.

      • TehPers@beehaw.org
        link
        fedilink
        English
        arrow-up
        3
        ·
        7 months ago

        If you’re writing C#, you could take a look into Source Generators. They’re supported directly by Roslyn I believe, and are pure C# instead of t4’s syntax. They’re often used with attributes to augment types, but I believe they can be used to generate sources on their own, and even read from a config file if you want to (or maybe even query the DB, if that’s something you want to do at build time for some reason, though I’ve never tried this).

      • tatterdemalion@programming.dev
        link
        fedilink
        arrow-up
        3
        arrow-down
        1
        ·
        7 months ago

        Is it prohibitively expensive to manually define your data types? How many do you have?

        I do not generally recommend using ORMs, but this advice is likely dependent on the particular ecosystem you are dealing with.

        It seems like you are pretty deep into Microsoft/.NET territory. I don’t have any experience with .NET so I might not be the best person to help.

    • Miaou@jlai.lu
      link
      fedilink
      arrow-up
      2
      ·
      edit-2
      7 months ago

      Never tried lisp, it’s always been on my “as soon as I have an excuse to learn it” list (alongside haskell). What makes it adapted to this use case?

      For this problem I’d usually go python + jinja but I cannot say I like the experience.

      • monomon@programming.dev
        link
        fedilink
        arrow-up
        1
        ·
        7 months ago

        Both languages you mentioned i highly recommend.

        Lisp macros are another level, because they are part of the language - you can use all language primitives to transform forms however you like.

        Haskell will give you a different view of programming. It’s beautiful and concise, and implements all sorts of academic research in languages. Ocaml is similar in many respects.

        • monomon@programming.dev
          link
          fedilink
          arrow-up
          1
          ·
          7 months ago

          Just thought of an example. If you want to, you can open a file at macroexpansion time, and generate code based on its contents. There are no limits, pretty much.

  • Kissaki@programming.dev
    link
    fedilink
    English
    arrow-up
    4
    arrow-down
    1
    ·
    edit-2
    7 months ago

    T4, small scripts, text search and replace, multicursor editing if that counts, dotnet code generators

    Preference depends on the context.

    “Modify” isn’t really generating though, so I’m not sure whether your question is clear (to me).

  • arendjr@programming.dev
    link
    fedilink
    arrow-up
    1
    ·
    7 months ago

    Easy: GritQL

    But I’m heavily biased, since I’m also the one implementing GritQL support into Biome :)

    Second would be Rust macros, but they’re both more difficult to write and language-specific.

  • RonSijm@programming.dev
    link
    fedilink
    arrow-up
    1
    ·
    7 months ago

    For simple snippets like templates I’m using Obsidian and Obsidian Templater ( - For any programmer I’d consider Obsidian the best note-taking-app by miles.)

    For more complicated stuff I used to just build generators in code, but as you mentioned, that’s kind of a nightmare to manage. So now I usually use Liquid Templates - and a custom parser I made to process them

  • Corbin@programming.dev
    link
    fedilink
    English
    arrow-up
    1
    arrow-down
    1
    ·
    7 months ago

    I use Nix. Or, rather, I use traditional tools like sed and awk and python, along with newer tools like jq so that I can store tables in JSON, and I call those tools from Nix builders. For example, this flake builds a book in several stages, starting by generating DOT from diagrams, then feeding some JSON tables via jq into Python scripts (replacing older awk scripts) to generate some Markdown tables and Metamath axioms, and finally calling mdbook and metamath to build the HTML for the book.

  • xmunk@sh.itjust.works
    link
    fedilink
    arrow-up
    4
    arrow-down
    6
    ·
    7 months ago

    I don’t really do that - I tend to aggressively refactor code. This is, I admit, a privilege of being a highly trusted developer at my company.

  • abhibeckert@lemmy.world
    link
    fedilink
    arrow-up
    2
    arrow-down
    15
    ·
    edit-2
    7 months ago

    have there been any improvements in this area?

    Um… what rock have you been living under?

    For simple code generation, I use GitHub CoPilot.

    In both cases, I’m essentially writing the code “from scratch” myself every time, but now I can type “write a person class” then “add a name property”, etc. Best of both words - the control of hand written code, and the efficiency of not having to type all that code out.

    When your code is really repetitive, you don’t even need to give it any prompts at all. You can usually just start a new empty line and it will guess what line goes there. For example if you have a firstName property, it will predict you’re about to add lastName.

    When it’s more complex, for example if I haven’t figured out how to structure the code yet, I use ChatGPT+. That’s more of a conversation approach, similar to bouncing ideas off a colleague… “how would you do this; what about that edge case; etc”.