valcron1000

Had no nuke the `target` folder a couple of weeks ago, +400 GB ...

This guy has been preaching against crypto for years, to the point of leaving the Haskell ecosystem just because the language was being used by Cardano. At some point you have to wonder what's going on with him...

Damn, that looks awful.

Where can we read the code?

if it’s a solo greenfield project

That's a big if. I don't have numbers but most professional engineers are not working on such projects

I've been thinking of doing the exact same thing. Preserve context as images and die. Expose a single tool called "eval". You could have a extremely tight editor integration using something like SLIME.

Still nothing to compete with GPT-OSS-20B for local image with 16 VRAM.

When something breaks, I SSH in, ask the agent what is wrong, and fix it.

I am spending time using software, learning

What are you actually learning?

PSA: OP is a CEO of an AI company

If international law had any effect people would believe in it. You're mixing cause/effect. This situation has been going on for years and the lack of response by international organizations makes people lose all confidence in them.

I'm unfortunately on the same situation. We made a consultation with people from Baptist Health Miami and it seems like there are several non trivial requirements for such treatment (histotripsy), like the number and location of mets. Hope that this improves in the mear future.

One of the first things I tried in Rust a couple of years ago coming from Haskell. Unfortunately it's still not stabilized :(

Memory safety is not that sacred. In fact, for many applications malfunctioning is better than crashing

Yeah, just another data leak, no biggie.

Not at the same level. TRAMP is way behind feature-wise.

Zig must also be good for eliminating the same ones.

But Zig does not eliminate them, but rather it might catch them at runtime. The difference here is that Rust promises that it will detect them at compile time, long before I ship my code.

The property of memory safety is itself not binary in both languages

In this case it is: either you catch the issue at compile time, or you don't. This is the same as type safety: just because Python can detect type errors at runtime it does not mean that it's as "type safe" as, for ex. Haskell. This might be due to imprecise usage of terms but that's just the way it's discussed in the craft.

Yes, but instances require the user to provide shrinking while Hypothesis does not: shrinking is derived automatically.

In the sense that you only need to work with the standard IO monad to get the benefits of the runtime.

You don't need "monads" (in plural) since GHC provides a runtime where threads are not 1:1 OS threads but rather are managed at the user level, similar to what you have in Go. You can implement async/await as a library though [1]

[1] https://www.cambridge.org/core/services/aop-cambridge-core/c...

async/await is also available in a bunch of other languages, including F#, C#8, Haskell[...]

Haskell (GHC) does not provide async/await but uses a green thread model.

Knowing if a function will yield the thread is actually extremely relevant knowledge you want available.

When is this relevant beyond pleasing the compiler/runtime? I work in C# and JS and I could not care less. Give me proper green threads and don't bother with async.

I mean, Haskell has like what, 2, 3, 4? Major build systems and package repositories? It's a quagmire.

Don't know when was the last time you've used Haskell, but the ecosystem is mainly focused on Cabal as the build tool and Hackage as the official package repository. If you've used Rust:

- rustup -> ghcup - cargo -> cabal - crates.io -> hackage - rustc -> ghc

    } catch (exception: Exception) {
      // log exception
      throw exception
    }

that data flowing between them consists of simple, agreed-upon formats

HTTP servers and clients, email systems, DNS resolvers—they all interoperate based on simple protocols

Yeah, massive disagree with this. There is absolutely nothing "simple" about these protocols. Try to compose 3/4 UNIX programs together and you necessarily need to run it to see if it even makes sense. Don't get me started on HTTP.

It boils my blood to read "simple" in the context of software engineering

Relevant (2006): https://web.engr.oregonstate.edu/~erwig/pfp/

No need to import a third party library: you can use `Data.Function ((&))` for this:

    arg
     & f1
     & f2
     & f3

How do you deal with persistent sessions in VSCode? I have a remote VM to which I connect through SSH using VSCode, but I need to have certain programs running even after I disconnect from the VM. It's the only reason why I use tmux and I haven't been able to get rid of it.

It did in 10 minutes what would take me several days to learn

I review every small update and correct it when needed

How can you review something that you don't know? How do you know this is the right/correct result beyond "it looks like it works"?

Thanks! I didn't actually build it myself but a professor and other student were also involved. When I joined the project the decision was already made: the professor wanted to use APL and we were using an old CPU architecture book as reference that used APL (Gerritt A. Blaauw, Frederick P. Brooks Jr. Frend, Computer Architecture: Concepts and Evolution 1st Edition).

We almost got the PDP-11 working albeit some extensions like floating point arithmetic.

So you go through my profile and assume that you know my professional background? What makes you think that that's the only project where I've used APL?

Such poor quality comment.

Care to elaborate?

My favorite language used to interpret my most hated language (used both professionally).

There are several things I disagree with regarding Haskell but it's understandable given that this is OP's first time using the language (like a "monad's internal state"), but I want to highlight one particular observation:

This uncertainty of time of evaluation also makes catching errors difficult, because calling catch on the function that throws the error will not necessarily catch that error

It's important to distinguish between imprecise exceptions (ex. calls to `error `, `undefined`, and the like) and synchronous exceptions (async exceptions are not important for the article).

Catch must be called on the function that forces evaluation on that error. This is something that is hard to trace, and something that types don’t help much with.

The types are actually the most important part here! Synchronous exceptions cannot be thrown by pure code (as long as we're not dealing with escape hatches like `unsafePerformIO`), while IO code can throw and catch all kind of exceptions .