11,185 karma · joined February 6, 2013
I'm a software developer specializing in accessibility for blind and visually impaired people. From mid-2017 to late 2020, I worked for Microsoft on the Windows accessibility team, though my comments were always my own opinion posted on my own initiative.
I'm legally blind myself; I have enough sight to read a desktop computer screen up close with slightly enlarged fonts, but I often use a screen reader when browsing the Web, doing email, and other tasks that don't involve code. (Don't get me wrong; totally blind people can program, but I never got used to doing it that way myself.)
Of course, there's more to me than visual impairment. When it comes to programming, I'm also particularly interested in the challenges of developing cross-platform applications that integrate smoothly with the host platform. Outside of programming, I love music and love to sing. Pre-COVID, I often did karaoke (of course, I memorize the words). And like many nerds, I read science fiction.
Email: mattcampbell@pobox.com
Mastodon: https://toot.cafe/@matt
Blog: http://mwcampbell.us/blog/
Location: Wichita, Kansas, US
[ my public key: https://keybase.io/mwcampbell; my proof: https://keybase.io/mwcampbell/sigs/9sbxkfOoTyW6C8IiDB50bP_ZWa-V73AfbdmvUlfOKe8 ]
My bet, and I realize this might just be wishful thinking, is that the high order bit for being an effective software developer in the near future will be skill at using more reliable and non-exploitative automation tools, such as programming languages with powerful macro systems and other high-level abstractions, to stay competitive with developers who sling LLM-generated code. So I'd better get started developing that skill myself.
I bear some responsibility for this, since I was one of the people who basically said, in the 2010s, that we should just give up and use popular languages like JavaScript because they're popular. I regret that now.
We've all already heard this message a thousand times. There's no need to keep repeating it. Don't discourage people, especially young people, who want to do great work.
Except we shouldn't even hate _them_, because they're sentient beings too. I guess we should only hate the worst aspects of our own nature.
I'm guessing you're specifically referring to Gecko's early over-use of XPCOM, which the Gecko team itself had to clean up in a long process of deCOMtamination [1].
I'm hopeful that if Servo ever gets enough funding to become a serious contender among browser engines (hey, KHTML was once an underdog too), that it might walk a middle path between overuse of COM-ish ABIs and what you described about Chromium. Servo is already decomposed into many smaller Rust crates; this provides a pretty strong compile-time boundary between modules. Yet those modules are all statically linked, and in a release build, that combined program gets the full benefit of LTO. Of course, where trait objects are used, there's still dynamic dispatch via vtables, but the point is that one can get strong modularity without using something COM-ish everywhere.
Incidentally, the first time I built Chromium (or more specifically, CEF) from source in late 2012, I was impressed as I watched hundreds of static libraries being linked into one big binary. Then as I studied the code (though not deeply enough to learn the things you described), I saw that Chromium didn't use anything COM-ish internally (though CEF provided a COM-ish ABI on top). That striking contrast with Gecko's architecture (which I had previously worked with) stuck with me. I wonder how much the heavily reliance on static linking and LTO (meaning whole-program optimization), combined with the complete lack of COMtamination, contributed to Chrome's speed, which was one of its early selling points.
[1]: Mozilla used to have a dedicated wiki page about deCOMtamination, but I can no longer find it.
As for our tendency to disrespect the copyrights of art, clearly we've always been in the wrong about this, and we should respect the rights of artists. The fact that we've been in the wrong about this doesn't mean we should redouble the offense by also plagiarizing from other programmers.
And there is evidence that LLMs do plagiarize when generating code. I'll just list the most relevant citations from Baldur Bjarnason's book _The Intelligence Illusion_ (https://illusion.baldurbjarnason.com/), without quoting from that copyrighted work.
https://arxiv.org/abs/2202.07646
https://dl.acm.org/doi/10.1145/3447548.3467198
https://papers.nips.cc/paper/2020/hash/1e14bfe2714193e7af5ab...
The strongest reason I can think of to discard this kind of automation, and do so proudly, is that it's effectively plagiarizing from all of the experts whose code was used in the training data set without their permission.
Here's an article that argues otherwise, convincingly IMO:
https://buttondown.com/maiht3k/archive/information-literacy-...
Can you please explain? I'm just curious, not arguing.
Any idea why? Is it because of some patent they hold?
Wouldn't it be annoying to be blocked on Apple rather than shipping on your schedule?
Is it actually going to be feasible to use WasmGC in Rust? I haven't yet found anything on this.
Can you give an example of what you mean here?
That is, rather than use an LLM to generate boilerplate code from an ambiguous natural-language prompt, use a high-level programming language to precisely, concisely, and directly express what you want.