I’ve read this comment on lemmy’s github repository by sbordeyne:

I closed it cause I have no interest in having to battle dessalines on minor nitpicks. Feel free to take the branch and reopen the pull request.

My thought process was that since lemmy is open source, we should be free to add new features without having to battle over philosophies, which was made apparent to me with his reviews and very strong opinions over which features to greenlight and which features to debate at length over (see infinite scrolling, and this very issue which was only approved on the condition we make it a setting that is off by default). I just don’t have the energy to contribute and be challenged on every little thing, I’ll just remain a plain user of the platform and not bother contributing to the project anymore.

Originally posted by sbordeyne in #282 (comment)

Instead of contributing to a project where only @dessalines@lemmy.ml, lionirdeadman and @nutomic@lemmy.ml dictate what gets approved, why not make a fork with the settings most people agree on?

My stance is that I wouldn’t contribute to a project hosted on GitHub, or a project that considers a few opinions more important than the majority.

Controversial takes
dessalines doesn't want SEO so we get URLs for robots

It might makes sense for the semantic web, but IMO it really doesn’t add that much value… look at how silly this type of thinking has gotten w/ reddit: https://www.reddit.com/r/aww/comments/glenz4/cute_baby_bunnies_think_the_golden_retriever_is/

Its gotten to reddit/community/comments/post_id/weird_lengthened_post_name, when it should be just reddit/post/postid

_Originally posted by @dessalines@lemmy.ml in https://github.com/LemmyNet/lemmy/issues/875#issuecomment-652165036_

:::

In my opinion, open-source projects should follow a set of principles to ensure transparency, community engagement, and effective development. Here are some key points that encapsulate these principles:

  • Clear Decision-Making Process for Future Releases: Open-source projects should have a well-defined process for deciding what features and improvements make it into each release. This process should be documented and accessible to the community. (For example, you can read about how Discourse decides what goes into each release here).

  • Complaint-Driven Development: Embrace the concept of “complaint-driven development,” where user feedback and complaints guide the prioritization of issues and features to address.

  • Transparent Donation Management: Be open about how donation money is allocated. Implementing a bounty system can further enhance transparency, enabling contributors to work on specific tasks for financial rewards.

  • Inclusive Community Involvement: Encourage active participation from the community in brainstorming and voting on potential features before finalizing the project roadmap. Community input can be invaluable in shaping the project’s direction.

  • Public Roadmap: Maintain a publicly accessible roadmap that outlines what is planned for upcoming releases. This roadmap should include the status of each feature or enhancement to keep users informed.

  • User-Friendly Feature Request Process: Provide a public feature request forum where users can submit their ideas. Clearly outline the process for how these requests will be reviewed and prioritized, ensuring transparency in the decision-making.

  • Effective Communication Channels: Avoid using disorganized or private communication platforms for project-related discussions. Instead, opt for well-structured, publicly accessible channels that don’t require users to log in to access information.

  • Document with a Blog: Utilize a blog or similar documentation platform to keep users and contributors informed about important project updates, changes, and developments.

  • PenguinCoder@beehaw.orgEnglish
    15·
    1 year ago

    I had a bunch of stuff typed here (probably too much), clicked a damn icon on this UI and POOF when my entire comment…

    These are my opinions, probably not shared with others and surely not the end all be all to ‘why not Rust?’

    Rust is hard. Rust is slow to iterate with and compile. Here’s a highlevel overview of the things you’d need to learn to effectively understand Rust code; not even speaking to learning enough of that to write it. Rust gets touted as secure, and it is more secure than other low level languages like C/C++. That does not make it invulnerable to exploits. It gives a false sense of security to developers who think My app can’t be hacked, it’s written in Rust!!. While Rust is better at memory management and protecting against run time errors related to memory issues, that doesn’t make it 100% safe. That removes almost one class of potential exploits, not all of them, and can’t protect the developer against other developer created issues. Rust code is still written by people. People still write insecure code even in Rust. Computers are dumb as hell; but fast. People are smart as hell, but SLOW. Combine the two and you get stupid things faster; not smarter things better.

    • Rust development is hard, hard to learn, very hard to do right
    • Rust is not suited for a web application. Would you tell someone to go write the web application and web page in C/C++? Nope. There’s a reason for that. Not suited to it. Square peg, round hole
    • There’s always exploits being discovered. Rust handles some things better, but uhhh… Go look at some Lemmy Rust code. Definitely still has vulnerabilities; Rust won’t save you from yourself.

    Something like Golang is much better choice for development of a web service that has sane API handling. By the time to add in more error handling, more type checking, more passing around of this function or that data, and more checking it on the sender and receiver side…etc. By the time you’re writing Rust safely and correctly; it is much slower than what you may be lead to believe.

    Go is primarily designed for speed of development (including compilation times), rather than speed of execution. Go programmers tend to value clear code over fast code. Why does a microsecond longer matter for a website? Maybe in some backend PLC land there’s a damn good use for that performance. For a networked web application; it’s a pointless metric. That is not going to be your bottleneck.

    Rust is hard to understand just reading it let alone determine why it’s doing something.

    Rust

    fn does_what(n: u64) -> bool {
    match n {
        0...1 => false,
        _ => !(2..n).any(|d| n % d == 0),
    }
}

    Golang

    func doesWhat(value int) bool {
    for i := 2; i <= int(math.Floor(float64(value)/2)); i++ {
        if value %i == 0 {
            return false
        }
    }
    return value > 1
}

    Not talking about the functionality merits of the two, but in comparing the _code itself. One of those is much easier to determine what’s going on and what it should be doing versus the other. I don’t feel like fighting my code. Programming is a tool to help. If it takes more work to use the tool to achieve your goal, it’s the wrong tool. Rust is the wrong tool for web development.

      • 1stTime4MeInMCU@mander.xyzEnglish
        8·
        1 year ago

        You can write anything in anything. The downsides have to be outweighed by the positives and OP is suggesting there isn’t enough positive.

      • MasterBuilder@lemmy.one
        6·
        1 year ago

        I suppose the question is whether Rust is worth the extra work. I know nothing of rust. I know C#, JavaScript, and some other web app tools. Is Rust significantly better than those? Are there enough developers interested in Rust to encouage robust participation?

        Can Lemmy handle plugins in a language agnostic way? If so, that might be a better route. Again,I am not advocating anything, just raising questions that can lead to an informed decision.

        • Dark Arc@social.packetloss.ggEnglish
          2·
          1 year ago

          This is the problem I always run into. I’m very skilled with C++ and Python, a little rusty (though I’ve written hundreds of thousands of lines) with Java and Ruby… Rust hasn’t offered me anything to justify the learning curve.

          It also scares me as it’s evolving quickly… perhaps too quickly. It seems like a complicated language that’s just getting more and more complicated.

          I’ve had the same issue with Go (module the ever increasing complexity/rapid evolution). For Rust C++ or Java better suit my experience, for Go it’s Java and Python.

    • jarfil@beehaw.org
      3·
      1 year ago

      Why does a microsecond longer matter for a website?

      Because some more microseconds later, it’s the difference between being able to serve 1k requests per second and dropping connections, vs. 100k requests per second and working smoothly.

      Rust is a great tool for backend development, which is all that Lemmy server is. The frontend Lemmy-UI is written in JavaScript.

      BTW, in your example, I find the Rust version easier to understand 🤷