NeutralForest

Cool to see there's a long term plan for the language and the ecosystem!

I know! But this is way different since it aligns everything properly and can be used in tandem with artist mode, you should try it out!

I know about it but that's only part of the problem, afaik you can't use breakpoint in Guile and dependency management is still non existent.

Yep, language success is also very much a social endeavor and there wasn't and isn't, a strong push and consistent messaging about Guile.

Good occasion to mention a super nice ASCII/UTF drawing library for Emacs: https://github.com/tbanel/uniline

Little tooling: you need to use Emacs and there's no LSP, no great debugging capabilities, no great testing libs, etc Bad docs for beginners: the docs are very complete in terms of coverage and yet have no tutorials or explanations in how to use Guile properly.

Very little visibility as well, Scheme is already a niche. By catering to only the most FOSS oriented/adamant part of the public, your pool of devs is very tiny.

Most guile libs can also only be installed through Guix or failing that, tar files.

The ergonomics of the language are bad and there no concerted community story and publicity around it either imo.

It's sad because it's a cool language and the efforts Wingo and people like the Spritely institute have put into it, are amazing.

CLOG is something I've wanted to try for a long time but then I need to spend some time learning CL.

It's not an issue, but that's not where most of the power is and can also be confusing since if you use variables in the case statement, the way it watches does not behave like a simple switch.

You should use if statements if that's what you need. The match statement is for structural pattern matching mostly.

Cool idea! I think I could benefit from this at my job if they're able to eat Anaconda's lunch and provide secure, self-hosted artifacts.

It's useful because it also packages a lot of other deps like CUDA drivers, DB drivers, git, openssl, etc. When you don't have admin rights, it's really handy to be able to install them and there's no other equivalent in the Python world. That being said, the fact conda (and derivatives) do not follow any of the PEPs about package management is driving me insane. The ergonomics are bad as well with defaults like auto activation of the base env and bad dependency solver for the longest time (fixed now), weird linking of shared libs, etc.

Pretty cool post! I'm not sure how I feel about SQLAlchemy (not the star of the post but mentioned quite a bit); it's such a big ball of state that has so many surprises, I wonder if some people build entirely without it.

Cool article, I think a lot of those issues are not Python specific so it's a good overview of whatever others can learn from a now 30 years old language! I think we'll probably go down the JS/TS route where another compiler (Pypy or mypyc or something else) will work alongside CPython but I don't see Python4 happening.

You can also walk and bike, it doesn't need to be crazy intensive.

I've never seen anybody do that... In Python you can use a module as a singleton (mentioned in the article). Or provide some data like:

  from functools import lru_cache

  class Whatever:
      pass

  @lru_cache(maxsize=1)
  def get_whatever():
      return Whatever()

And use `get_whatever` as your interface to get the resource.

fair

Thanks for the article! Do you have a solution, if any, to maintain links green? Anytime I write something with lots of links, I'm always afraid that there's basically no way to retrieve the original page after some time.

Since other people mentioned there's been work there, here is my Emacs config now:

  (use-package janet-ts-mode
    :ensure t
    :defer t
    :vc (:url "https://github.com/sogaiu/janet-ts-mode"
            :rev :newest))

  (use-package ajrepl
    :ensure t
    :defer t
    :vc (:url "https://github.com/sogaiu/ajrepl"
            :rev :newest)
    :hook (janet-ts-mode . ajrepl-interaction-mode))

Also, a fix for treesit auto to not ask for the grammar every time:

  (use-package treesit-auto
    :pin melpa
    :ensure t
    :custom
    (treesit-auto-install 'prompt)
    :config
    (add-to-list 'treesit-load-name-override-list
               '(janet "libtree-sitter-janet-simple" "tree_sitter_janet_simple"))
    (add-to-list 'treesit-language-source-alist
             '(janet-simple . ("https://github.com/sogaiu/tree-sitter-janet-simple")))  
    (treesit-auto-add-to-auto-mode-alist 'all)
    (global-treesit-auto-mode))

I've been trying to use ajrepl but as mentioned in the README, there's a lot of cruft that gets output. How do you setup ajsc?

Janet is awesome but pretty please, work on the tooling. There's very little in the way of working and debugging interactively with the REPL from any IDE that I know of and last time I tried (on Emacs) there was barely a dedicated mode to work with it.

That's all fair, I just think it has more to do with separation of concerns than Pydantic and that the OP doesn't make it clear at all.

I'm not sure I agree, you can still use Pydantic in the domain model and update the version of the API when you change the expected schemas of your CRUD application.

Where I'm with you, is that you should take care of your boundaries and muddling the line between your Pydantic domain models and your CRUD models will be painful at some point. If your domain model is changing fast compared to the API you're exposing, that could be an issue.

But that's not a "Pydantic in the domain layer" issue, that's a separation of concerns issue.

What's the motivation for doing this? When does Pydantic in the domain model starts being an issue?

I honestly don't think it's enough of a value proposition but I wish you the best, more competition is good!

Then why use this instead of VSCode with a couple extensions?

I don't think it's unpopular, I'm European and it's sad to see the tech scene and the kind of capital we have available, compared to the US.

You do you. I'm happy with uv.

pip is not a package manager, it's only meant for installing packages. Also, uv has a pip-compliant interface through `uv pip` which lets you interface with pip easily.

Sadly this isn't always true, if you have non-pure Python dependencies, you might still need to use conda since they package database drivers or complex C/C++ dependencies for example.

To be fair, the surface of software has gone through the roof. Unix utils like `grep` or `find` can be hammers while a retailer's website with varying promotions, inventory and overall content needs to be maintained, moreso like a car.