- TZubiriI think I get the idea, gdb is too powerful. For contexts where operator is distinct from manufacturer, the debug/logging tool needs to be weaker and not ad-hoc so it can be audited and to avoid exfiltrating user data.
- They worked fine for me. Keep working at it until results are positive instead of rabbit holing into a failure mode with a blog post.
It's usually more productive to right about how LLMs work rather than how they don't. In this case especially, there's improvements that can be made to the schema, without forfeiting on the idea of schemas altogether
- I was just trying to think of an example of a non idempotent function. As in it depends on an external IO device.
I will say that error handling and logging in general is one of my weakpoints, but I made a comment about my approach so far being dbg/pdb based, attaching a debugger and creating breakpoints and prints ad-hoc rather than writing them in code. I'm sure there's reasons why it isn't used as much and logging in code is so much more common, but I have faith that it's a path worth specializing in.
Back to the file reading example, for a non-idempotent function. Considering we are using an encapsulating approach we have to split ourselves into 3 roles. We can be the IO library writer, we can be the calling code writer, and we can be an admin responsible for the whole product. I think a common trap engineers fall for is trying to keep all of the "global" context (or as much as they can handle) at all times.
In this case of course we wouldn't be writing the non-idempotent library, so of course that's not a hat we wear, do not quite care about the innards of the function and its state, rather we have a well defined set of errors that are part of the interface of the function (EINVAL, EACCES, EEXIST).
In this sense we respect the encapsulation boundaries and are provided the information necessary by the library. If we ever need to dive into the actual library code, first the encapsulation is broken and we are dealing with a leaky abstraction, second we just dive into the library code, (or the filesystem admin logs themselves).
It's not precisely the type of responsibility that can be handled at design time and in code anyways, when we code we are wearing the calling-module programmer hat. We cannot think of everything that the sysadmin might need at the time of experiencing an error, we have to think that they will be sufficiently armed with enough tools to gather the information necessary with other tools. And thank god for that! checking /proc/fs and looking at crash dumps, and attaching processes with dbg will yield far better info than relying on whatever print statements you somehow added to your program.
Anyways at least that's my take on the specific example of glibc-like implementations of POSIX file operations like open(). I'm sure the implications may change for other non-idempotent functions, but at some point, talking about specifics is a bit more productive than talking in the abstract.
- I know this is standard practice, but I personally think it's more professional to attach a gdb like debugger to a process instead of depending on coded log statements.
- Say like opening a file?
I guess in those cases standard practice is for lib to return a detailed error yeah.
As far as traces, trying to solve issues that depend on external systems is indeed a tall order for your code. Isn't it beyond the scope of the thing being programmed.
- >Then you still have the overhead of the log.trace function call
That's not an overhead at all. Even if it were it's not compareable to string concatenation.
Regarding overhead of lambda and copying params. Depends on the language, but usually strings are pass by ref and pass by values are just 1 word long, so we are talking one cycle per variable and 8 bytes of memory. Which were already paid anyways.
That said, logging functions that just take a list of vars are even better, like python's print()
> printtrace("var x and y",x,y)
> def printtrace(*kwargs):
>> print(kwargs) if trace else None
Python gets a lot of slack for being a slow language, but you get so much expressiveness that you can invest in optimization after paying a flat cycle cost.
- Oh that library that gives you a write() wrapper in exchange for RCE vulns
- We call those warnings, and it's very common to downgrade errors to warnings by wrapping an exception and printing the trace as you would an exception.
- You can log your IO and as long as your functions are idempotent that should be enough info to replicate.
- How about wrapping the log.trace param in a lambda and monkeypatching log.trace to take a function that returns a string, and of course pushing the conditional to the monkeypatched func.
- I don't think of it much as fighting, but rather as just using devuan. Half of the defenses against any criticism in open source is "you can just fork it/not use it", so here we are.
It's fine, literally nothing happens if you just don't use systemd.
- Why a .us domain?
- A common pattern in social networks with a political identity, is that bait news stories are less scrutinized for truthfulness and more baited into raging. E.g:
Political group:Right
Social media: twitter
Headline: "the police detained a 15 yo for posting on tiktok"
Reality: "15yo called for violence on a specific event and group of people"
Pol group: left
Social media: bluesky
Headline: "young mother of 2 gets detained by ICE for speaking in spanish"
Reality: "DUI, didn't speak english, translator was used, prior records"
Reminds me of how phishing attempts play to our political identities as well, recently there was a phishing attempt were the platform said that during pride month all uploaded content would have the pride flag added or something like that.
The common pattern is that some things are ridiculous, but people want to believe that "the enemy" is as ridiculous, it's an opportunity to be enraged and vindicated that the injustice is too obvious to hold on its own. That it will all come crumbling down, or at least that any insecurities in our political positioning are reduced, and our position becomes clearer and our certainty increased.
In our case, it seems to be something very specific about external links from the play store. I can't be sure but it seems as if this rule relates to apps distributed through the google play store that in turn can download other apps. This provides an alternative agreement to the rev share model, where app stores can pay per install rather than on all future revenue.
Let's try to understand news and be on the same page before analyzing implications.
- It's actually time for an old init system, check out devuan.org
Works absolutely fine.
- Devuan.org
- Great, looking forward to having to relearn the new way to do something inconsequential, and having random scripts break because a unix config file is now a systemd output rather than an actual config.
- How does it handle tables with invisible lines and inconsistent justification? (For example one centered column and one right justified column.
- hi, can I have latin only LLM? It can be latin plus translations (source and destination).
May be too small a corpus, but I would like that very much anyhow
- Restaurants don't have a food business, they have a charging people money through bills business.
- Does it handle ancilliary domains correctly? For example if I allowlist youtube.com, but that also uses youtu.be or cdn.google.com, do resources from those domains get blocked until I specifically allow them?