Turned into a skeleton in 10 minutes

DuckDuckGo

I scale by dropping requests

no no no, this is the wrong way around

because sales and marketing sell it before it even exists

The site name’s a play on “The Onion” so it’s gotta be satire, right? I couldn’t find an about page to confirm.

Yes, it's satire.

The page is run by one author https://www.theolognion.com/about and no description or goal described

Runs on "substack" platform (standard software)

The story reads like a story, and the mentioned company does not exist

I see, TIL. That's different from Germany, where Ingenieur is a protected term.

Driving a train is engineering?

Did you stop programming altogether? /s

I think you can potentially get stuck with worse when you stop Java.

Webcrawlers count as users too, right?

Yes, the GPL allows you to make modifications. The GPL still applies.

The cloned repository still holds the history and deleted files. The files that are still there retain the GPL. If you make additions to the GPL sources, the GPL applies to those too. (Copyleft license.)

You can check the summary of GPL on ChooseALicense to understand your rights and conditions a bit better.

People regularly change email addresses. Listing that as an example is a particularly bad example in my opinion.

I hope the demo starts soon…

(What a bullshit correlation/equation to start with.)

A patch from January and MFA prevents account takeover.

If you're not updating gitlab for over three months, across max severity security patches, you're negligent.

Personally, I like to call catched exception variables up, so for a rethrow I can throw up;.

Their main argumentation (from page 1) summarized:

You know the state and progress of a program from the line you are on. A goto breaks that.

You can index the progress of a program through static line indexes and a dynamic loop index and function call stack. A goto breaks that. Including a "statements/lines since beginning of execution" is infeasible for understanding.

I wouldn’t do that, too much tunnel vision and biases.

Absolutely not. Self-reviews are very productive. I can confirm this from my own work and my colleagues, who also find it so.

You're of course free to vary the degree and depth of self-review, but tunnel vision and bias is definitely not overbearing and diminishing in those situations for us.

Someone else will of course see more, what you may not see due to tunnel vision. But that's besides the point.

If only this post title had received descriptive text too

The term engineering is not about problem-solving, especially when differentiated from development. Engineering is about deliberate understanding and decision-making, about giving it an architecture, a structure.

You can develop without any structure, solving an issue, without understanding a bigger context or picture or behavior. But that's not engineering.

The title could have been "Why knowledge of programming alone is not enough", without a question mark. I would have preferred that.

I think it's convoluted way to describe it. Very technically-practical. I agree it's probably because of historical context.

The argument I read out of it is that using goto breaks you being able to read and follow the code logic/run-logic. Which I agree with.

Functions are similar jumps, but with the inclusion of a call stack, you can traverse and follow them.

I think we could add a goto stack / include goto jumps in the call stack though? It's not named though, so the stack is an index you only understand when you look at the code lines and match goto targets.

I disagree with unit tests replacing readability. Being able to read and follow code is central to maintainability, to readability and debug-ability. Those are still central to development and maintenance even if you make use of unit tests.

I hate popovers. This one not only covers the whole screen, it opens the virtual keyboard because of auto focus. So people actually subscribe like that? I don't. I leave.

I think the guideline should be: future software should be written on a whim

Sounds to me like the AI was programming using you instead of the other way around.

Did you copy and paste back and forth without learning or understanding anything? Or did you read and assess the results, and try to understand errors and issues?

Go has goto too. They surely did not "mindlessly copy" it.

The standard library makes use of it. So they most definitely see a warranted use-case for it.

• math/gamma uses goto
• Stack Overflow: "Why does Go have a goto statement?"

OP argument against using it in high level languages may still hold though. Go may have introduced it as a systems language which allows control over alternative implementations.

No

If budgeting donations is difficult, maybe donating time is more viable?

Employees are already paid for. Less people involved to approve too.

If you have the autonomy you may even be able to to without explicit approval.

In highlighting the need to understand the requirements before development begins, the research charts a path between Agile purists and Waterfall advocates. ®

Random trademark symbol. What's the registered trademark here? The dot? "advocates"?

While it doesn't provide an SQL interface, I've been using Nushell as my shell, which has native data operations.

I tried querying the same, and I'm still not fluent (this was my third or fourth bigger/practical data querying), but it works well and fast too when you know the syntax:

http get https://api.github.com/orgs/golang/repos | each {|x| get license} | get key | group-by --to-table | update items {|x| $x.items | length }

I've used Nushell for reading en-mass json files, generating command json files for stuff saved in excel files (you can natively open those too), and most recently to query log files for specific information and usage analysis.

/edit: This comment has the better nu solution.

How do you self-review while writing? What do you mean by that?

I see it as different phases of development, mindset, and focus. You inherently can't be in multiple at the same time.

1. Problem space and solution exploration - an iterative and at times experimental process to find and weigh solutions
2. Cleanup and self-review - document your findings, decision-making, exclusions, and weighing, verify your solution/changeset makes sense and is complete (to intended scope)
3. Reviews

It makes no sense to be thorough during experimental and iterative exploration. That'd be wasted effort.

After finding a solution, and writing it out, a self-review will make you take a systematic, verifying review mindset.

I would learn on the project, and use the official documentation to look up what it is, how it works, and how to solve what you want to do.

First half is a general introduction, second half is an introduction to their product Digma, which is limited to Java and IntelliJ.

Currently, Digma fully supports Java and IntelliJ, along with related frameworks such as Spring, Spring Boot, Dropwizard, and Micronaut. If you’re interested in other languages, you can find more information here.

Overall it feels shallow to me.

From what I see they didn't even support the claims they set out to present. They show a few screens of their tool, but never how that would "avoid breaking changes". The conclusion is incredibly generic. Feels like publicity/promotion and keywords content was the goal rather than actually sharing information. OP only posting their Digma content fits the impression of PR too.

