#worseisbetter — Public Fediverse posts

@kentpitman wrote quite some time ago:
«...
I often do binary partitions of languages (like the static/dynamic split, but more exotic), and one of them is whether they are leading or following, let's say.
...
But, and this is where I wanted to get to, Scheme led on continuations. That's a hard problem and while it's possible, it's still difficult.
...
In the early days of Lisp, the choice to do dynamic memory management was very brave.
...»

Is this related to Worse Is Better?

(I suppose it may be unusual to apply the latter to the Lisp family of languages, but nevertheless.)

#ComputerProgramming
#Lisp
#ProgrammingLanguages
#ProgrammingLanguageDevelopment
#WorseIsBetter

@screwlisp @cdegroot @ramin_hal9001

"To serve you better, we're raising the price of your home internet plan by $5 per month"

Thanks, #Sasktel !

(This is a company I already pay $3,200 / year for internet, TV, and landline)

#WorseIsBetter #ToServeYouBetter #CustomerService #WeveHeardOfIt #ripoff #internet

🧵 3of3
The last portion of Richard Gabriel's #WorseIsBetter is most salient pour moi:

"Completeness: the design must cover as many important situations as is practical. All reasonably expected cases should be covered. Completeness can be sacrificed in favor of any other quality. In fact, completeness must sacrificed whenever implementation simplicity is jeopardized. Consistency can be sacrificed to achieve completeness if simplicity is retained; especially worthless is consistency of interface."

NGL the CS Stanford Edu (middle of thread was the more enjoyable read for me)

#ThinkElegantly #WednesdayWisdom

🧵2of3
Richard Gabriel "The worse-is-better philosophy is only slightly different (MIT/Stanford style of design's The Right Thing):

Simplicity: the #design must be simple, both in implementation and interface. It is more important for the implementation to be simple than the interface. Simplicity is the most important consideration in a design.

Correctness: the design must be correct in all observable aspects. It is slightly better to be simple than correct.

Consistency: the design must not be overly inconsistent. Consistency can be sacrificed for simplicity in some cases, but it is better to drop those parts of the design that deal with less common circumstances than to introduce either implementational complexity or inconsistency."

Source: https://web.stanford.edu/class/archive/cs/cs240/cs240.1236/old/sp2014/readings/worse-is-better.html

#WorseIsBetter #WednesdayWisdom #ThinkElegantly

🧵1of3 Design Simplicity & Thinking Elegance
Albert Einstein: "Everything should be made as simple as possible, but not simpler."

CS Stanford Edu: "Our particularly interpretation of worse-is-better is as follows: When tradeoffs are required in a software system, priority should go to implementation simplicity at the expense of completeness or correctness."

Source: https://cs.stanford.edu/people/eroberts/courses/cs181/projects/2010-11/WorseIsBetter/index353f.html?title=Worse-is-better&oldid=48#:~:text=The%20worse%2Dis%2Dbetter%20design,simplicity%20(that%20is%2C%20ease%20of

#WorseIsBetter #WednesdayWisdom #ThinkElegantly

🤔 Warum setzen sich häufig vermeintlich „schlechtere” Lösungen gegen technisch überlegene Systeme durch?

Das Worse-is-Better-Prinzip zeigt, dass Einfachheit Perfektion oft übertrifft. Dies gilt insbesondere im Technologiebereich. Ein Artikel darüber, warum weniger oftmals mehr ist.

https://pyngu.com/magazin/tech/worse-is-better/


#Technologie #SoftwareEntwicklung #WorseIsBetter #Tech
#pyngumagazin #pyngurocks

Needless to say, this is interesting and valuable.

I wonder how this approach could be applied to Richard Gabriel's famous "worse is better".

I can't summarize it properly here, but in a sentence,
this is a thesis that
a partial solution that is available now and that can be improved later
often wins
over a complete solution that takes a long time to be produced.

#DoingTheRightThing
#WorseIsBetter

@johncarlosbaez @Adittya

@atlefren @kly

Det er på et vis den naturlige utviklingen av å prioritere "enkelt å komme igang" over alt annet. Har sett noen tilsynelatende js-utviklere omtale det på et vis som … kanskje er sånn Rust-typer ville omtalt js og php.

Basert på det forventer jeg at det blir ekstremt vanlig og ekstremt dritt. #WorseIsBetter gjelder formodentlig fortsatt (selv om js ser ut til å bli skiftet ut med ts i disse dager)

@cstross Unfortunately what UNIX actually delivered was "a bunch of tools that just barely perform their purpose", the culmination of #WorseIsBetter.

These days I barely use bash files as config files with reams of `export FOO=BAR` or a bunch of flags set for some other command; pretty much anything complex enough to have some conditionals or functions get turned into a Python script.

Perl at least got `use strict;`; bash remains broken with its "unofficial strict mode".

My last highlight ITT is the excellent tooling around the Scheme language, from which Skribe is derived, to build your own blog (with a bit of CSS) and/or export your documents as PDF with \LaTeX.

Thanks to Guix your students probably won't have a wifi connection, but they won't need it because they'll be able to:

- export their documents as PDFs offline,
- build their websites offline thanks to Haunt and git(7) CI,
- manage their PKS offline thanks to the Denote standard (which lets you rename documents according to their creation/publication date, title, and keywords)
- read the docs offline,
- read SICP offline (guix install sicp info-reader)…

Not to mention GNU Guile, which superpowers Scheme and Emacs Lisp programs (with Lua support underway), in which Denote is implemented as part of the GNU project, which has incumbated at the MIT.

Your regular humanities students can do all of these tasks with the tools that exist today, for free, with minimal IT support (and no IT support for Skribe authoring).

3/3

#Denote #SSG #Git #CI #Guix #Guile #Blog #Blogging #100DaysToOffload #WorseIsBetter

