A GUI is indeed superior to a TUI. And keyboard driven should be both. But neither is my preferred UI. I want CLI programs callable from my shell.
This way I can quickly repeat an action from the past. I get a history of commands inserted.
_And_ I can bind my own keyboard shortcuts if necessary. TUI and GUI do not meet this level of platform independence.
If a tool is TUI only I will not adapt it.
That's not the case with a GUI, though.
I, temporarly, banned some ip range.
I didn't find a source for pinpointing countries; though I am interested. Could you point me to some sources which, deterministically, resolve to some countries? To my knowledge you can not reliably identify countries by ip since this would be dependent on DNS servers. Though I am just a application programmer!
Your router doesn't care about their DNS settings. IP addresses are very easy to tie back to countries. The reason they say it's not reliable is because it's trivial to spoof the country, but even so, a lot of attackers don't even bother. It's sort of like the Nigerian prince scam calls: if you're wise enough to block Russia, you're not worth their time.
Your firewall vendor should supply you with country lists, just select the known bad ones and drop their traffic. If you have a consumer grade router, you will probably have to configure the blocklists manually.
> The reason they say it's not reliable is because it's trivial to spoof the country
ISPs sometimes do trade IPv4 blocks and countries to which it belongs do change occasionally. That can become a problem if you were like literally Netflix and someone few nation states over started an ISP.
Unless you're serving something, you should probably drop all incoming requests. If you are serving something, the US is a pretty big market to lock yourself out of.
I'm happy to unblock China from accessing my website, once China does something about the millions of daily hack attempts originating from that country.
We have studied. We constantly educate ourselves (I have still not yet managed to work through the entire SICP on my own). Our tools are changing constantly. We are juggling information through devops, requirement engineers and customers. We advise daily. We get consolidated if something is complicated to summarize. We do forensics. Constantly under the pressure that some bit rot may open a new urgent bug we have to investigate. Money AND reputation on the line.
It is a damn stressful job.
So if we do our craft, we do it with incremental knowledge. Carefully.
We build community of trust in our free time to get connected and improve. Any new member gets welcomed and onboarded. His knowledge im the future will supplement ours. So we mentor additionally.
Now comes AI. Collects the knowledge and hands it over to anyone. And we know: It is UNSAFE.
Don't get me wrong; I consolidate it now as well, just to keep up with the increasing pressure to investigate. But the thing is:
While we did our craft so that we won't have to touch it in the next five years, the complexity increases every single day. And its out of our hands. If some junior comes in and starts writing decent code with ai it is nice. Until it breaks and AI won't help. Or worse: Gets applied on customer data in the wrong way.
A new ticket for the greybeards (by no means, I am not such).
I think we are on the wrong track.
Using ai decreases my abilities.
It increases the load.
I think we should get twice the salaries.
It has become unbearable.
Could you imagine that your local file server for your family consists of a enterprise database, a key-value store, possibly multiple reverse-proxies, a vector database.... my point beeing: Complexity. Invariants, frameworks to get familiar with... And the tool to supplement the demand is intransparent (but probably deterministic? Idk). It feels just so wrong.
Wait; So you say you outsource development to a LLM fully knowing that it will not write sound/deterministic code and your quality requirement are your test cases, right?
I further suppose you are not writing the test cases in its whole by hand. But you try to specify them before you hand out the development task to the LLM, right?
It sounds like you just introduces a new team member which is not trustworthy yet.
Normally you would review each change of him and explain how to improve hisself and the code.
But that's not possible to a fixed-state LLM.
That sounds exhausting.
If your Markdown Files should aim at improving the LLM contributions, you are again stuck with the fact that it did not follow in the first place.
So I conclude: You pay for an Intern who is not trustworthy and pay additional input token on Markdown Files to still no be certain about future contributions.
I just don't grasp how we as engineers are accepting this and integrate it into our craft.
And: Everybody using External LLM Services, possibly providing the entire project as context, is allowed to let the source code of your company be leaked to some third party. I hope that party is trustworthy and does not have a track record of copyright infridgement. Because this would be fairly naive and reason to be fired. So we as Engineers knowing the implications should therefore point to these issues at the correct management level.
If you differ between AI source code and engineer source code say so. "Getting things done" is a business need. Which things get translated to a deterministic language executable by a computer is code.
There are entire languages dedicated for lesser engineers/domain experts to formulate business requirements.
Anyhow; What's your point?
That we received a framework for "soft algorithms" where the output does not need to be correct and deducible?
What's even the point of putting it into software.
Just forward your input to the reader and let him judge on its own.
AI is more "grown" than it is "hard-coded". It's sideways to normal software - the way DSP is sideways to normal software but somehow even worse.
It all comes down to hard logic eventually, but that "eventually" has teeth. None of the interesting behaviors of AI systems live in "engine.py".
My point is: there are tasks where the choices are to use AI, use a meatbag, or suck forever. The "use AI" option going to be flawed, and often in the same ways "use meatbag" is. But it's going to be cheaper, much more scalable, and a lot better than "suck forever". Humanlike flaws are the price you pay for accessing humanlike capabilities.
You sound like the type of meatbag that goes "a human would never make this type of mistake", then makes a mistake at least twice as embarrassing, and either never notices, or immediately memory holes it to preserve his overinflated self-image.
To me, your FAQ quickly addressed all questions I had to get a first grasp of the capabilities.
It appears to me that you had a determined scope and I very much like that!
Your professional input may be desired. Though I did not contribute to Thunderbird either (, yet?).
Thing is, your critique may result in guidance to make part of these changes according to your skillset!
But I am just a hopeless dreamer in the good of many things.
I think if the team are shipping it in this state then either: they don't have the ability to notice the issues on the core team, or they see the issues and ship it anyway. Feedback like this is unlikely to solve either of those cases.
This isn't complex stuff either. I'm not a designer, I don't even do frontend/UI work, I'm basically just a backend engineer. If I'm spotting this stuff on first glance at the main marketing screenshot, which should be the best possible case, then this stuff must be glaringly obvious and pervasive.
You might have a particularly good eye. I saw none of these problems in the marketing screenshot.
I only see one ... icon in the entire screenshot, nothing is fuzzy, and all text looks aligned. The only weirdness is a misalignment between the sidebar header and the main window header, but those don't need to be aligned anyway.
> Unfortunately moving to Gitlab or Sourcehut doesn't really help, because the underlying model (GPT-x) is trained on the entire internet, so that includes all scrape-able websites. The only way for your data not to be used in GPT (and therefore Copilot) is to not to put it on any website or make it very difficult to access, like encrypting it.
Having the entire git history decorates specific chunks (at least entire commits) with context by the commit message. So you may not only process the entire repo at one specific state in time, but the entire history in at this point in time.
There is valuable knowledge while making sense of it; But this is not accessible to us. It relies in the knowledge base of one company (or two).
No. One need a specification of the intended behaviour. Behind this specification lays the interface (data type, here a Object-class). This data type on the other hand can have different representations.
Design by contract is a term i didn't read as an agreed scientific term.
It is used in OO-languages for some pattern, where you "generate" (read imply) a specification. E.g. two unrelated services use the same data type within their communication. This may be injected or included within their dependencies. To me its related to code generation. It may aid the collaborations between multiple developers across multiple projects to 'move faster'. I have limited and bad experience with this.
> If so, what about invariants? Are invariants related to good interface design?
Invariants in my book are then a synonym for mixins. Which in OO-Design would be represented via dependency inversion.
Invariants can be necessary at best.
Its no measure for a good interface.
If your data types are specified such that invariants do not missbehave, they can be used.
Invariants are not a synonym for mixins, I'm not even sure where that idea might have come from. Invariants are assertions that are true throughout a program or subset of a program (like loop invariants). Where did you get this notion they were synonyms for mixins and what would that even mean?
> Invariants are not a synonym for mixins, I'm not even sure where that idea might have come from. Invariants are assertions that are true throughout a program or subset of a program (like loop invariants). Where did you get this notion they were synonyms for mixins and what would that even mean?
It was my own understanding; Thanks for suggesting clarification.
I falsely associated such mixins with encapsulated behaviour. It was my take on mixins and may have translated the term invariant wrong.
Appreciated.
> Thanks for your reply! I will need more research to reflect on the examples you give.
Please note my sibling answer which shows I am opinionated.
I have memorized my own takes from such terms so researching about my answer may be time not used well.
Sorry.
Does indeed overlap.
I only read about contract-based programming; contract by design via API documentation in a java environment.
> and it seemed to me the main concern was program correctness/consistency
It is. There are multiple factors to deploying correct software though.
> Maybe I mix up different concerns and good interface design is more about satisfying use case?
Apparently your are on the right track. But I would strongly agree on the latter. Such formal correctness proves didn't cross my career yet. But I am assuming safety-critical systems or systems haed to update may benefit here the most.
Which would explain my lack of certainty.
