Arthur Wang

iOS programmer

[uixamjad @uixamjad]

Really ?? Figma 🥳🥳😳😳😳😳 https://t.co/r499awmb2M

[Kimi.ai @Kimi_Moonshot]

Here's a short video from our founder, Zhilin Yang.

(It's his first time speaking on camera like this, and he really wanted to share Kimi K2.5 with you!)

[Kimi.ai @Kimi_Moonshot]

Kimi K2.5 has arrived! 🥝
Here are 2 things to know: Aesthetic Coding x Agent Swarm.

[Arthur Wang @Arthraim]

RT @Kimi_Moonshot: 🥝Meet Kimi K2.5, Open-Source Visual Agentic Intelligence.

🔹Global SOTA on Agentic Benchmarks: HLE full set (50.2%), Bro…

[Arthur Wang @Arthraim]

昨天已经走过闸道口了，我问她要不要回头等等火车头，她说好，于是站在寒风了等了10分钟，离开的时候棉花说，我们还是等了一辆火车呢。

[Arthur Wang @Arthraim]

正在觉得倒霉，在闸道被第一辆拦下来的时候，棉花说，哇可以看到火车头了，太幸运了

[Arthur Wang @Arthraim]

时代真的变了，听到同事说：你annotate一下。
愣了下
咱都说的blame一下 =。=
#git

[Star Wars Facts @sw_tweets]

Diego Luna assembling Cassian Andor’s blaster rifle

[rushilshah @rushilshah_x]

Using the blur trick for optical alignment

[Crystal @crystalsssup]

really interesting, banger in changelog

[Petrichor @Jam79922967]

要吃出精美、吃出艺术，不仅需要创意，还有好的顺手的工具。

[Y Combinator @ycombinator]

Make something people want.

[Arthur Wang @Arthraim]

当你的what's new写的太骚了⬇️

[The Type @TheType]

为进一步扩展 The Type 订阅会员权益，我们正在筹建 The Type Club 会员俱乐部，群组内将：

• 分享专属活动
• 推送最新内容
• 进行会员礼品抽奖
• 提供会籍管理服务
• 举办交流会和问答会
• 闲谈、探讨、新知、解惑

我们将开设「Telegram 群组」和「微信群组」，The Type 团队静候您的加入。

烦请添加以下客服账号进行会籍验证：

Telegram：

https://t.co/F0US8eRzd8

微信：

thetypemembers

欢迎各位会员字谈字畅，畅所欲言！

https://t.co/EVsgYGFVMf

[TablePlus @TablePlus]

There are no Swift Markdown tokenizer that are fast enough, so I'm going to write one for the LLM native chat.

The price of not using web-view-embedded is that you have to implement many things if you want it to have good performance 🥲

[Jonathan Blow @Jonathan_Blow]

I read this article about software development, which I knew about because I saw Prime reacting to it:

https://t.co/oXYuMTRXs0

For the most part I think it is fine: a relatively young programmer is doing the healthy work of introspecting on what he should really be doing.

But there's one part of the article that I think is a deep mistake, and the author doesn't know it's so wrong because he has never experienced the alternative:

"Software doesn’t stay solved. Every solution you write starts to rot the moment it exists. Not now, not later, but eventually. Libraries deprecate. APIs change. Performance regressions creep in. Your once-perfect tool breaks silently because https://t.co/KC2vCoIkWK is now https://t.co/KC2vCoIkWK.2. 2

I have had scripts silently fail because a website changed its HTML layout.
I have had configuration formats break because of upstream version bumps.
I have had Docker containers die because Alpine Linux rotated a mirror URL.

In each case, the immediate emotional response was not just inconvenience but something that moreso resembles guilt."

Yes, this is true in much of the programming world. But there is another world in which people build things that last much longer. I have done it many times. I shipped a binary for this game Braid in 2009 that you can still download and play on Steam 16 years later. If you are pretty young (like 35), you can run binaries on Windows that were compiled before you were even born, which is amazing given how hard they have been trying to f up Windows lately.

On an emulator like MAME, you can play arcade games programmed in 1979. If today's software "technology" is so much better, why does it fall apart like tissue paper?

The author is not wrong about the cited decay. But this decay is not inherent to the practice of software. It's due to choices made, usually foolishly, by the people designing the systems being interacted with. And, it's due to a lack of knowing better, non-exposure to the sector of programmers who are very concerned with their code lasting a long time, actually.

The way you make code last a long time is you minimize dependencies that are likely to change and, to the extent you must take such dependencies, you minimize the contact surface between your program and those dependencies.

The actual algorithms you program, the actual functioning machinery you build, is a mathematical object defined by the semantics of your programming language, and mathematical objects are eternal, they will last far longer than your human life. The goal then is to avoid introducing decay into the system. You must build an oasis of peace that is insulated from this constant bombardment of horrible decisions, and only hesitantly interface into the outside world.

This means, for example: If you are shipping on iOS, you only reluctantly use any functions iOS gives you, because when you use them, Tim Apple will come along and break your program next year for arbitrary pointless reasons, because Tim Apple does not respect you or anyone you know.

This means a program cannot last forever on iOS, because Tim Apple likes breaking your things and watching you submissively clean them up. But the core of your program, which could be 95% of the code, is fine, and you can deploy it elsewhere.

This means you have to insulate from Linux userspace, because of all the jackass decision making that introduces constant incompatibilities while somehow never making the system better.

Using a library dependency to do font rendering or sparse matrix math? That dependency gets checked into your source tree, a copy of exactly the version you use. Ten years later you can pull down that source and recompile, and it works, because your program is a mathematical object. If you want to upgrade to something newer that has bug fixes and so forth, you are free to do so, but you are also free not to do so, and your program still works. (And how many of these bug fixes do you really need? Your program worked correctly when you shipped it to the greatest extent you could measure, because you are a skillful software engineer who wants to ship things of a high quality).

Everyone who got into programming for the joy of it knows, at some level, that the magic of programs is that they represent complexity that is replicable over time (and thus they exist outside of time). But the trashy programmer culture of the past 20 years stopped aspiring to this, and now has forgotten it is even possible.

And so long as people have forgotten, decisions will continue to be made that make the problem worse.

There are programmers who only write glue code, and who think that's what programming is; to these people what I have written above will not make sense. But the good news for that contingent is, they can always just stop writing glue code and start doing something else! If today's software "technology" is so good, why do you think it needs so much glue? Maybe there is a stylistic problem.

So if you are looking for what to do in the world of software that can represent a lasting contribution, maybe this is food for thought.

@NotAShelf @ThePrimeagen

[K.L @kinglinzhuhui]

🥰没有中间商，才是世界该有的样子。
美国“TikTok 难民”通过小红书结识中国家庭，通过一些时间的小红书互动，中国友人邀请美国家庭来上海相见，希望这种没有中间商的互动更多些，增进相互了解。

[Ryan Cash @ryanacash]

10 years ago today my life changed forever.

On the morning of February 19th, 2015, Alto’s Adventure launched into the world.

What started as a tiny passion project became something that took over my life in ways I never expected.

Here’s a look back – at the highs, the wild moments and the people who made it all possible. 🏔️✨🧵

[Yachen Liu @Blankwonder]

SwiftUI 和 React 这种依靠状态绑定的声明式 UI，会让开发者写起来非常爽，能很快就搞出个七八十分的产品。但是为了最后那二三十分，花几倍的时间都不一定解决的了。
这些问题通常是由设计模式本身所决定的，随着逻辑与流程的复杂度提升，单纯靠状态量绑定很难表述所有的状态，特别是状态的迁移。
我认为的最佳实践，一是根据场景选择，如果是本身凑合用用就行的临时工具，那么声明式 UI 没有问题，如果是精品项目，那还是慎重，不要贪图一时爽快。
另外混合使用是非常不错的方案，对于布局复杂但是逻辑简单的页面使用声明式 UI，而整体架构依然使用命令式 UI。

[Swift Language @SwiftLang]

Open sourcing Xcode's build engine -- introducing swift-build: https://t.co/huxgprd8v5

[Arthur Wang @Arthraim]

「如果年轻一代都是不假思索，把历史抛在身后，那当有一天它突然出现在我们面前的时候，我们甚至无法分辨出它的脸」