rmgk

Using faxes is much more streamlined than the more modern Scan, Email, Print process.

This is somewhat ironic, given that it was systemd that replaced the battle-tested systems that came before it, and variants of your comment were used to argue against it.

I tried with Kagis LLM assistant.

Without web search:

Chat V3 discusses the events: violent government crackdown, human rights violations, censoring.

R1 evades answering, stating the topic is sensitive in China (simlar how it reacts to American sensitive topics)

With web search enabled, R1 discusses the found sources (which are not censored, and the model does not add any censoring as far as I can tell, certainly not enough to respect the Chinese governments stance.)

I think you are not very accurate about “open source product” vs something like “community led project”.

People being able to adapt their software to their own needs by making changes to the code is exactly what open source is about. This is good.

What is a problem though, is to have the code merged in the main repository requires you to gift them the rights to your code (not just license it). They are also not very clear about this in the summary of their CLA: “You're giving Zed permission to use and share your contributions (like original works or modifications).” which could be misunderstood to just be a usual open source licensing agreement, but seems to be complete handover of copyright: https://zed.dev/cla

This is not good, and something people should be more aware of when contributing.

Giving good individual feedback requires effort and is low priority. Those things tend to not happen without requiring complicated feelings to be involved.

Which direction of contrast is your problem?

For me, the small contrast on pages like HN (in particular with any of the gray text) strains my eyes because it’s more effort for me to see the letters.

But I also read a reasonable amount of PDFs (black on white) which is relatively comfortable on most of my monitors (LCDs with generally low brightness setting to have less light shine into my eyes).

I think what I am saying is, I agree that what is comfortable depends on the user, so websites not moving off the defaults is better, because then users can configure what works for them.

Addendum: The low contrast example on the article is very uncomfortable to read for me.

Maybe, but the pronunciation of the forge part is essentially just the English one (at least much, much closer to an attempted German pronunciation).

The jo part is close to German though, so maybe this is why it’s not too bad for someone who knows English and German. And everyone else gets to dislike at least some part of it :-)

This seems to be a good tagline for a HN audience that kinda clicks a link blind and wants to figure out what it is quickly and move on. But it’s unclear to me why the Forgejo website should care about this type of visitor? Being a “forge” is likely well understood by anyone that is interested in installing this type of software (or they will figure it out because of the context that linked them to the page). None of the features you mention is a good discriminator, as essentially all forges have these features in one form or another, so an interested use will have to look at the details anyway. Being: “self-hosted, lightweight, easy to maintain” those are very important quick discriminators if you are looking at this type of software.

> I understand your first language is German. Figures.

I assume your argument is: “Everyone who had to learn English as a second language is so used to completely random pronunciation that they won’t complain about anything anymore”.

While I understand the utility of separating contexts and making “distractions” from the current context harder to access. Doesn’t better integration into your system window management kinda defeat this separation again? Is there a significant difference in having a porn tab open or a porn windows open?

It’s great if this separation works for you and your current setup, but what does prevent future you from building muscle memory to quickly switch back to porn when you want to procrastinate your taxes?

While I am glad that you seem to have found a new workflow that you like, your description strikes me as a personal experience.

I am aware that a lot of people use searches as a form of navigation, but it’s also very common that people use bookmarks, speed dial, history, pinned tabs, and other browser features instead of searching. My Firefox is configured to not do online searches when I type into the address bar, instead I get only history suggestions. This setup allows for quick navigation, and does not require any steps to set up new pages that I need to visit.

What I want to say that while you seem to imply that you found a different pattern of use that many people will soon migrate to, I think these patterns have always been popular. People discover and make use of them as needed.

It’s also strange that you put such a negative sentiment on interconnected documents. Do you not realize how important these connections were for you to be able to reach the point you are at now? How else would you have found the things that are useful to you? By watching ads?

Search engines are also … really not really a good example of the strengths of the interconnected web, as they are mostly a one way thing. Consider instead a Hacker News discussion about a blog, and some other blog linking to that discussion, creating these interconnected but still separate communities and documents.

The way that this syntax (see bash, zsh, fish, etc) usually work is that these lists are separated by spaces. You can still quote arguments if they contain spaces (or escape the spaces).

Choosing space for a very common thing in your language often makes sense, as you reduce the amount of visual elements. Thus space is often used to apply arguments to functions. Lisp and Haskell are common examples Though, you could argue that in Lisp it only is an application if it is within parenthesis.

I understand this as systemds config being less powerful than using Guile?

If so, I fully agree, on the config being less powerful.

Maybe let me add to my original argument, because it does not seem to make it’s point well.

I think that it would be feasible (and worthwhile) to simplify the configuration structure while keeping Guile syntax, and have the complaint be a non issue. As opposed to keeping the semantic structure and just changing the syntax as the comment I replied to proposed.

So we should give Drew the other half of the keynote to make an informed decision afterward?

The point in the Article is that Meta used LibGen to train, not legally obtained books from their local library. The problem is that if you and I made use of LibGen and some of the “right holders” (more likely some IP specialized law firms) realized that, we would be prosecuted.

Giving Meta exclusive access to those copies is the problem (which is effectively what we are doing if they are not prosecuted, or, alternatively, if we accepted that LibGen is fair use for everyone).

I don’t think this is about lisp syntax.

The systemd variant uses one of the universal DSLs for key-value pairs (key=value) and the universal DSL for calling programs (program name, space separated list of arguments).

The latter is even the same syntax that lisp uses for functions calls – thus I would argue the systemd config file looks more like a lisp program than the Guix version does.

