This post is really good which is describe in above but I have another issue
when I tried to install the latest version of Windows 10 it shows an error
[https://errorcode0x.com/resolve-epson-scanner-communication-error/](https://errorcode0x.com/resolve-epson-scanner-communication-error/),
so I
> On the other hand there were Java and Python frontends on the GCC, and where
> are they now? I think only Ada and Fortran frontends are really good GCC
> citizens along side with C/C++/ObjC.
The main Modula-2 developer said at a 2016 GCC development conference that the
developers' penchant
Yeah, honestly I don't see this helping D's popularity all that much. It
certainly doesn't hurt, but let's not panic or make it our goal to do the same.
The most impactful way to increase Nim's popularity is to _write about it_ and
_talk about it_ at conferences and with colleagues and friends.
Yes, but the DMD's fronend version in GCC 9.1 is like 8 versions behind the
current one, this is kinda bad. On the other hand there were Java and Python
frontends on the GCC, and where are they now? I think only Ada and Fortran
frontends are really good GCC citizens along side with C/C++/ObjC.
> I wonder if that will affect D's popularity...
What does "mainlined" mean?
Ada and Modula-2 have had GCC frontends for decades now, but they're still
basically invisible. One reason may be that they typically require you to
download and/or build a separate compiler. In Modula-2 you have to
Back on topic, [the big news in
Dland](https://www.phoronix.com/scan.php?page=news_item=GCC-9.1-Compiler-Released)
is:
"The D programming language front-end has finally been mainlined in GCC! There
is now D support beginning with GCC 9."
I wonder if that will affect D's popularity...
> It's may be a strange question, but what do you think about PureBasic ?
I don't think about PureBasic, because it's proprietary. I don't hate
proprietary software - I'm sure plenty of people find it useful - but I have no
use for it personally.
It seems like PureBasic had a _raison d 'être_
perhaps what you want is
[quote](https://nim-lang.github.io/Nim/macros.html#quote%2Ctyped%2Cstring) proc?
yeah, that's a current limitation. You should either use `ref` or
`FutureVar[T]`.
Thanks for implementing it! The only problem I ever had was how you can't bind
var parameters, since it assumes you might be resuming the future in a
different thread. object = await object.method(...) works for most of the time
I'd want to pass a var object though.
I mean a string composed of tokens. You can't do say parseExpr{a * x + b} which
in D just syntax highlights everything normal even inside the {}. parseExpr"a *
x + b" requires the editor to treat everything between "a * x + b" as untyped,
untokenized string characters.
It's really a very minor
If by token string you mean string mixins you can parseExpr"a * x + b" and
parseStmt"var a: int" if you want to do string-based macros.
> The languages are pretty close in all the other aspects though, and I run
> into async/await situations a lot. So, that's why I've been using Nim lately.
Yay! Awesome to hear something I've implemented is pushing people towards Nim.
Happy to help with any problems you run into btw, feel free
* _D_ \- concurrency uses kernel threads or longjmp, with little language
support for async semantics
* _Nim_ \- has await. Rewrites procedures to be async friendly. Futures that
don't rely on kernel threads.
That's basically the biggest factor in my mind for using Nim. Everything I can
Wow: rather curious analysis here. It's may be a strange question, but what do
_you_ think about **PureBasic** ?
Recently I found myself comparing with **Nim** : both converts their code to
different languages before native code, both have portable runtime, both
promote heavy macroengine
> why "Projects like Nim and D can never be failures"?
I've explained that point. At very least they brought value to the thousands of
programmers that used them, but that's just one aspect of their achievement.
D (since 2001) and Nim popularized the idea that a language can come close to
the
The overall part which may be going to get the part perfectly to handle it in
such part to enable it to
why "Projects like Nim and D can never be failures"? what is the common between
them? open source? what do you think about redlang
[https://www.red-lang.org](https://www.red-lang.org)/ which is said to promote
new idea of rebol language, however I think red lang is doomed to fail since it
Projects like Nim and D can never be failures. They've introduced or spread
many new ideas. Many of those ideas have already crosspolinated to other
languages. If some ideas don't spread, they were still a worthwhile experiment.
> Sorry, but same could be said about other languages that have better tooling
> and community support. With the important difference that those other
> languages will not blow up in your face due to the maintainers fiddling
> around with new features. As regards maintenance, with D I used to
Because open source is not really sustainable. People act too entitled.
Everyone is basically looking for a big banquet of all you can eat buffet but
someone else has to foot the bill. Of course Nim,D,Crystal cant do that. They
do not have the mega corporation paying top dollar for all the
People in the D community is actively discussing if D has failed:
[https://forum.dlang.org/thread/ylwktmssgntvoddub...@forum.dlang.org](https://forum.dlang.org/thread/ylwktmssgntvoddub...@forum.dlang.org)
It is kinda interesting and frustrating to see how big and old living project
being pushed
This post is really good but I have another issue when I tried to install
windows 10 latest version then my system shows an error
[https://errorcode0x.com/solved-dell-error-code-2000-0333/](https://errorcode0x.com/solved-dell-error-code-2000-0333/),
so I really want a proper solution how to
This post is really good but I have another issue when I tried to install
windows 10 latest version then my system shows an error
[https://errorcode0x.com/solved-dell-error-code-2000-0333/](https://errorcode0x.com/solved-dell-error-code-2000-0333/),
so I really want a proper solution how to
opudcyuh
ojiugdujhn
This post is really good but I have another issue which is related to my
printer when I connect my printer with wifi it shows an error
[https://itunessupport.org/blog/fix-error-54-itunes/](https://itunessupport.org/blog/fix-error-54-itunes/),
so I really want a proper solution on this error as
This will be going to manage it in such part where the user will liable to
proceed it with the
[https://netgears.support/blog/netgear-r6700-nighthawk-ac1750-review](https://netgears.support/blog/netgear-r6700-nighthawk-ac1750-review)/
so just follow the function.
I agree with some points but that
> The NIM project founder is sort of a one person show in development and
> promotion.
is plain wrong.
Not having a large organization like Mozilla behind it Nim can obviously not
compete with some "competitors" in terms of how many full time developers it
The NIM project founder is sort of a one person show in development and
promotion. I wouldn't say it is not ready for real (commercial) use without
being objective, as you have to really characterize what those requirements
are. If one considers commercial criteria to be something like:
The process where it will be going to provide the perfection for the user to
proceed it. So this will be taking guided by the
https://epsonsupports.net/blog/epson-printer-not-printing/;>epson](https://epsonsupports.net/blog/epson-printer-not-printing/;>epson)
printer not printingfor finding the
The process where it will be going to provide the perfection for the user to
proceed it. So this will be taking guided by the
https://epsonsupports.net/blog/epson-printer-not-printing/;>epson](https://epsonsupports.net/blog/epson-printer-not-printing/;>epson)
printer not printingfor finding the
Let me help you out. I'll emphasize the relevant word to make it easier for you.
> I can let other opinions stand and have no need to "facepalm" or similar to
> otherwise belittle or attack **anyone** here
Maybe, just maybe one might take my opinion re. D as "attack" or belittling IFF
I had it
So? You have your opinion and I have mine - and as you saw (with my no further
discussing with someone else) I _can_ let other opinions stand and have no need
to "facepalm" or similar to otherwise belittle or attack anyone here. In fact I
assume the differences in our views largely stem from
I was hoping for a more adult analysis of [Alexandrescu's introspection
talks](https://www.youtube.com/results?search_query=Alexandrescu+Introspection)
and Nim vs D...
> FWIW I had a look at D multiple times and learned to fervently dislike it. My
> personal summary is that D is b
> Well noted, I could provide more detail (and I did for Nim which is worth it)
> but I don't for D.
No you didn't develop for Nim as well.
> With all due respect I'm not interested in your list. Those things are
> technicalities. A good language, however, needs deeper insights (I'd even say
Hmm, I see. A classical political correctness and Über-Ich argument ...
Well, no. I clearly said "personal summary" and I have no obligation to meet
any arbitrary conditions like e.g. "examples!" Well noted, I _could_ provide
more detail (and I did for Nim which is _worth it_ ) but I don't for
There's no need for disparaging other languages, especially without examples to
give more substance to your claims.
I do feel like in terms of design goals and at a high level, D is the closest
cousin of Nim.
* statically compiled
* strong meta-programming and CTFE
* C and C++ FFI
*
FWIW I had a look at D multiple times and learned to fervently dislike it. My
personal summary is that D is but yet another better C/C++ attempt with funny
gadgets added and an utter lack of consistence in concept and design.
To even put Nim and D next to each other is ridiculous.
" **I believe we are the language with the best static introspection in the
world** " — [AA](https://en.wikipedia.org/wiki/Andrei_Alexandrescu) @ [Dconf
2018 in Munich](http://dconf.org/2018/index.html), three minutes into "[Ask Us
I've created a git repo to compare D vs nim, with the goal of having an up to
date comparison of features between D and nim and 1:1 map of features and
libraries to help D users learn nim and vice versa. Better as a git repo than a
forum to have all info organized in 1 place.
PR's are welcome
I like D quite a bit, and there's clearly been some convergent evolution (UFCS)
with Nim. The D story with respect to memory management is still unfolding. As
was already said, I think the language could have been designed to make GC
easier, perhaps separating **ref** and **ptr** like Nim. Then
This recursion unpacking/unrolling trick that gcc does (at call-site if
insulated by call via volatile function ptr, and always inside the recursive
impl) is, in my experience, a rare compiler optimization, but maybe it will
catch on. clang does _neither_. If you `objdump -D` the executable (or
I am using mingw64/clang64 in Msys2. But I found that the exe file build by
clang runs very slower than exe by gcc.
The nim is a fresh build from github source yesterday
$ nim
Nim Compiler Version 0.17.1 (2017-07-07) [Windows: amd64]
Copyright (c) 2006-2017 by Andreas
I get the same perfect line with the Nim fib(47..57) as well. { Well, slightly
slower: log_1.618(wall) =~ N - 47.35. So, 1.618**(47.67-47.35) = 1.16 or around
16% slower. }
@cblale I was actually talking about the Nim fib(55)
@aedt - with that C program I posted and just changing the numbers, I see no
change in behavior at all:
N fib(N) log_2(Fib(N)) WallTimeUsrCPU log_1.618(Tm)
57 365435256832 38.410825 88.338572 88.29 9.31268150798
56 225851408384 37.716583 54.570624
I think the difference is in the details, but the details matter. I would
really be interested to get some experience from people who actually had
projects in both languages. Because then you get to know about differences that
actually matter.
A tiny feature of the Nim language, the dot call
The [recent blog
post](https://nim-lang.org/blog/2017/05/25/faster-command-line-tools-in-nim.html)
I wrot eon the Nim blog also explored performance and build times in D/Nim
based upon a blog post on the D site.
In it you can see that D and Nim achieve similar speeds in that particular
Oh, sure. There isn't _usually_ a 1.618**4 kind of work reduction in play,
though. Araq would know, but I doubt the reason NimMainInnner is called
through a volatile function pointer is to trick gcc's optimizer, though that is
a happy side effect.
To me, this was just a performance mystery
@cblake
Also I have noticed that if you do a fib(55) the time increases significantly.
This is probably because of integer precision choices, but I may be wrong.
@Araq
I agree. The generated C codes always add a great deal of tedious optimizations
that users will tend to forget about.
The produced C code by Nim tends to optimize well in general though.
In case anyone else is curious about aedt's fibonacci benchmarks, I found an
explanation for the approx 6..8X time difference of C vs Nim (with gcc as a
backend, on Linux). It took digging into assembly to figure it out, though.
With the Nim version, the nested calls/various module boilerplate
For me the killer feature is readability: no bracket, no semicolon.
Also when reading other's Nim code, most of the code I see is really clean and
in short self-contained functions.
**gokr:** _I don't know D, but I am quite sure that Nim beats D on these three
specific meta programming aspects (just looked them up quickly)._
This is arguable. While Nim's AST manipulations are generally more powerful,
the "string mixin hacks" are often plenty sufficient to get the job done
D may be more "complete" as it is older.
Nim has compile time function execution and Mixins, but D's Mixins may be
different, I don't know. Static ifs -- maybe that is what Nims when expression
is. From the current version of the book it may be not possible to learn all
the advanced stuff of
@ yglukhov
While you make good points, I would argue that D feels more ... ... "complete".
Don't get me wrong, I like Nim. However D is self hosted, and it has nice
features like CTFE, static ifs and Mixins etc. I'm currently reading through
the Nim book so I don't quite know if Nim has these.
I've used to use D a while ago, but here are the things that made me switch and
i'm not going back.
* Nim is magnitudes of orders easier to contribute to. Not only the compiler
code is easier to reason about (at least for me), but PRs are accepted a lot
more willingly. I bet such openness of
> Without main function: 5.004 s With main function: 3.126 s
That is really some magic which we should investigate, document and remember.
> and using an explicit main function:
Really?
I would be (again) very surprised, as fibonacci() was already a standalone
proc, and all execution takes place inside this function. I can not imagine
that the symbol "main" does any magic, and that echo is faster inside main
should be not really
I don't understand why the other languages are slower, but you can make the Nim
version faster by using smaller types (same as your other languages) and using
an explicit main function:
proc fibonacci(n: int32): float32 =
if n < 2:
result = float32(n)
else:
@aedt Your numbers are vastly off what other people report. Something has to be
wrong with your way of measuring things.
This is very interesting. I am a big fan of D, and I use D as my to-go
language. I like Nim too. But how come the difference between D, C++ and Nim be
so big? This is impressive and it's a little bit too good to be true! In my
machine,
//D
import std.conv, std.stdio;
64 matches
Mail list logo
