I like that even here on Lemmy, with inline code format, colors.ini
is not being colored but color.ini
is. Great symbolism for your issue.
I like that even here on Lemmy, with inline code format, colors.ini
is not being colored but color.ini
is. Great symbolism for your issue.
If you only care about contributing improvements, no, it doesn’t matter.
If you want to at least be recognized as an author, and be able to say “I made this”, the license opposes that.
Waiver of Rights: You waive any rights to claim authorship of the contributions […]
I don’t know how they intend to accept contributions though. I guess code blocks in tickets or patch files? Forking is not allowed, so the typical fork + branch + create a pull request does not work.
I’ve been using TortoiseGit since the beginning, and it covers everything I need. Including advanced use cases. I can access almost all functionality from the log view, which is very nice.
I’ve tried a few other GUIs, but they were never able to reach parity to that for me. As you say, most offer only a subset of functionalities. Most of the time I even found the main advantage of GUIs in general, a visual log, inferior to TortoiseGit.
GitButler looks interesting for its new set of functionalities, new approaches. Unfortunately, it doesn’t integrate well on Windows yet. Asking for my key password on every fetch and push is not an acceptable workflow to me.
That’s less than I expected. If there’s 141 commands that on average comes down to 10 per.
git has 17 million options
proof needed /s
I wonder how many it actually is.
Looking at the Web Archive; Diatraxis has been around since 2021. That divio docs since May of this year.
I doubt they didn’t “get inspiration” from Diatraxis.
Using early returns and ternary conditional operator changes
private boolean meetsRiderPreferences(Rider rider, Driver driver) {
if (driver.rating >= 4.5) {
if (rider.preferences.includes('Premium Driver')) {
return driver.isPremiumDriver;
} else {
return true;
}
} else if (driver.rating >= 4.0) {
return true;
} else {
return false;
}
}
to
private boolean meetsRiderPreferences(Rider rider, Driver driver) {
if (driver.rating < 4.0) return false;
if (driver.rating < 4.5) return true;
return rider.preferences.includes('Premium Driver') ? driver.isPremiumDriver : true;
}
dunno if java has them, but in C# switch expressions could put more of a case focus on the cases
private boolean meetsRiderPreferences(Rider rider, Driver driver) {
return driver.rating switch {
< 4.0 => false,
< 4.5 => true,
_ => rider.preferences.includes('Premium Driver') ? driver.isPremiumDriver : true,
};
}
or with a body expression
private boolean meetsRiderPreferences(Rider rider, Driver driver) => driver.rating switch {
< 4.0 => false,
< 4.5 => true,
_ => rider.preferences.includes('Premium Driver') ? driver.isPremiumDriver : true,
};
The conditional has a true result so it can be converted to a simple bool condition as well.
private boolean meetsRiderPreferences(Rider rider, Driver driver) => driver.rating switch {
< 4.0 => false,
< 4.5 => true,
_ => !rider.preferences.includes('Premium Driver') || driver.isPremiumDriver,
};
Be bold and make changes. Document what you find out, what is outdated, what is missing.
Take ownership. If there’s nobody that oversees overall structure, be the one to do so - at least where you’re touching it or are being bothered by it.
Diatraxis gives some great insight and considerations input into writing and structuring documentation. Namely how different target audiences and doc use cases require different forms and detail levels of guidance.
My company’s internal doc/guidance also links to https://www.writethedocs.org/guide/ which seems like a good source.
Blazor is incredibly versatile in terms of where and how you run it. The UI is in HTML and CSS, the generated runtime bindings in JavaScript, but you can code the backend as well as frontend logic in C# / .NET / Razor template files.
It can render on the server or client, even work offline with WebAssembly and Service Worker, and dynamically switch between or combine them.
You can also integrate it into Windows Forms, WPF, or multi-platform .NET MAUI with Webview2, which will render “as a website” while still binding and integrating into other platform UI and code.
Your goals of “neat little GUI” and “as portable as possible” may very well be opposing each other.
Main questions are what do you have (technologies); what are you constraints, and what do you need. Different tech has different UI tech. Overall, most GUI programming is a hassle or mess.
If you want to dip your toes, use the tech you like, and look for simple GUI techs first. Don’t try to do everything/all platforms at once first.
I’m still waiting for better Windows Git Auth integration in GitButler. I don’t want to enter my key password for each remote action (fetch or push).
They make valid points, and maybe it makes sense to always prefer them in their context.
I don’t think exceptions always lead to better error handling and messages though. It depends on what you’re handling.
A huge bin of exception is detailed and has a lot of info, but often lacks context and concise, obvious error messages. When you catch in outer code, and then have a “inaccessible resource” exception, it tells you nothing. You have to go through the stack trace and analyze which cases could be covered.
If explicit errors don’t lead to good handling I don’t think you can expect good exception throwing either. Both solutions need adequate design and implementation to be good.
Having a top-level (in their server context for one request or connection) that handles and discards one context while the program continues to run for others is certainly simple. Not having to propagate errors simplifies the code. But it also hides error states and possibilities across the entire stack between outer catch and deep possible throw.
In my (C#) projects I typically make conscious decisions between error states and results and exceptional exceptions where basic assumptions or programming errors exist.
Does the performance cost of error checking/result types they discovered in C++ apply to languages that have native result and option types like Rust?
I would hope they were able to find efficient, performant implementations, and that branch prediction picks the expected non-error branch in most cases.
I recently watched a presentation (on YouTube from a conference/offline presentation) about Systemd which also went into its focus/baseline of Linux, not Unix, and how NT supported a stronger service concept from the beginning. It was quite interesting to learn about the differences and the presenter’s assessment and reasoning of the necessity of Systemd or something else that replaces or extends init and rc.d.
Somehow it’s clunky to use.
huh?
I find developing GitHub CI in YAML clunky.
I don’t find configuring a simple service via YAML config, with a preset showing me and explaining what I can do clunky.
The server sidebar has an uptime stat. Could also have a simple monthly costs covered percent stat.
with this in mind
With what in mind? Evading NULL
?
Languages that make use of references rather than pointers don’t have this Dualism. C# has nullable references and nullability analysis, and null
as a keyword.
What does your reasoning mean in that context?
The items don’t seem concise and always clear. But seems like a good, inspiring resource for things to consider.
If it is expected that a method might fail, then it should fail, either by throwing an Exception or, if not - it should return a special case None/Null type object of the desired class (following the Null Object Pattern), not null itself.
I’ve never heard of evading null with a Null object. Seems like a bad idea to me. Maybe it could work in some language, but generally I would say prefer result typing. Introducing a result type wrapping or extending the result value type is complexity I would be very evasive to introduce if the language doesn’t already support result wrapper/state types.
It’s an operating system that demands more of you than does the commercial offerings from Microsoft and Apple.
Does it?
It’s different, but I imagine they’re not fundamentally different if you exclude established knowledge/already being used to something.
Normal office use for non-techy people is launching apps, editing documents, and surfing the web. That doesn’t work much differently, not fundamentally different, and not fundamentally more difficult.
I wish standards were always open access. Not behind a 600 dollar paywall.
When it is paywalled I’m irritated it’s even called a standard.
Now that you say so, I feel like I’ve read about this before. In comments about Diatraxis/one of them years ago. :)