progman

The wayland project exposes what marvelous piece of software X11 really is since Wayland is still not able to compete, otherwise the whole Linux community would use it already.

I respect the intention and efforts of the Wayland community to make things better. However, I wished the community would have focused on making X11 better (easier to maintain with modularity etc.) instead of following the mainstream which is focused on eye candy and other sensual features to attract customers.

The unfortunate developments of KDE3/4, Gnome2/3 and Win7/8 exposed that boring usable functionality is much more important than exciting sensual functionality.

Bash is a typical Unix tool, and Unix follows the KISS principle. Hence, also Bash scripts should be KISS.

If you need >100 lines of code your code is too complex in the script world, and you should split it into several scripts where each does one thing, and that one thing well. Usually, bash scripts are applied with pipes. A sequence like cat x | tr a b | sort >output is much more likely and easy to handle then a single script which does all these things.

KISS with Bash is a very different approach compared to other scripting languages like Python and Perl. There you can write long code easily and conveniently. However, things can get tough when larger scripts need to be maintained.

I consider the examples in the "Bash Bible" a collection of useful black boxes. It's fine if they just work. Regarding the "unreadable" trim_string for instance, if you have problems to understand that code, and you have to change something then you can simply write your own new trim_string script, even in Python or Perl if you like. Pipes work also well with them.

Update: Another advantage of bash and pipes over Python/Perl is that the Unix system can assign each script in a pipe to a separate thread. That means, simple bash scripts with pipes can work _much_ faster than single scripts in Python or Perl.

The irony is that the very attempt to be one tool for everything caused Perl's own destruction. Perl 5 is still used by some veterans for small scripts but who wants to use Perl 6?

Unix follows the KISS principle, and that is key for success. Albert Einstein said: "Keep things as simple as possible but not too simple". In that sense Unix and Posix are well done. However, that doesn't mean that good ideas like Nushell are not welcome.

Yes, there are also poor languages with many users :-)

> This is OCaml's problem: it's a great language with no users.

My other post in this thread proves the opposite.

Nice work! Lem looks "Spartan" at first glimpse, the high expansibility however is a promising key for success. Anyone who truly loves Common Lisp has the opportunity to make Lem the best Lisp editor ever.

I am a long-term Emacs user but I think we really need an optional editor which can be extended in Common Lisp rather than Emacs Lisp. What I really like about Lem is the KISS principle ("Keep it simple, stupid") since Lem is based on curses which is good for portability.

I have no experience with Roswell. Is it possible to use QuickLisp packages? Or do you consider to switch from Roswell to quicklisp? That would make installation of Lem much easier!

Basically said, systemd follows quite the opposite of the KISS principle which made Unix and Linux so great.

> We're here because of mass progress

What is "mass progress"? There are two options: a) let the masses learn to use the inventions of individualists (which happened with C/C++, PHP and Python for instance), or b) let the inventions be customized to the mediocre capabilities of the masses.

You want option b), obviously. I wouldn't call that "progress".

Rust may be a very good choice for systems programming. However, safety criticial software can also be written in other languages which don't need a borrow checker -- Ada and SPARK for instance, or even in C with verificatino tools (FramaC etc.). Most developers also don't need Rust's "feature" of not having a garbage collector since they are not involved in systems programming. As for me, what makes OCaml attractive is its functional nature combined with a very practical imperative syntax. There is no steep learning curve like in Rust, and OCaml's compilation speed is staggering.

If you want to teach FP you should use the very first and most simple FP languages --- Lisp and Scheme. Despite their extreme simplicity, they provide an extremely expressive power (through their macros) which is still unmatched in most other languages.