From your description, my view is limited, there is no correct solution. Any choice is viable and fine, and any decision you make will be due to the reasons you chose with.

You didn't disclose what the alternative opportunity and field is, and also not your view on the field and you in it. So it's difficult to assess and put into relation.

You didn't disclose what you did before work, but two years is not that much experience for an engineer. Especially if it is not a particularly nourishing environment. You gain such expertise through experience and exposure over time. Depending on the project and environment it's also not enough to fully understand and intuitively know a big project.

At my workplace we separate role from [personal] development level. As a developer one's role may be developer or lead developer. The development stages are Trainee, Junior, Professional, Senior. If you can work on tasks mostly self-reliant (asking and collaborating is still open of course; knowing when to ask is a skill too) and can put tasks and work into context, you are a Professional. A Senior can support and guide the team. It is perfectly fine to settle for Professional.

Not being exceptional is not a good reason to quit. If you work and bring value, that's still value. Don't decide whether you are valuable or good enough for others. (This leaves out the question of what it means for yourself of course. Tackle those questions individually.)

You say you get your work done. Continuing to do that at a Professional Developer rather than Senior level is fine. You still bring value.

I want to know if that’s what it sounds like to people who’ve seen that before. If you were in my position, would you walk away and just be a hobbyist programmer or stick it out and hope to be a mediocre engineer one day?

I really can't answer that specifically.

You said your team environment is not the best. I assume you don't do retrospectives or personal feedback. Is feedback something you could ask [of some of] your team members, lead, or seniors? (Take care not to poison your question for open feedback with your negative assumptions of yourself and your work.)

Where would you like to be? Separating what you think is expected of you from your expectation and view of yourself and from what you enjoyed and where you think you would feel comfortable settling, how would you lay those out?

Have you considered switching project or employer? You have only seen and experienced that place. A different work environment could be very different - even in the same field.

You're asking about the backend only, separated from the fronted? The fronted will be HTML only, but independent of the backend anyway?

Doesn't that mean you're introducing another interface and a need for another backend for the HTML frontend generating?

If it's independent, why does the frontend intention matter?

My first choice/exploration would be C#/.NET.

a random program

like

alert(Math.random())

Mastodon is a Fediverse platform. Lemmy is too. Anyone can host their own Mastodon and Lemmy instances.

When a user uploads an image or video on Mastodon instance 1, and a user of Mastodon instance 2 is following them, that image or video is copied over to Mastodon instance 2 - because that's where that user resides.

This means content gets replicated and duplicated across every shared-network instance. Resulting in resilience, but also exponential, excessive storage needs.

OP is suggesting that media files should be shared across platform instances so that they don't get duplicated many times. This would significantly reduce storage and bandwidth needs and use for the platform instances themselves, offloading and centralizing media file concerns.

One time passwords

Forgotten after one use

For a desktop app I would go with none of those.

If cross platform is the goal, the more important question, and independent of the programming language, is which GUI framework you will use.

Your best bet, at least if you are looking for a stable GUI framework, the best candidate may be C++ and Qt. But that's a hassle in its own right - both C++ and Qt.

TypeScript will have some solutions for you, with web rendering as a desktop app. Golang will have Qt bindings or other more experimental/not thoroughly established+popular GUI frameworks.

My personal favorite ecosystem is .NET. It has an official cross-platform UI project MAUI, but without an official Linux target. Community extensions probably exist. Personally, I dislike the way the UI is declared and bound though (XAML).

My current interest, which I have not explored or validate yet, is using .NET but then host a web or Blazor app in it with Webview2. .NET supports cross-boundary programming, crossing web+managed/native development, and crossing web(HTML+JS)+managed.

Most of the time GUI and the framework technology is a hassle. Your question is too broad and unspecific, so there's not a good answer.

If it's not a "serious" project that you depend on [for your livelihood], pick and start with whatever [looks good or interesting] and go from there. If it is a "serious project" do a bit more GUI framework exploration and assessment, and pick and commit to something. If it's a big commitment or risk, do prototyping with your candidates for verification and assessment - beyond the most simple examples, and for your specific usage.

The Windows integration will surely be awful for users. Windows 11 seems to be getting continuously messier, more convoluted, less focused, less accessible, less approachable, and less understandable. Adding AI and more online service integration won't make those pain points better. It'll make them worse.

The investments into technology and APIs like DirectML and "native" PyTorch will likely have a positive impact for developers making use of AI models.

Many of the other changes mentioned are unrelated to AI.

I supposed Dev Home is useful for big companies that need the setup, setting and workflow sharing, and the specialized features.

sudo seems like it could be a neat utility and addition. Git in File Explorer too - although it probably won't be useful to me personally. (TortoiseGit is already a great shell/File Explorer integration.)

Your description of JIT-learning sounded more like learn-only-on-the-job than JIT.

When you say "should have learned more upfront" I don't see how that would necessarily have to be outside or within the job. Where you learn it is open and arbitrary. For me, it's a question of what's reasonably necessary or efficient, does it make sense to explore more or prototype at work? Outside of that, I would have to have a personal interest in it to explore it in my private time just in time.

Usually, I learn upfront unspecific to concrete work. And that experience and knowledge come in handy at work.

When I'm on the job I work on and learn what is necessary to the degree it makes sense. I prefer to fully understand, but sometimes that's not possible or reasonably, acceptably efficient. Then you can weigh risk vs cost and prospect. There's no way around weighing that each time and individually. Development, in/as general, is too varied to have one arbitrary supposed weighing to follow.

extending the list

• You don't need JavaScript to build web pages
• You don't need JavaScript to publish web pages