@marick @norootcause I understand "features that increase reliability increase complexity" and find it a valuable insight but IMHO this does not invalidate a preference for simplicity. To quote Ousterhout "Simpler designs allow us to build larger and more powerful systems before complexity becomes overwhelming." The problem may not be dichotomy, but applying it across system levels. Adding a feature may add a small, manageable amount of complexity somewhere, while keeping the overall system simple to understand.

Whenever we build the new system, we never design it to make it easy to migrate off of in the future when it reaches the end of its natural lifespan. It’s like with our estimates, we somehow never learn from history. https://mastodon.social/@deech/114604242144233640

@deech Quite right, too! Nobody designs languages to be diachronic. It's a disaster.

« The apparent stuck-ness of any situation is not static; it is not still. Ever-adjusting processes are holding the stuck-ness in place. »
- Combining, Nora Bateson

"We owe the excellent editing to a Dutch engineer working for Shell: Bert Terpstra had sent an intelligent fan letter out of the blue, too late for Feyerabend to have read it. On the strength of that letter Feyerabend’s widow, Grazia Borrini-Feyerabend, had the wit to choose him as editor.”

OMG, that would have been my perfect life. I’d die feeling fulfilled. Which I do not anticipate.

https://www.lrb.co.uk/the-paper/v22/n12/ian-hacking/screw-you-i-m-going-home (2/2)

@wingo I think it depends on the compiler. Anything is possible!

"The internet is full of smart people writing beautiful prose about how bad everything is, how it all sucks, how it’s embarrassing to like anything, how anything that appears good is, in fact, secretly bad. I find this confusing and tragic, like watching Olympic high-jumpers catapult themselves into a pit of tarantulas." https://www.experimental-history.com/p/28-slightly-rude-notes-on-writing

We've just released an early access version of the C++ to Rust Phrasebook, a resource for helping devs translate C++ idioms into Rust. Check it out here:

https://cel.cs.brown.edu/crp/

C++ to Rust Phrasebook via @lesley https://lobste.rs/s/al3t1f #c++ #rust
https://cel.cs.brown.edu/crp/title-page.html

Recently I had a chance to play with MLIR's Dataflow Analysis Framework.
I really love how it is implemented (that is, except of some overly optimistic defaults) and encourage anyone working with MLIR to get familiar with it.

I wrote a guide covering some of the concepts and highlighting some of the pitfalls to avoid.
Knowing this upfront would've saved me a few hours of debugging, I hope it will be helpful for you too 🙌

The missing guide to Dataflow Analysis in MLIR
https://lowlevelbits.com/p/the-missing-guide-to-dataflow-analysis

This morning I found out through the #Ardour forums that Dave Phillips has passed away in November 2023: https://discourse.ardour.org/t/dave-phillips-1951-2023/111854

Dave Phillips was a pioneer when it came to Linux audio with his articles for the Linux Journal and by laying out the foundations for the Linux audio community.

Rest in peace Dave!

#linuxaudio

I'm delighted to announce the 5th edition of Programming Language Pragmatics! I joined Michael Scott as a coauthor. We updated the semantics chapter to use inference rules, & substantially updated coverage of types, OO, codegen, Rust ownership & safe concurrency, async, traits & more!

🎉 Big update! With CalDAV, CardDAV & WebDAV support in Stalwart v0.12, you can now self-host calendars, contacts, and files. No third-party tools required! Learn more at https://stalw.art/blog/collaboration

The reason it's considered (by many) acceptable to churn/sling/vibe code using AI is largely due to how we frame development in respect to design. We consider design thinking as both innately human and a non-technical code-free occupation. We think of developers as machines who only encode design.

If developers get replaced by AI, it's only because we dehumanised them already. And the development itself *will* get worse. Because the best developers actually think deeply about their work.

datalog : graph reachability
::
dependent types : length-indexed lists

Hey you. Do you like low level programming? would you like to contribute to a large and well established project? Because I'm always looking to help new contributors getting started on GDB! It uses C++, but you may also end up needing to remove abstraction layers, so there's tons of things not-C++ to think about, if you want to.

I know that contributing to the GNU Debugger may sound like it's something that would be incredibly hard, or that you need ungodly amounts of knowledge to improve, because that's literally how I felt before sending my first patch, but the truth is, the project was developed by people (humans and otherwise), so silly bugs will abound, and simple oversights will need correcting. There is stuff for every level of programmer to do, from "I've worked on the kernel for 20 years" to "this is my 1st year in college and I'm not scared of large projects"

And here's the kicker, I want more contributors to the GDB project. So, if you are interested in this at all, you can hit me up and I will do my best to help you get setup to contribute (from compiling locally, to setting up git-send-email, running tests) and then help you understand the bugs, the code, and how to make a good commit message (to GDB's standards anyway). I've literally done code-walks with other mentees in the past, I eager to share as much of my experience as you would like to have! and I do my best to be ADHD/autistic friendly, since I'm AuDHD myself and would have really loved a mentor that did that for me in the past...

So... yeah, don't be afraid to reach out!

A free online course by Harvard starting today: American Government: Constitutional Foundations

"Learn how early American politics informed the U.S. Constitution and why its promise of liberty and equality has yet to be fully realized."

https://pll.harvard.edu/course/american-government-constitutional-foundations

Nice little bit of #Scala 3 news: SIP-71has been formally accepted for addition to the language -- https://github.com/scala/improvement-proposals/pull/109/files?short_path=d3572ef#diff-d3572ef3097e37afe674ae0fcf2e2ded08a364798eacf72836f5d2fa55726a05

tl;dr - this SIP adds the `into` type/soft-keyword, which means "this parameter accepts implicit conversions".

It's a compromise between the wild-west implicit conversions of Scala 2 (powerful but sometimes confusing) and the strict language import required in Scala 3 so far.

Not a panacea, but it helps with a major upgrade gap, so IMO it's a win.

great blog post "What Works (and Doesn't) Selling Formal Methods" -- properly focusing on the economics and on communicating what the results mean to a client. both of these are pretty significantly under-appreciated in the FM research community.

https://www.galois.com/articles/what-works-and-doesnt-selling-formal-methods

@shriramk I enjoy reading your impressions. The mythology of cities commands that the number of hills be seven ... E.g. İstanbul, there are other examples https://en.m.wikipedia.org/wiki/List_of_cities_claimed_to_be_built_on_seven_hills