One of the things I've heard a lot that bugged me when I saw discussions regarding Nim out in the wild are:
I think one of the reasons why these questions are often asked is that we fail to present Nim's uniqueness and strength in the fast growing space of new programming languages. This thread in particular is concerned about the landing page.
Currently our landing page reads:
Efficient, expressive, elegant
Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula.
Efficient
- Nim generates native dependency-free executables, not dependent on a virtual machine, which are small and allow easy redistribution.
- The Nim compiler and the generated executables support all major platforms like Windows, Linux, BSD and macOS.
- Nim's memory management is deterministic and customizable with destructors and move semantics, inspired by C++ and Rust. It is well-suited for embedded, hard-realtime systems.
- Modern concepts like zero-overhead iterators and compile-time evaluation of user-defined functions, in combination with the preference of value-based datatypes allocated on the stack, lead to extremely performant code.
- Support for various backends: it compiles to C, C++ or JavaScript so that Nim can be used for all backend and frontend needs.
Expressive
- Nim is self-contained: the compiler and the standard library are implemented in Nim.
- Nim has a powerful macro system which allows direct manipulation of the AST, offering nearly unlimited opportunities.
Elegant
- Macros cannot change Nim's syntax because there is no need for it — the syntax is flexible enough.
- Modern type system with local type inference, tuples, generics and sum types.
- Statements are grouped by indentation but can span multiple lines.
TL;DR:
This example attempts to reuse Nim's current EEE (efficient, expressive and elegant) telling approach. This approach might not be the best for describing Nim, but I think it worth a try.
A language with strong focus on being efficient, expressive and elegant.
Efficient:
- Flexible templates cuts away boilerplate with ease. Do more, with less.
- Powerful compile-time execution environment allows cutting away runtime costs by computing what you need before your program is run.
- Nim can compile to both efficient native code and Javascript, enabling Nim to powers both frontend and backend.
Expressive:
- Powerful macros bring a new meaning to extensibility. Make your own feature, be it a DSL for HTML, pattern matching or even a powerful multi-threaded runtime.
- Know what sort of types you're looking for? Tell Nim using concepts.
Elegant:
- Python-inspired syntax brings forth Python-like flexibility. *insert examples here*
- Clever defaults that brings safety and performance. *reference to Nim's parameter passing semantics, how let/var uses the same amount of keystrokes*
(I'll admit that writing is not my strong suit)
I'm curious about everyone thoughts regarding Nim's current landing page, my analysis, and whether there are further ideas on how it can be improved.
In my view The current landing page for the most part could describe any language. I'd add the following to Elegant:
Nim utilizes a Uniform Function Calling Syntax, which means whether the variable is an int, or a object you can call procedures as if they were member functions. Example: 10.float.pow 2
I also think that changing the "Expressive" to "Extensible" makes sense, as your change and the current site both indicate expandabillity and not exactly how the language is expressive.
Nim can bootstrap itself (why this is in "Expressive" is beyond me).
Translation: "The Nim compiler, library, and tools are written in Nim."
However, that's not a distinction.
Nim can bootstrap....
Translation: "The Nim compiler, library, and tools are written in Nim."
Exactly. The whole documentation would benefit from more 'translations' like this. It often feels like from language-developers for language-developers , which however misses the vast part of the readers, the language-appliers.
First, thank you for starting this thread.
Second, I agree with most of your points, but I don't have the time to write a better copy.
Third, I think one thing that would help a lot is language comparison. When you decide on whether to invest time in a language, you don't just evaluate its features, you compare it to other languages. Nim really shines in comparison, and it's a popular marketing feat to show a visual comparison if your product against its competitors.
I feel that the landing page and FAQ focus on what Nim is and its syntax and don't mention the language philosophy and long term goals.
Something like: "Nim is ambitious project. We value state-of-the-art, research-based design over easy compromises. We strive to reach for the speed of C, the readability of Python, the flexibly of Lisp and the safety of Rust. "
(I'm using "readability" and "flexibly" instead of "expressiveness" and "programmability" to make the punchline easier to read)
For the landing page we should keep it short, the long stuff can be put into the "Features" page for example.
Here's my attempt at simplifying the statement:
A language backed with state-of-the-art, research-based design and emphasizing on speed, readability, flexibility and safety.
This seems to be a good opening to have a discussion rolling for us to argue in favor of Nim. What do you think about it?
And I think we might also want to do away with Nim's current motto of "efficient, expressive and elegant". As it's hard to even capture some basic points on how we have been following that ideal, I don't think it's a good fit for describing the language. I don't have a better replacement for the catchy tunes of EEE though.
do away with Nim's current motto of "efficient, expressive and elegant".
I was never happy with that wording on the landing page. But it may survive on the "Features" page. Maybe?
Nim utilizes a Uniform Function Calling Syntax, which means whether the variable is an int, or a object you can call procedures as if they were member functions. Example: 10.float.pow 2
Although I've come to like UFCS, at first I was skeptical. "Some" people think that you should have one obvious way to write something. It's even a recommendation in the "Zen of Python" (seen with import this). Actually I like this rule, but I like the flexibility of UFCS more. :-)
My point is, depending on who reads the information about UFCS, they might consider it a dis advantage. So maybe this feature shouldn't be directly on the landing page.
Expressive:
...
Know what sort of types you're looking for? Tell Nim using concepts.
I don't think we should advertise a feature on the landing page that's marked as "experimental". :-)
I believe that mentioning strong support for functional programming (closures, higher-order functions, pure functions (with latest .strictFuncs. addition as well as sum types). Also I think nimscript should be mentioned too - for things like automation, scripting and embedding (sort of). I mean, how many statically-typed /intepreted/ languages with easy support for DSL are there? I don't know of any tbh. This is not main focus but should certainly be mentioned somewhere.
More on nimscript - when you start talking about 'statically typed, compiled language' you instantly trigger all rust/zig/c++/etc. people who start comparing fibonacchi benchmarks. But when you talk about 'statically typed language with strong DSL support, suitable for automation of anything etc' - that's much more interesting
I mean, this is the perfect replacement for YAML for example - instead of trying to squeeze things like looks etc in markup lanugage which was not made for it you can actually have full-blown language with DSL suited for your particular task.
This is just my opinion but there are several things - mainly (1) style-insensetivity, (2) writing 'js backend' and 'system programming' on one page, (3) mentioning 'system programming' and 'garbage collected' in one article - just make people assume things they don't really know anything about
I'm curious about everyone thoughts regarding Nim's current landing page, my analysis, and whether > there are further ideas on how it can be improved.
Thanks for this. I think you made a very good analysis and in the spirit of brainstorming here is my take on an alternative tagline and other miscellanous thoughts.
Looking at "How other emerging languages present themselves" they all provide a very appealing tagline that tries to express some of the characteristics of their language. I do like the EEE approach but is rather dry. It feels more like a list of guiding principles for language design and as such might attract people who are interested in programming languages per se. I feel like currently Nim should target more users that might want to use Nim to put in production stuff or people who want to help build the ecosystem.
We could try something different and what I have come up so far is: "A joyful programming language for anybody and anything". Why?