diegojromero
Joined 9 years ago
Karma
20
Submissions
23
Member since
Mar 26
Recent submissions
Comment · 1 month ago
Could you recommend some lectures/reads about the use of formal methods in LLMs, I'm interested in the area.
Comment · 2 months ago
Something I've learned is that your specification is as solid as your validation harness. If you have added strong e2e tests, with the critical scenarios covered, then you are safe. If not, sometimes it's rolling dices.
Comment · 2 months ago
On what dataset was the AI trained?
Comment · 10 months ago
Sure, in my workflow I make use of mypy and ruff extensively (but ruff does not allow plugins). So I decided to create several plugins with the intention of improving the developer experience and understanding of the code.
Now, what I am asking is, could we expand this by having static annotations that enforce runtime behaviours before running the code? I'm not advocating for the removal of the tests or some manual testing phase, but in the same vein of type errors being shown in our IDE, could we have static checks like contracts for functions or class invariants?
Full disclaimer: I leveraged AI technologies to create them.
Comment · 1 year ago
Well, I was so worried about boilerplate that I created a Python decorator for avoiding polluting the code with so much of that (https://github.com/diegojromerolopez/otelize).
About the cost, AFAIK it is not prohibitive.
I will continue working as I was, thanks for your opinion!
Comment · 1 year ago
Thanks for your comment! It has given me an idea for a project: a simple library that provides a Python decorator that can be used to include basic telemetry for functions in Python code (think spans with the input parameters as attributes): https://github.com/diegojromerolopez/otelize
Feedback welcome!
Comment · 5 years ago
Interesting, maybe adding a decorator @freeze_final could be a good idea? I'll take a look at it later.
Thank you for your input!
Comment · 5 years ago
I knew about dataclasses when I started writting gelidum, but I wanted to make the immutable objects be from any classes, those under my control or not.
Having said that, I think dataclasses are a better solution for making immutable objects if the class is going to be made from the start.
Comment · 5 years ago
I'd really love if that could checked statically.
Performance is bad, I mean, all params are deep-copied because I assume frozen then "inplace" is not intended as they could be objects used by other parts of code.
Comment · 5 years ago
Yes, you're right with your concerns.
I added this feature yesterday. Note the default value is "exception". With "nothin" I was thinking in passing some frozen object through a pipeline of unsafe/inherited/bad code, but without polluting the console with warnings or stopping the execution with exceptions.
Comment · 5 years ago
Exactly my main issue. I see this code as something that asserts that an object is not modified by that "bad" code, but I fail to see more use-cases. I've been thinking about doing some kind of dictionary datastore with these frozen objects but I'm not sure if it is actually useful.
Comment · 5 years ago
Interesting idea, instead of a deep clone, would it be something similar to the copy-on-modify pattern?
Comment · 5 years ago
Per advice from Daniel from HN (thank you!), I have reposted this Ask HN I made earlier about immutability. [1]
I was thinking the other day about my days working with Ruby On Rails and how the strings are mutable in Ruby and the freeze method. My mind wandered about that, the several freeze packages that exist (even the frozendict [2] package) that make frozen classes of objects.
I haven't worked professionally with Haskell or Erlang, but some of their functional capabilities are nice and have ejerced a big influence in my work with Ruby on Rails and Python. Specially the ideas of having immutable objects and keeping updates at minimum.
I thought on doing a freeze package that could make frozen objects recursively in Python. The idea is to make easier to share objects between threads without having to worry about updates inside threads.
However, I'm not sure that this package is useful at all. Maybe is because Python is not a well-suited language for this? Maybe is because my lack of knowledge about functional programming? Maybe is because it doesn't make sense to "freeze" objects?
Some ideas I have in the back of my mind for this package are:
- Some kind of basic datastore-server where data is immutable (threaded server?). - Storing all updates some kind of super-object by storing all history as immutable objects.
What are some sources to learn about immutability on programing languages? How could you use a freeze package in Python or other languages? Would it be useful to share information between threads?
Any advice/idea/feeback/criticism or comment on this matter is appreciated.
Take a look at my GitHub profile: https://github.com/diegojromerolopez