netvor

I'm not sure if this is a right type of question for this community.

The context is not essential, but in a recent video Alex O'Connor quoted "The Apologist's Evening Prayer" by C.S.Lewis. As a non-native English speaker, I failed to understand it from hearing, so I looked it up but I still struggle with interpreting it.

Can someone here help me out with "translating" to a bit simpler English?

So here's the poem, as taken from cslewis.com:

From all my lame defeats and oh! much more From all the victories that I seemed to score; From cleverness shot forth on Thy behalf At which, while angels weep, the audience laugh; From all my proofs of Thy divinity, Thou, who wouldst give no sign, deliver me.

Thoughts are but coins. Let me not trust, instead Of Thee, their thin-worn image of Thy head. From all my thoughts, even from my thoughts of Thee, O thou fair Silence, fall, and set me free. Lord of the narrow gate and the needle’s eye, Take from me all my trumpery lest I die.

Disclaimer: I'm aware that with poetry, interpretation can be problematic, but here's my thought process: when I tried to look for "explanation" I haven't found any, which hints to me that the text is not particularly ambiguous once you can see through the poetry part. (In other words, people who quote this don't feel the need to add explanation since the meaning is rather clear for an educated native reader.)

I mean, everyone knows that in January it's hot in Australia, and in July it's cold there.

But do Australians call it "winter" in January and "summer" in July? Or does just "winter" imply hot weather and beaches, and "summer" implies ~~winter,~~ eh, i mean, snow sports and wool socks.

And given that, most of the population lives in northern hemisphere, is there a body of dad jokes and culture tropes related to the fact that "we're different", or is it just too cringe and boring. (I realize both could be true on this one.)

I initially wrote this as a response to this joke post, but I think it deserves a separate post.

As a software engineer, I am deeply familiar with the concept of rubber duck debugging. It's fascinating how "just" (re-)phrasing a problem can open up path to a solution or shed light on own misconceptions or confusions. (As and aside, I find that among other things that have similar effect is writing commit messages, and also re-reading own code under a different "lighting": for instance, after I finish a branch and push it to GitLab, I will sometimes immediately go and review the code (or just the diff) in GitLab (as opposed to my terminal or editor) and sometimes realize new things.)

But another thing I've been realizing for some time is that these "a-ha" moments are always mixed feelings. Sure it's great I've been able to find the solution but it also feels like bit of a downer. I suspect that while crafting the question, I've been subconsciously also looking forward for the social interaction coming from asking that question. Suddenly belonging to a group of engineers having a crack at the problem.

The thing is: I don't get that with ChatGPT. I don't get that since there's was not going to be any social interaction to begin with.

With ChatGPT, I can do the rubber duck debugging thing without the sad part.

If no rubber duck debugging happens, and ChatGPT answers my question, then that's obvious, can move on.

If no rubber duck debugging happens, and ChatGPT fails to answer my question, then by the time at least I got some clarity about the problem which I can re-use to phrase my question with an actual community of peers, be it IRC channel, a Discord server or our team Slack channel.

So I'm wondering, do other people tend to use LLMs as these sort of interactive rubber ducks?

And as a bit of a stretch of this idea---could LLM be thought of as a tool to practice asking question, prior to actually asking real people?

PS: I should mention that I'm also not a native English speaker (which I guess is probably obvious by now by my writing) so part of my "learning asking question" is also learning it specifically in English.

I started writing this as an answer to someone on some discord, but it would not fit the channel topic, but I'd still love to see people's views on this.

So I'll quote the comment but just as a primer:

The safest pattern to use is to not use any pattern at all and write the most straight forward code. Apply patterns only when the simplest code is actually causing real problems.

First and foremost: Many paths to hell are paved with design patterns applied willy-nilly. (A funny aside: OO community seems to be more active and organized in describing them (and often not warning strongly enough about dangers of inheritance, the true lord of the pattern rings), which leads to the lower-level, simpler patterns being underrepresented.)

But, the other extreme is not without issues, by far.

I've seen too many FastAPI endpoints talking to db like there's no tomorrow. That is definitely "straight forward" approach but the first problem is already there: it's pretty much untestable, and soon enough everyone is coupling to random DB columns (and making random assumptions about their content, usually based on "well let's see who writes what there" analysis) which makes it hard to change without playing a whack-a-bug.

And what? Our initial DB design was not future proof? Tough luck changing it now. So new endpoints will actually be trying to make up for the obsolete schema, using pandas everywhere to do what SQL or some storage layer (perhaps with some unit-of-work pattern) should be doing -- and further cementing in the obsolete design. Eventually it's close to impossible to know who writes/expects what, so now everyone better be defensive, adding even more cruft (and space for bugs).

My point is, I guess, that by the time when there are identifiable "real problems" to be solved by pattern, it's far too late.

Look, in general, postponing a decision to have more information can be a great strategy. But that depends on the quality of information you get by postponing. If that extra information is going to be just new features you added in the meantime, that is going to be heavily biased by the amount of defensive / making-up-for-bad-db junk that you forced yourself to keep adding. It's not necessarily going to be easier to see the right pattern.

So the tricky part is, which patterns are actually strong enough yet not necessarily obtrusive, so that you can start applying them early on? That's a million dollar question.

I don't think "straight forward" gets you towards answering that question. (Well, to be fair, I'm sure people have made $1M with "straight forward code", so that's that, but is that a good bet?)

(By the way, real world actually has a nice pattern specifically for getting out of that hole, and it's called "your competitor moving faster & being cheaper than you" so in a healthy market the problem should solve itself eventually...)

So what are your ideas? Do you have design patterns / disciplines that you tend to apply generally, with new projects?

I'm not looking for actual patterns (although it's fine to suggest your favorites, or link to resources), I'm mainly interested in what do people think about patterns in general, and how to apply them during the lifetime of the project.

When I speak, unless I'm sharing the screen I always keep looking at myself. It's kind of strange -- it clearly does not match a real-world conversation, but somehow I can't help it.

Edit: More context -- I'm wondering if others have it, if this is something that can be explained by some "brain" thing, and also how does it affect the conversation.

Every time I try to understand how forces which hold atoms and molecules together work, I find myself wanting to ask this question: why not the other way around? Could there be an atom which has electrons and neutrons inside, and protons outside?

It feels like a silly question, but is there something we know about the universe we live in that implies that this is not possible?

This might be just EU thing, but is there an effective way to deal with endless "accept/reject cookies" dialogues?

Regardless of the politics behind, I think we can all agree that current state of practice around these dialogues is ...just awful.

Basically every site seems to use some sort of common middleware to create the actual dialogue and it's rare case when they are actually useful and user friendly

or at least not trying to "get you". At least for me, this leads to being more likely to look for "reject all" or even leave, even if my actual general preference is not that. I've just seen too many of them where clicking anything but "accept all" will lead to some sort of visual punishment.

Moreover, the fact that the dialogues are often once per domain, and by definition per-device and per-browser, they are just .. darn ... everywhere, all the frickin' time.

Question: What strategy have you developed over time to deal with these annoying flies? Just "accept all" muscle memory? Plugins? Using just one site (lemmy.world, obviously) and nothing else? Something better?

Bonus, question (technical take): is there a perspective that this could be dealt on browser technical level? To me it smells like the kind of problem that could be solved in a similar way like language -- ie. via HTTP headers that come from browser preferences.