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.

Every time I see the X11 protocol, I realize that the UNIX philosophy (everything is a file) is dead.

As "dead" as Android (which is based on Linux, a Unix clone) and OSX (a BSD Unix) and iOS (child of OSX)? Why does Microsoft vibrantly support Linux in Windows 10 (an abomination to Ex-CEO Steve Ballmer) if Unix is "dead"?

I think the very opposite is true. Some developers realized that the KISS principle (including the Unix philosophy where everything is a stream of bytes) is not a bad idea after all.

https://blog.pragmaticengineer.com/software-architecture-is-...

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.

very few change their life in significant ways to help it.

I did it, and it is really worth the effort.

What I changed:

- buy liquids in glass only -> healthier and reduced container garbage to 2/5

- use soda stream for mineral water

- buy fresh food -> healthier and reduces plastics packing

- buy used devices (where it makes sense) -> cars, phones, pc's etc. -> much cheaper, reduces waste -> don't be beta tester for newest products

- use rechargable batteries with smart recharger (to benefit the life cycle)

- avoid unfixable devices in general

- use grandma's household remedy, e.g. baking powder and vinegar instead of chemicals (packed in big one-way plastic bottles) to clean your house drains

There are many more tips in the Internet. For instance:

7 Ways to Support the Environment in 2018

https://www.care2.com/greenliving/7-ways-to-support-the-envi...

Further recommendations are appreciated.

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.

Companies using OCaml: https://ocaml.org/learn/companies.html

What is OCaml used for? https://www.quora.com/What-is-OCaml-used-for?share=1

Further infos:

awesome-ocaml - A curated collection of awesome OCaml tools, frameworks, libraries and articles: https://github.com/ocaml-community/awesome-ocaml

OCamlPro Research and Development: https://www.ocamlpro.com/research-and-development/

OCaml Weekly News (RSS): http://alan.petitepomme.net/cwn/cwn.rss

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.

I like to share the following links to those who also don't like systemd.

http://without-systemd.org

Devuan (Debian without systemd):

http://devuan.org

More Linux Distros without systemd:

http://without-systemd.org/wiki/index.php/Linux_distribution...

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.

The people at https://discuss.ocaml.org/ are quite helpful.

it's cool from a language point of view, but as a developer it can get overwhelming

If you consider OCaml's features overwhelming why don't you consider a much simpler language (Typescript etc.)?

I am learning OCaml myself right now, and I only use the features which I currently need. If I need more I will learn OCaml's suitable features then. Btw. I like OCaml, after having tested Haskell for a while. OCaml feels like a really practical usable "Haskell light". The compilation speed is outstanding (like LuaJiT).

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.

Why do you abhor elitism? It's elitism (not group thinking) which yields progress. For instance, da Vinci, Newton, Einstein, etc. and all the Nobel price winners were all outstanding elitists.

If something is truly worth it, it should be accessible to the "masses"

OCaml is accessible to the masses, for 10-20 years already.

I doubt that the masses will switch to FP languages (OCaml, Haskell, Lisp, ...) ever since the classical lightweight languages (Javascript, PHP, ...) provide anything they need for their basic stuff. Only few need more, and they have free choice of several nice niche languages which don't need to become mainstream.

I have also worked with CL commercially in this century, and the only thing I missed was a convenient portable GUI library for OSS Lisp. I hope in McCLIM (https://common-lisp.net/project/mcclim/1.html).

You can find a library for anything these days

http://quickdocs.org/

https://www.quicklisp.org/beta/

Kudos to the new Common-Lisp.net!

I would like to recommend to add links to websites like planet.lisp.org to make common-lisp.net look active on a regular basis. Another interesting style is used by haskellnews.org/grouped.

Wow, thanks for sharing!

Looks impressive. However, since Nim has such an easy C/C++ FFI you have to consider also all C and C++ APIs. That looks superior even to Go, unless Go's C FFI is as easy as Nim's.

https://github.com/kozross/awesome-c

https://github.com/aleksandar-todorovic/awesome-c

https://cpp.libhunt.com/

https://github.com/fffaraz/awesome-cpp

However, the ecosystems are not at all comparable.

Really?

https://github.com/VPashkov/awesome-nim

You can install Nim packages easily with nimble.

https://github.com/nim-lang/nimble

Why give up on performance?

We don't need to give up on performance, even with low-performance RISC-V chips. What we need is a new architecture which takes advantage of low-speed multicore processors. If it is possible to produce thousand-core RISC-V chips [1] then any core could be assigned a single thread - which implies that there is no need for a complex multitasking OS.

[1] Towards Thousand-Core RISC-V Shared Memory Systems (PDF)

https://riscv.org/wp-content/uploads/2016/11/Wed1000-Thousan...

After all, what use is a nuanced term if it can't reliably convey that additional information.

I would recommend the general term "A/B compiler" where A and B are arbitrary regular languages. That way it would be pretty clear what a Pascal/C compiler is, or a JVM/Webasm compiler, for instance. Or a x86/C compiler which would also make the word "decompiler" obsolete.

is it so bad to have another word for source-to-source compilation?

If you compile C to Assembler then you compile from one code (C) to another code (Asm, or machine code which is the compact form of Asm). What's the difference to a "transpiler"?

Wikipedia states that the difference is just the (almost) equal level of abstraction. I would call such a thing a high-level source-to-source compiler. The word "transpiler" is uncertain and barely known, hence the people here who ask what a transpiler is.

Cross-compilation is another thing since it means compiling on one platform for another platform. In all three cases we deal with compilers from one regular language A into another regular language B.

"Transpile" is an artificial buzzword, just meaning source-to-source translation, from Pascal to C for instance.

Actually, there is no such thing as a "transpiler". There are only compilers which are programs which translate from one regular language A into another regular language B. It doesn't matter whether B is a high-level language or low-level machine code.

... and run it in a serverless environment, a docker container or a browser.

... Waiting for tens of seconds, or minutes, until all the JS libs are loaded into their GB's of RAM by their GHz multicore processors while those old veterans compiled all their stuff within a second on their ancient Turbo Pascal on their ancient MHz CPU's with barely noticable 64K RAM :-)

Also John McCarthy the inventor of Lisp should be mentioned. Since 50 years Lisp provides features which are still copied by modern languages.

https://en.wikipedia.org/wiki/Lisp_(programming_language)

According to the Namcook Analysis all the IT world should switch to Excel since it is placed 13 places ahead of Smalltalk. And according to my personal experience Lisp is not that unproductive. And other business languages like OCaml are not even mentioned.

Rank 1/Asm 6/C 26/Lisp 65/Smalltalk 78/Excel

Post like that brings me back to earth every time I dream of running Linux only.

It's not a Linux problem, it's a Windows emulation problem in Wine.

As for Linux, I'm using it for 25+ years, and I ditched Windows 10+ years ago. Windows is not necessary to do stuff. However, if you vitally depend on CS5 then running CS5 in emulation is not the best idea. At least you can use it properly in a PC emulator like VMware in Linux.

Lisp is the secret power tool of developers who really understand computing.

Emacs, one of the most reliable software ever was written in a language with no typechecking -- in Lisp! Emacs never crashes although it is configurable by the user in almost any way -- also in Lisp.