This, Too, Shall Pass: Reflections on Secure Computing

My friend Daniel posted something perky, positive, and constructive, and so I had to reply with my sentiment:

This too shall pass. https://t.co/oHuo3Z2Gst

— Alec Muffett (@AlecMuffett) February 27, 2024

A good report by the @WhiteHouse (ONCD) on the path to secure and measurable software … With memory safe languages being pushed to the front of the queue.

Oh, how I wish, my sweet summer children, but alas the world does not work that way; I’ve been doing this stuff professionally since 1988 which makes it 36 years or so, plus another 5 year or so as a larval hacker-nerd, so in my 40 years of experience I have seen:

• at least 2 previous iterations of “AI is coming and will destroy everything”, including the “Fourth Generation Languages Which Will Write Themselves” in the era of BASIC, and the second-wave AI of the 1980s which even then was glorified pattern-matching
• at least two previous iterations of “memory safe languages will fix everything” including Erlang (which would have meant that we could live-patch machines, because “functional”, and therefore we would not need DevOps!) and Java (which could/would never, ever, ever, be unsafe, because of a hand-tooled and unproven software theorem checker validator dynamic loader which people would know never to hack-around as a deployment convenience.
• the death of VMS and Unix — macOS and *BSD does not count — and their replacement in the enterprise by Windows and Linux… where both of the former had their flaws but were actually engineered to be good for the enterprise, as opposed to agglomerated-and-fixed (Linux) or overstretched desktop software (Windows)
• we used to have code injection; then we had SQL injection and XSS; now we have prompt injection. It seems that “injection” is perennial

In the 1980s practically every university computer science department had a “Sun Lounge” or “Solarium” filled with Sun computers; and when the students left they went into Wall Street and dragged what they knew along with them, and Sun’s fortunes boomed.

Sun axed its educational sales to focus on Wall Street and the pipelines of expertise collapsed, leaving students to “grow up” on Linux and Windows; and when they left they went into Industry and dragged what they knew along with them, and Linux and Windows became deployment platforms in spite of their deficiencies.

My first experience of the cultural generational mismatch was around y2000 at Sun where EDS had been brought in to manage a datacentre of Starfires and other enterprise kit which were supposed to maintain beyond-5-nines of uptime, and where literal millions of dollars hinged upon them delivering that; the “expert” from EDS instituted “weekly reboots” to keep them fresh — just like Windows — and EDS was promptly kicked-out of the datacentre within 48 hours.

Various “web” platforms arose, and built heavily over-engineered deployment solutions like “Enterprise Java Beans” and whatnot, but nobody at school actually learned them, so when they got into Industry they threw them out in favour of what they were comfortable with – often stuff that (like at school) they had either rolled for themselves (and therefore understood) or that they got from friends whom they trusted (and could therefore get community help)

Summary Learnings

There is no magic wand, no silver bullet; there is no language which will “fix everything”, and any candidate language for fixing even a chunk of the problem will have a limited shelf-life until the demographic which finds it sexy gets promoted to management and the newhires want to use something which they built themselves. Dick Gabriel was/is perennially correct that “Worse is Better” (there are several versions of that, check them all out) and any much-hyped new “win” will fade with time and human memory.

The only winning move is not to play a game of “this time, for sure!” and instead teach people how security works, ideally at school.

Hence: https://en.wikipedia.org/wiki/This_too_shall_pass

Postscript

The full version of Dick Gabriel’s essay is attached and is very much worth reading even if you do not speak Lisp; if you believe in memory safe languages as being impactful then you will be able to read between the lines regarding the development process:

https://www.dreamsongs.com/WIB.html

https://alecmuffett.com/article/109271

#history #security #worseIsBetter

@bitsavers @c_discussions To be fair, J&W Pascal was in fact inadequate for all the reasons BWK described. However, no one using Pascal to to Real Work used J&W Pascal. Everyone used extended versions, on micros especially UCSD Pascal and Turbo Pascal.
Unfortunately the ISO extensions were too little too late.
Ada had pretty much all of the good features of Pascal, but with the stuff needed for Real Work. Unfortunately it mostly failed, in favor of worse languages. #WorseIsBetter

Slack is such a local-optimum tool. Does that count as #worseisbetter?
"Why should we log that data, if we already slacked people?"
"We can discuss that complicated situation a flat thread in Slack."

From https://www.semianalysis.com/p/google-we-have-no-moat-and-neither, “Large models aren’t more capable in the long run if we can iterate faster on small models” reminds me a lot of #WorseIsBetter https://en.wikipedia.org/wiki/Worse_is_better #LLM #AI

@dekkzz76 I did & I loved it! However, early thi.ng projects (2011-2016) already made the "mistake" of using a socially unaccepted format (i.e. #OrgMode Literate Programming), which with very few exceptions basically stopped almost all 3rd party contributions, even though I still believe it was a superior format/solution for writing big projects...

Some example links in this comment:
https://www.reddit.com/r/emacs/comments/9w8i2g/comment/ec7xv5a/?context=3

A few years later I then bowed to pressure and converted one of the projects to a traditional source code setup, with the literate .org files remaining as archive/reference. Choosing Fossil would be an even more extreme barrier for adoption/contributions, esp. these days... sad, but true, but we live in a #WorseIsBetter world!

I'm thinking that whatever supplants #SAFe will have to be "worse" than it: https://jchyip.medium.com/worse-is-better-also-for-organisational-change-and-design-d1258f2da232 #WorseIsBetter

What comes first:

1) people stop using ANSI graphics in the output of commands so that all build logs are clean

2) #Github implements #ANSI terminal sequences in their markdown routines so that build logs are actually readable when sent to gist.github.com

#worseisbetter