In most of Germany neither is required (Baden Württemberg requires non-EU citizens to pay 1.5k€ per semester). Commonly though you have to pay from 200 to 300€ administrative fees.
The harder problem is to enter Germany, but as you have EU citizenship, that's not a problem for you.
I tried coding "ownership strictly" in Rust myself for a while and I've given up for the most part. In a lot of cases I painted myself into corners that I couldn't get out from without changing everything. That is probably a signal I should use, but Arc and clone also work. So I use them.
As a fellow zed user, I fear this could affect us (though i'm not 100% confident). Zed uses their own adapter to implement claude's ACP support, and it's likely using `claude -p` (the agent SDK) under the hood.
And you can spend your effort on features and architectural issues rather than smaller scope bugs. My experience is that Rust enables me to focus on features as long as I don't give the AI free reign. Architecture matters for correctness bugs, because some solutions are inherently more prone to the AI becoming confused along the way than others.
The more effort I spend on planning architecture with the AI, the less runtime bugs I need to investigate after it did the implementation.
Discovery of the best solution in a problem space is not generative but only verificative. Meaning: the LLM can see if a solution is better than another, but it can't generate the best one from the start. If you trust it, you'll get sub-par solutions.
This is definitely an agent problem instead of an LLM problem. Anybody got something explorative like this working?
For the love of god, don't do blank textiles anymore. In the end you have a software that has 20 (or more) individual files for each programs section, which works fine until you want the files to be consistent. Boom. And then you add a lock to fix it and suddenly your whole program can only run sequentially. And then your customers ask why it's so slow in ingress. I won't name any names here, but this is a real commercial product.
We use a cheap invoicing program. It works fine except it gets very slow when dealing with large numbers if invoices. Turns out each invoice (or payment record, or customer record, or whatever) is a separate text file with form-urlencoded data. No indices.
The way I use AI now feels more exhausting than the programming I did for the last 20 years. I pose a problem, then evaluate proposals, then pick the one I think is the "right one"(tm), then see the AI propose a bunch of weird shit, then call it out, refine the proposal until it feels just about right (this is the exhausting part), then let it code the proposal. The coding will then run for 1-5 hours and produce something that would have taken me at least 2 or 3 weeks (in that quality).
After 5 hours or so of doing this planning, I'm EXHAUSTED. I never was exhausted in this manner from programming alone. Am I learning something new? Feels like management. :)
I feel this as well. I think it’s something to do with having to be more “on” as you slowly work with the LLM to define the problem and find a reasonable solution. There’s not much of a flow-state. You have to process mountains of output and identify the critical points, over and over, endlessly. And it will always be an off in this unsettling little way, even when it’s mostly quite good. It’s jarring.
The strange sorts of errors and reasoning issues LLMs have also require a vigilance that is very draining to maintain. Likewise with parsing the inhuman communication styles of these things…
Could it be that what we called flow state was actually a sort of high level thinking time afforded by doing low level routine work?
For instance I'm the old world, if you wanted to change an interface, you might have to edit 5 or 6 files to add your new function in the implementations. This is pretty routine and you won't need to concentrate that much if you're used to it, so you can spend that low-effort time thinking about the bigger picture.
Its the "unsettling little ways", right. So you can't skip whole paragraphs, you literally have to read everything. And sometimes its worded in ways I don't understand at all (due to missing implications that the LLM conveniently omitted), so I have to re-ask it about that point as well. For every major feature or work-unit it takes up to 2 or 3 hours.
I figured out some patterns in the way it behaves and could put more guard-rails in place so they hopefully won't bite me in the future (spelled out decision trees with specific triggers, standing orders, etc.), but some I can't categorize right now.
Just to offer a counter-example, using AI makes programming bearable again for me. Most of programming comes down to a short - edit: not quit so short but you may understand the figure of speech.. - list of things which are repeated ad infinitum in myriad variations.
I don't have to slog through yet _another_ way to sort, split, combine a list, open a file, show a UI component, handle events, logging, make data flow through some type of "database", serialize and deserialize endless things, implement yet another protocol in $whateverishotnow, managing authn, authz, the list is endless.
The interesting part of programming, for me, is deciding on and capturing the domain in a tight, surprisingly simple yet powerful architecture. This is hard - for me - and actually has very little to do with "programming" per se, meaning it has nothing to do with wrangling syntax/low-level semantics of whatever platform I'm on and fighting package managers to name just two highly depressing parts of my job. I don't like typing code. I am doing it my entire life and I still don't like it.
I like coming up with invariants and ways of guarding them. To find simple decompositions that turn a hairy, ungodly blob of a problem into a manageable almost trivial network of not-so-complicated things. The not-so-complicated things themselves.. I don't care in the slightest about them. Opening files, managing database connections, forms, the mechanics of i18n, typing the word "class", you name it. I find it exceedingly boring.
Perhaps I am more of the architect type, but I find managing a bunch of AIs and making sure they don't stray from My Path is easy on the mind. Programming works on my level of abstraction finally.
AI does the easy/medium part, leaving only hard stuff and context switching, so naturally it's more exhausting, as the concentration of difficult-work-per-unit-time and context-switching-per-unit-time is much higher.
To me it’s more like being a super micro-managing TL that would annoy the hell out of their human reports. It comes with all the pros and cons of micro-management.
When the end result has problems and needs to be reworked.
You can't figure this out instantly except when you'd review everything the LLM produces, which I am not. So the round trip time is pretty long, but I can trace it back to the intent now because I commit every architecture decision in an ADRs, which I pour most of my energy into. These are part of the repo.
Using these ADRs helped a lot because most of the assumptions of the LLM get surfaced early on, and you restrict the implementation leeway.
Do they? I haven't experienced models deviating from a spec in a very long time. If anything I feel they are being too conservative and have started to ask to confirm too much.
The problem is not the LLM deviating from the plan (though that rarely also happens when it thinks it has a better idea) but rather if the plan is not strict enough and the LLM decides on the fly HOW it is going to build your plan.
The original plan was to only shut the reactors down when enough renewable energy sources would be available to replace them. The Merkel government wanted to prolong the initially planned phase outs. Then Fukushima happened. Bad optics. So after pressure from the populace they instead of prolonging their runtime (as they wanted initially), they shut them down, but earlier than planned.
I tried the way they used "oracles" to verify their implementation against known good ones, and I must say: this works.
Not all implementations are re-implementations, so this approach won't work for everything. But for a new implementation in a new programming language than the original implementation, it works great. Built myself a MIB compiler, checked against smidump. Now it is more correct than the original, because smidump still crashes on some inputs, while mine does not.
So the news is not so much that Anthropic built a C compiler, but HOW.
The harder problem is to enter Germany, but as you have EU citizenship, that's not a problem for you.
reply