DOS ain't dead

Many months ago, I had the idea to post about various coding philosophies, hoping to somehow sort in my own head various good ideas that are worth remembering.

These few should get you started. If you have any further links to similar ideas, feel free to suggest them here.

(from Wikipedia):
* Minimalism
* Code refactoring
* KISS principle
* UNIX philosophy

I'd like to add Clean code (or in German Wikipedia: Clean Code -- There's no English article so far.)

---
Forum admin

Returning to use GNU Pascal (DJGPP) again reminds me of their own GNU Pascal Coding Standards (German, Croatian, Spanish). A lot of good ideas there, too.

* The Ten Commandments for C Programmers (Annotated Edition)
* ISO/IEC 9126 Software engineering -- Product quality (1991)

* Your Coding Philosophies are Irrelevant
* Programming Modern Systems Like It Was 1984
* Suckless Software Philosophy
* Write Small and Fast Software
* The Duct Tape Programmer
* the djb way
* Rob Pike's 5 Rules of Programming

* Coding best practices
* Redundancy (engineering)
* Software reliability testing
* SPARK (programming language)

* three great virtues of a programmer: laziness, impatience, and hubris
* perlport (portability tips)
* perldos (DOS port tips)

An Ethos for Sustainable Computing (Alexander Nicholi).

---
https://codeberg.org/tkchia · https://disroot.org/tkchia · 😴 "MOV AX,0D500H+CMOS_REG_D+NMI"

* Software Crisis
* Dependency Hell
* Bootstrapping (compilers)

* Epigrams In Programming

* Software prototyping
* You Aren't Gonna Need It (YAGNI)
* Plan to throw one away
* Project Management Triangle (aka, "Choose Two: Good, Fast, Cheap")

Maybe the question isn't "what philosophy?" but "which philosopher?"

* Turing Award (list of winners, 1966-2020)

New word in licensing process.

PS: About "Why?" section: reasons, for me, don't looks like a stupid joke, in modern time. Yes, purposed word is, definitely, worth.

---
Make DOS great again!
Make Russia small again!

> PS: About "Why?" section: reasons, for me, don't looks like a stupid joke,
> in modern time. Yes, purposed word is, definitely, worth.

Clearly someone decided to ask themselves questions like, "How do I protect vulnerable people against physical abuse?", or just, "How do I create quality software that has few bugs?" And after asking these questions, they came up with ... that above idea. Well, OK.

---
https://codeberg.org/tkchia · https://disroot.org/tkchia · 😴 "MOV AX,0D500H+CMOS_REG_D+NMI"

On more mundane matters: should one write const int, or int const, in C++ code? What if the code is not C++, but C?

---
https://codeberg.org/tkchia · https://disroot.org/tkchia · 😴 "MOV AX,0D500H+CMOS_REG_D+NMI"

How To Write Unmaintainable Code

---
Forum admin

How to be a Programmer: Community Version

---
Forum admin

The Most Important Skill a Programmer Can Learn

---
Forum admin

Something about coding and designing for the web that also relates to traditional coding in several ways:
* Plain old webpages still matter
* Notes on the small web
* Just another website
* The small web is beautiful
* Guidelines for Brutalist Web Design

Or are we just getting old?

---
Forum admin

DOS: Choosing a Memory Model by Bill Mayne (C News Vol. 1, Issue 11, 15 Sep 1988)

> DOS:
> Choosing a Memory Model by Bill Mayne (C News Vol. 1, Issue 11, 15
> Sep 1988)

while this is mostly correct from a 1988 perspective, compiler technology has seriously advanced since 1988, even for 16 bit compilers.

while it is easier (for dummies) to simply use simply compact and large memory models, selecting small or medium model and access the (hopefully) few large data structures using the __far keyword and the rest just __near produces usually much better (smaller and faster) code.

so the information above is mostly outdated.

* Choosing a Memory Model (Digital Mars)
* Our bloat problem (LWN.net, 2005)
* Software disenchantment

(PDF) A plea for lean software by Niklaus Wirth (1995)

---
Forum admin

The Lost Art of Structure Packing (Eric S. Raymond)

---
Forum admin

> * UNIX philosophy

I didn't notice that Eric Raymond's The Art of UNIX Programming book (2003) was freely available online. It has TONS of philosophical and practical advice. It's less about UNIX-only code and more about the history, why things were done, the good ideas, the elegance.

Seven habits of effective text editing (Bram Moolenaar)

* The UNIX-HATERS Handbook

Here's my blog's #idioms tag:

* mov fast and mak things
* Debugging is the act of removing errors from a program. Programming is the act of putting them in.
* The master has failed more times than the beginner has even tried.
* Good, Fast, Cheap. Pick two.
* On two occasions I have been asked, — "Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?" In one case a member of the Upper, and in the other a member of the Lower, House put this question. I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.
* Hitting the table hurts the fist more than the table.