As a person that has seen a reasonable amount of sexpression, this is what I would not bat an eye at:

(start /path/to/ntpd -n -c /etc/ntpd.conf -u ntpd -g)

Traits in Rust are more a variant of Haskell typeclasses than of Smalltalk traits.

The whole FP vs OOP distinction does make little sense these days, as it has mostly been shown that each concept from the one can neatly fit within the other and vice versa.

Your argument is essentially: “I have downloaded and watched this movie, but because I cannot recreate the images, there was no copyright infringement involved”.

You find the first part in your stack that is documented (e.g., make is documented, even if your makefile is not) and use that documentation to understand the undocumented part. You then write down your findings for the next person.

If you don’t have enough time, write down whatever pieces you understood, and write down what parts “seem to work, but you don’t understand“ to help make progress towards better documentation.

If you put the documentation as comments into the file, this can make copy&pasting working examples into a reasonably solid process.

Basically, opting out is the most reliable way to not accidentally give Google full access to private use data because backups are stored in their cloud by default.

My understanding is that this was the same for Apple until they added e2e encrypted backups, but Apple users seem much less sensitive to privacy violations done by Apple (which is probably reasonable given that Apple is not as focused on profiting off of data)

If you managed to figure out how to edit the Windows registry, you probably would also be able to figure out how to edit config files on Linux. Navigating to the correct paths can be done in any GUI file explorer and there are plenty of GUI Text editors. Most config files are also much better at self documenting than any part of the Windows registry.

I am not saying that you are wrong for liking what you like – it’s completely fine to be comfortable with the tools you are used to.

I just think it’s not an argument for what type of person would be comfortable with Linux.

I work in an environment all of Linux, macOS, and Windows are used (what ever the user prefers) and the people that „just want their Job done“ need an „IT person“ to figure out any configuration and complication for them independent of the OS used.

Given that the original article is criticizing the unequal wealth in the USA, a GDP PPP (which is an average) but higher concentration of wealth would imply that most people in the USA are much worse off.

Would recommend to just try their 100 free searches. Their results are good, but it’s hard to have an objective measure. For me, it’s the little features that make it worth it (and that they have a forum for feature requests, and a proper changelog).

If you want to read a bit of Rust community criticism into the Article, I think it would not be too far off to read this as “There are lots of people claiming writing things in Rust provides better software due to memory safety, but in practice users did not care and were perfectly content with the C implementation” (presumably because the latter has no noticeable bugs).

I also interpreted the article a bit that “users” here refers to developers that make use of libcurl, that would overall like to ensure that the application that they are writing does not segfault or similar. It seems plausible to assume that some of the Rust goodwill would translate to developers that may also try to migrate their overall code to Rust to try out that backend, and potentially contribute improvements. The Linux kernel and Git for example seem to attract a lot of attention of people that want to work on migrations towards more Rust.

If you mean the text position that overflows, that seems to be computed by the library. The same happens in chromium at some resolutions.

If you like to have most of the simplicity of just setting classpath, but still have convenient dependency resolution, I highly recommend checkig out coursier: https://get-coursier.io/

Its a cli based artifact fetching tool for the JVM ecosystem, and you can have it just make up classpath strings for you, i.e., to use some Apache dependencies with the single file simplified java running you could just:

java --enable-preview --class-path (cs fetch --classpath org.apache.commons:commons-collections4:4.4) program.java

Also, maybe do have a look at scala-cli: https://scala-cli.virtuslab.org/ It does work just fine with Java files, and allows you to write single-file programs that include dependencies as special comments. The tool has some idiosyncrasies (like a background compiler server), but overall works extremely well if you need some of the power of a build tool, but without having a complex project structure.

Does this not seem to rather imply that using the proton/windows APIs works well and is a good solution with many advantages?

Is the large portion of windows/mac/linux productivity software that targets chromium/electron an indictment of the immaturity of windows/mac/linux?

Again, I see where you are coming from, and I do agree that a lot of discussion about Git (and it’s workflow) is really about GitHub (and it’s workflow).

But even when using GitHub as the hosting service, every time you work on a local branch (this includes main/master) you are working on something purely local that will not conflict with what anyone else is doing. It’s only by pushing/pulling that tracking branches are automatically updated, which seems to correspond to the operation that you would refer to as updating tip.

As the rest of the discussion is this topic seems to indication, people do work on these “private” branches a lot, and do rebase/modify them freely to create a history as they like before publishing that history (at which point, you would require coordination with everyone who saw that to change it again).

As far as I can tell, what the Meta tooling seems to offer is that you can see the “kinda private” commits of other people, if I understand correctly. That does sound indeed useful, but also out of scope for Git – rather part of some further UI that displays such information conveniently.

As far as I can tell, what is really meant by “rebase is only possible for "private" commits.” is that for public commits, rebasing would require to coordinate with everyone interested in that branch.

This seems to be very similar to what you say with “requires some basic communication as to what is considered ‘tip’”

Requiring coordination (or a constrained model of allowed changes) when modifying things (such as what the tip/branch points to) is a general principle unrelated to git and applies to every workflow.

That said, I do understand that Meta’s centralized tool is more useful for your usecase.

First of, I do like that style.

In the context of my argument its quite interesting because you essentially argue that one can get the benefits of separate runtime implementations without actually needing pure functions (in a very strict sense) or any of the IO encodings.

What I had in mind when I said application specific handling, I meant things like the application developer writing a custom optimization pass on the returned IO values to make the execution more efficient for the specific application. Or adding custom way of handling/reporting errors. And I meant doing so while not making their own interfaces and instead working with whatever the common IO abstraction is.