arendjr

Zen is simply a fork of Zed for those who are happy to use an IDE free from AI, telemetry, and other cloud-based services. I use it as my daily driver and intend to maintain it so that I can also use it as the base for some non-developer tooling I want to create.

Only tested on Linux for now, though Zed's support for other platforms should be (mostly?) intact.

Biome is an integrated linter/formatter for JavaScript/TypeScript, CSS, HTML and GraphQL.

We are now in the process of implementing TypeScript-like inference (not full type checking!) that allows us to enable type-informed lint rules. This is similar to typescript-eslint except instead of using tsc we attempt to implement the inference ourselves.

This post describes our progress thus far, with a detailed overview of our type architecture.

Biome is a formatter and linter for JavaScript, TypeScript and other web languages.

With this partnership, we aim to develop TypeScript-compatible type inference that works out of the box for use in our lint rules.

Sorry, it’s an integrated linter and formatter for web developers.

Biome lead here, so feel free to ask anything!

Biome is an integrated linter and formatter with support for JavaScript, TypeScript, CSS, and more.

Highlights of the release:

* Plugins: You can write custom lint rules using GritQL.

* Domains: Domains help to group lint rules by technology, framework, or well, domain. Thanks to domains, your default set of recommended lint rules will only include those that are relevant to your project.

* Multi-file analysis: Lint rules can now apply analysis based on information from other files, enabling rules such as noImportCycles.

* `noFloatingPromises`: Still a proof-of-concept, but our first type-aware lint rule is making an appearance.

* Our Import Organizer has seen a major revamp.

* Assists: Biome Assist can provide actions without diagnostics, such as sorting object keys.

* Improved suppressions: Suppress a rule in an entire file using // biome-ignore-all, or suppress a range using // biome-ignore-start and // biome-ignore-end.

* HTML formatter: Still in preview, this is the first time we ship an HTML formatter.

* Many, many, fixes, new lint rules, and other improvements.

Love it! Great quote and very on point.

As for Heraclitus vs. Plato, I think the lesson I’m trying to teach is to not pick a side until you understand each position’s implications and which of those might be more beneficial to the problem at hand ;)

xD

In all seriousness though, you do hit a great point. The moment you stop being embarrassed about your mistakes and set your ego aside, is the moment that you can truly start learning from those same mistakes. At some point it even becomes the only way you can move forward, unless you want to stay boxed inside a niche of expertise defined by your own self-set boundaries.

Thanks! I would just like to clarify I’m actually not opposed to OOP at all, and at several points I tell people it’s fine to go in that direction for the problems where you need it. I do try to warn against it as a go-to solution before you’ve understood what are the problems that actually need fixing, which it sounds like we’re pretty aligned on.

Indeed if you pass by value/use immutability where feasible, you already avoid most of the issues I’m warning against, so it sounds like you found a sensible way to apply it while avoiding the pitfalls.

> If I have to give a taxi driver a jerrycan full of petrol, that's the definition of a leaky abstraction... Possibly literally in this case.

:D

That’s useful feedback, thanks!

I like this one, thanks!

I actually have nothing against objects and methods, but that’s a very limited subset of OO. I prefer to use algebraic data types for domain modeling, and giving them methods is totally fine too. But I do prefer them to be immutable in most cases, which is also quite counterintuitive from an OO perspective.

The keyword to search for is algebraic data types, which are common in functional languages, but for instance Rust also has them.

Here is an example comparing C# with F#, where the latter also algebraic data types: https://blog.ploeh.dk/2016/11/28/easy-domain-modelling-with-...

Just know that if you do this, you’re injecting statefulness in the center of wherever it was this procedure was being used. If your entire system already has statefulness everywhere, nobody will bet an eye. But if you want to have any chance at creating a functional core or island, it’s the opposite of what you should be doing.

Biome is a formatter and linter for the web, written in Rust. We’re currently asking for input for developing a plugin system, where the main contenders seem to be JS/TS (possibly through the use of Deno crates) and WASM.

Glad to see my contributions included in a public release =) https://biomejs.dev/blog/biome-v1

Congrats to the team, and wishing the project a healthy future!

From what I gather, a lot of Reddit usage comes from Google referrals, similar to how StackOverflow gets a lot of its traffic. If people leaving Reddit delete or scramble their comments (which some are definitely doing), they also screw up Reddit’s referral value and Google ranking, so Reddit has quite some motivation for trying to restore those comments.

This is mostly an advisory and inspirational tale on how to become a better programmer with a focus on delivering value. It’s primarily based on personal learnings, but I hope they resonate with others. Feel free to share your own thoughts or learnings!

At least Bash doesn’t have that hideous topic selector

I would be sympathetic if it were purely `”Hello, World!” |> console.log`. I still wouldn’t use a pipe in such a trivial case, but at least it’s not really worse. But with the topic selector that example has strictly more concepts you need to understand than the example without pipe. From an educational perspective that’s already not great, but what’s more worrisome is that proponents tend to suggest the pipeline should be used wherever you can, despite simultaneously “knowing” when not to use it and ignoring examples where you cannot use it due to multiple subjects being composed.

It’s not the pipeline in general that I’m against, but I’m very opposed to this “let’s-add-a-third-syntax-to-compose-arbitrary-expressions-Hack” proposal.

Unlike pipe operators in functional languages, the Hack proposal is aimed at composition of expressions instead of functions. This makes the proposal extremely pervasive and unfocused, enabling people to write `a |> %[0]` instead of `a[0]`, for instance.

Proponents argue it’s great because you can pipe arbitrary expressions without nesting or needing temporary variables, but opponents argue it harms readability and will result in needless style arguments.

The pipeline operator currently sits at Stage 2 as an ECMAScript proposal. Many people (including me) believe the current proposal is a harmful addition to the language, and it would be better to not have a pipeline operator than the current Hack proposal. For this reason, I created the linked ESLint plugin.

In this post, we detail how we use fp-bindgen (https://github.com/fiberplane/fp-bindgen) and Redux reducers written in Rust (https://fiberplane.dev/blog/writing-redux-reducers-in-rust/) to create our own Rich Text Editor. Feel free to ask us anything!