A Quick Comparison of Nim vs. Rust • Hacker News Board

Re: A Quick Comparison of Nim vs. Rust

#91

Post by Dylan16807 » Wed, Jan 14, 2015, 7:40 PM UTC

dom96 wrote: post #89

duaneb wrote: post #84

Earlier quoted context omitted.

> In what situation would a code base use fooBar and foo_bar as two different identifiers meaning two completely different things? You don't. It's a terrible idea to mix naming conventions. > amyAtePizza has the same meaning as amy_ate_pizza. WHY?! What possible benefit could it have? Why would you be mixing styles in the first case? Why can't you just remember which style hopefully your entire code base uses?

I wouldn't mix styles inside my own code base. But what if I am using somebody else's library which uses a different style? The benefit is that I can then use the style I have been using in my code base to call the functions in that library without mixing naming conventions.

I hope you never move code between different code bases, then.

Wouldn't it be a lot simpler to have a single style?

Re: A Quick Comparison of Nim vs. Rust

#92

Post by burntsushi » Thu, Jan 15, 2015, 1:24 PM UTC

pcwalton wrote: post #70

The first benchmark is primarily a comparison of Nim's PEG package to Rust's libregex package. The two have very different algorithms, and libregex is optimized to avoid exponential blowup on pathological regexes. It's missing a fallback to the backtracking algorithm at present. Using rust-pcre would probably mitigate this problem.

I was still pretty surprised that `regex` was getting killed. It turns out, I think, that `\w+` in Rust is Unicode friendly, but it's not in Nim. In cases where most matches fail, checking the full spectrum of Unicode "word" characters becomes pretty expensive (although it is at least doing a binary search on contiguous ranges of characters: https://github.com/rust-lang/regex/blob/master/src/vm.rs#L23...). When I switched `\w+` to `[a-zA-Z0-9_]+` in the Rust program, I saw a ~60% performance increase.

> and libregex is optimized to avoid exponential blowup on pathological regexes. It's missing a fallback to the backtracking algorithm at present.

Maybe. RE2/C++ doesn't do any backtracking AFAIK, but it appears near the top of any benchmark I think.

Re: A Quick Comparison of Nim vs. Rust

#93

Post by arthurtw » Thu, Jan 15, 2015, 6:38 PM UTC

burntsushi wrote: post #92

pcwalton wrote: post #70

The first benchmark is primarily a comparison of Nim's PEG package to Rust's libregex package. The two have very different algorithms, and libregex is optimized to avoid exponential blowup on pathological regexes. It's missing a fallback to the backtracking algorithm at present. Using rust-pcre would probably mitigate this problem.

I was still pretty surprised that `regex` was getting killed. It turns out, I think, that `\w+` in Rust is Unicode friendly, but it's not in Nim. In cases where most matches fail, checking the full spectrum of Unicode "word" characters becomes pretty expensive (although it is at least doing a binary search on contiguous ranges of characters: https://github.com/rust-lang/regex/blob/master/src/vm.rs#L23... ). When I sw…

Bingo. With `regex!(r"[a-zA-Z0-9_]+")`, Rust finally runs faster than Nim. I’ve updated the article.

Re: A Quick Comparison of Nim vs. Rust

#94

Post by mmfZ4e4OqQ7RRwP » Tue, Jan 20, 2015, 1:01 AM UTC

Dylan16807 wrote: post #90

dom96 wrote: post #82

Earlier quoted context omitted.

I don't understand why you think it makes code hard to read. In what situation would a code base use fooBar and foo_bar as two different identifiers meaning two completely different things? The idea behind this "style insensitivity" is that amyAtePizza has the same meaning as amy_ate_pizza. Why should it be distinguished in a programming language?

You don't understand how having multiple highly-different forms for each name is harder to read? People read a token at a time whenever possible. Nobody is arguing that you should be able to use multiple forms for different variables. They're arguing that you shouldn't use multiple forms at all .

When I present myself to people I use one form of my name. Some people I know use nicks. Others use part of my formal name. Due to me being a foreigner, essentially everybody I know uses a slightly different way to name me or pronounce the same name. However, there is consistency. Each person will use the same form for naming me.

This happens with Nim code too. Each programmer will have their convention, and will use it consistently. If you have a team, you establish a convention for the project: you need that anyway because people creating new stuff need a consistent way of naming things and you don't want to later rename everything after a heated discussion. So if you can't keep people on your team from using a project convention, you have a bigger problem than slightly different identifiers in a programming language.

Also, once you start using the different free naming conventions in Nim you grow inmune to them looking ugly. Just like when you know only one programming language everything else looks alien, but when you learn something else you expand your horizon and it stops looking so alien, and it stops being "harder to read". I jump from one convention to another without problem for each project as needed, and doesn't even bother me at all.

tl;dr it's not a big deal, don't let that stop you from learning a very nice language, you could regret it later