---
l

* Feature creep
* Don't repeat yourself

> Many months ago, I had the idea to post about various coding philosophies,
> hoping to somehow sort in my own head various good ideas that are worth
> remembering.
>
> These few should get you started. If you have any further links to similar
> ideas, feel free to suggest them here.
>

The one I have always held close is:

Eschew Obfuscation!

Bob

* Compiler Deadly Sins
* Modular Programming
* Halstead Software Complexity Measures
* Code Smell

Top-down and bottom-up design

At about the time Logo was developed, an ideology of top-down programming as the only "allowed" technique became popular among adult computer scientists: design first, top-down; only then, start coding. Logo's programming style was and is proudly antithetical to such disciplines [Harvey 1991]. Sherry Turkle and Seymour Papert introduced the use of the French word bricolage (tinkering) to label the Logo style of work, in which children experiment freely until they obtain a result that seems worth preserving as a procedure [Turkle and Papert 1990].

[Harvey 1991]
https://people.eecs.berkeley.edu/~bh/bridge.html

[Turkle and Papert 1990]
Sherry Turkle and Seymour Papert. 1990. Epistemological Pluralism: Styles and Voices within the Computer Culture. Signs:
Journal of Women in Culture and Society 16, 1 (1990), 128-157.

From: https://dl.acm.org/doi/10.1145/3386329


My high school teacher taught me top-down programming style, while my father taught me bottom-up programming style.

Here is a few projects which represent “something going wrong” in modern software.

---
Make DOS great again!
Make Russia small again!

> Here is a few
> projects which represent “something going wrong” in modern
> software.

What's wrong?

---
Forum admin

> Maybe the question isn't "what philosophy?" but "which philosopher?"

* Andrew S. Tanenbaum receives ACM Software System Award (2023)
* https://en.wikipedia.org/wiki/ACM_Software_System_Award
* https://en.wikiquote.org/wiki/Andrew_S._Tanenbaum

Nobody Gets Promoted for Simplicity by Matheus Lima

---
Forum admin

> Here's
> my
> blog's #idioms tag:

Updates since the prior post:

* Scientists believe no experiment is a failure; that even a mistake advances the evolution of understanding.
* they use a heuristic (an easily calculated) procedure
* his “portable definition”, a game is “the voluntary attempt to overcome unnecessary obstacles”.
* if you garden as a hobby, you only have to garden the ways you like and the amount you find enriching
* Sorry to write you such a long letter; if I had more time I'd have written a short one.
* If you wish to make an apple pie from scratch, you must first invent the universe.
* There’s the old quote "I don’t like writing, I like having written."
* It has been said that smart people learn from their mistakes, but wise people learn from other people's mistakes.

---
l

And another bit from my blog:

> What is a debugger and how can it help me diagnose problems?
>
> A debugger is a program that can examine the state of your program while your program is running. The technical means it uses for doing this are not necessary for understanding the basics of using a debugger. You can use a debugger to halt the execution of your program when it reaches a particular place in your code, and then examine the values of the variables in the program. You can use a debugger to run your program very slowly, one line of code at a time (called single stepping), while you examine the values of its variables.

---
l

> And
> another
> bit from my blog:
>
> > What is a debugger and how can it help me diagnose problems?
> >
> > A debugger is a program that can examine the state of your program while
> your program is running. The technical means it uses for doing this are not
> necessary for understanding the basics of using a debugger. You can use a
> debugger to halt the execution of your program when it reaches a particular
> place in your code, and then examine the values of the variables in the
> program. You can use a debugger to run your program very slowly, one line
> of code at a time (called single stepping), while you examine the values of
> its variables.

And using a debugger is some kind philosophy or what?

---
Forum admin

> And using a debugger is some kind philosophy or what?

Yes =v

---
l

Joe's Blog — 2014-06-25 Minimal Viable Programs

(…)

The Erlang ticket system was designed and implemented by Peter Högfeldt in 1986. We needed a ticket system that was easy to use, intuitive, reliable and we wanted it yesterday, so Peter got the job, since he was very busy and didn't have time to take on any new jobs.

If you want a job done find the busiest person you know and give them an extra job. This is because the reason they are busy is that lot's of people want them to do things because they are good at doing things and that's why they are busy.

(…)

New features mean new sales opportunities, good for the company but not good for the user.

New features mean new untested code, and backwards incompatibility with earlier versions of the program. Things that are stable for a long time are good.

(…)

If we to have any control over complexity then we should ensure that the basic components are MVPs.

(…)

---
Forum admin