5,980 karma · joined October 2, 2018
If you see the typescript options it's like giving yourself a water boarding session through your own volition.
What deepseek has done is so much better than anything else in the West that the panic hasn't left yet.
I think there is going to be a counter reaction towards artisanal apps which will come out of all of this.
Just how WordPress runs 70% of the web but it's 70% of the crap web.
Similarly AI will maybe create 70% of the apps but it will be 70% of the crap apps.
And this is not some sort of reflection on AI. AI is actually great tech, but it's more about the person making the app and the proof of work required to show how much they care about the product. Or in this case these apps will be associated with shady fly-by-night companies trying to sell something.
Now they have gone from crypto grifting companies and AI hyped companies and it really seems that the a-level players are missing.
Or maybe it's just a matter of smaller teams and focus and care.
I think now I see YC more like a job for the partners than a passion.
I might be wrong but there is definitely something to it that YC has not had a success for a very long time.
It's really sad because YC is one of the best things to happen to the tech industry.
> Modern editors like Visual Studio and Visual Studio Code have excellent performance.
Well I am not sure we are on the same page here. Still, fingers crossed.
The surface area of apis would be limited because you would be constrained by what you can keep in your head, but now you're free to just add hundreds of different methods.
One of my theories is that Java actually has so much sprawl is because how good the IDEs were for Java so I think overall, it definitely adds to brain rot.
let x = 10
<div>{x}</div>
x = 12
now the div changes.
It had its own unique, clean way of doing things and had its own identity.
Now they went down the route of looking like exactly like the others while doing everything much worse.
Of course a bunch of people keep telling me that yeah, this is much better. But they are brainwashed.
That stuff is already a mess so the AI slop that comes out is also messy and that's fine as long as it looks good and performs well. and does what I want and it's also really trivial to change.
However, I'm not letting it come near any backend code or actual development.
It can get basic front-end react apps done but nothing beyond that.
But since front-end programming wasn't ever really programming, I don't mind that and I sometimes use it for that.
For everything else, it just makes a massive mess.
It's good to ask it questions about pretty common topics and get a cleaner reply than searching stuff yourself on Google and going through spam articles.
But any sort of insight or any sort of new learning, it just simply doesn't have it.
Furthermore, all of the hyping of research assistants for $20,000 and all of that is just absolute bullshit.
And no, there is no AGI coming.
Lol. Poor Azeem Azhar who is a Freelance Contributor.
> I think in three years AI will become useful for mathematicians. It will be a great co-pilot. You’re trying to prove a theorem, and there’s one step that you think is true, but you can’t quite see how it’s true. And you can say, “AI, can you do this stuff for me?” And it may say, “I think I can prove this.”
> It’s a very exciting potential use of AI to create connections or at least point out possible connections. Right now it has a very lousy success rate. It might give you 10 suggestions of which one is interesting and nine are rubbish. It’s actually almost worse than random. But this could change in the future.
As usual the title is embellished and his actual interview is it "might" be useful.
GPT 4.5:
In Clojure, the *thread-first macro* (`->`) is used to improve code readability by threading a value through a series of function calls. It takes an initial value and passes it as the first argument to the next function, then continues threading the result through subsequent functions. This eliminates deeply nested expressions and makes the code more readable.
For example,
```clojure (-> 5 inc (* 2) str) ;; Equivalent to (str (* 2 (inc 5))) → "12" ```
Here, `5` is incremented to `6`, then multiplied by `2` to get `12`, and finally converted to a string.
---
Deepseek v3:
In Clojure, the `->>` (thread-last) and `->` (thread-first) macros are used to improve code readability by allowing a more linear, pipeline-like flow of operations. The `->` (thread-first) macro takes an initial value and threads it as the first argument through a series of forms. For example, `(-> x (f) (g))` translates to `(g (f x))`. This is particularly useful when working with nested function calls, as it flattens the structure and makes the sequence of transformations clearer. It’s commonly used with functions that take the threaded value as their first argument, such as collection operations or Java interop methods.