warp

But dlang has a long problem of change constantly without backward compatibility and a lot of projects just die because of it, for example the mentioned https://github.com/facebookarchive/warp : ==== make dmd -c -O -inline -release -ofwarp.o cmdline.d constexpr.d context.d directive.d expanded.d file.d id.d lexer.d loc.d macros.d main.d number.d outdeps.d ranges.d skip.d sources.d stringlit.d textbuf.d charclass.d context.d(222): Error: Implicit string concatenation is error-prone and disallowed in D context.d(222): Use the explicit syntax instead (concatenating literals is @nogc): "# 1 \"%2$s//\"\x0a" ~ "# 1 \"<command-line>\"\x0a" context.d(223): Error: Implicit string concatenation is error-prone and disallowed in D context.d(223): Use the explicit syntax instead (concatenating literals is @nogc): "# 1 \"<command-line>\"\

Context: Walter Bright created the first native C++ compiler, Zortech C++. This pull request actually implements its own C compiler! For Walter, considering he's implemented C++98 alone, implementing C must be nothing :) He implemented the ANSI C compiler here in just 5 days. Semi-related project, using libclang to import C++ directly (with C++ templates and all the other features, regular D has C++ linking and exception support built-in): https://github.com/Syniurge/Calypso Some quotes from the forum https://forum.dlang.org/post/s7a37h$2bbv$1@digitalmars.com : - Writing a C preprocessor is a nightmare. Fortunately, I already did that https://github.com/facebookarchive/warp and we can use it if we choose. - The D code will be able to inline C code, and even CTFE it. - There are a lot of wacky C extensions out there. We only need to implem

Here's the source code: https://github.com/facebookarchive/warp and the one for the C compiler I wrote long ago: https://github.com/DigitalMars/Compiler/blob/master/dm/src/d... which is integrated with the C lexer for speed reasons.

My experience, which of course is anecdotal, is that the advantage is it's easy to change the algorithms and data structures. I've maintained C and C++ code bases for decades, and I've found that the first algorithm I tried has stayed there in the code. It gets tweaked, optimized, refactored, but it's the same algorithm and data structure. With D, when I developed the Warp preprocessor, https://github.com/facebookarchive/warp I continually tried different algorithms & data structures to see which was faster. One reason it's easier is that in C/C++ the . is used for value field access, while -> for pointer field access. In D, . is used for both. So you can easily switch between a value and a pointer to the value by changing little code.

I don't really have any scathingly brilliant goals for the D version, other than inspiring others to make use of it. I still maintain it, it'll be much easier to maintain in D, and not much work to convert it to DasBetterC. Yes, it was Warp: https://github.com/facebookarchive/warp https://code.facebook.com/posts/476987592402291/under-the-ho... You're welcome! It's reactions like yours that make it worthwhile.

Lexing and parsing are the simplest, by far, parts of a compiler. (That's why it is possible for Flex & Bison to exist.) 99% of the time spent writing a compiler will be elsewhere. If you want a correct to the last drop C preprocessor, prepare to spend 6 months on that, minimum. Or just use Warp: https://github.com/facebookarchive/warp and then you can have fun just working on the compiler bit.

> Does D have a thing? Probably its most useful feature is rather subtle. It's very easy to express diverse ideas in code in D without having to resort to contortions. It's something people realize after having worked with D for a while. It is not the result of having feature X (you can always find feature X in other languages or a way to make X work), it's the combination of various X's. For example, some algorithms express naturally in a functional manner, some imperative, some OOP, etc. It isn't necessary to buy into a manner for the whole program, just use the manner that fits the particular part of the program. You might like to use FP here and there, but don't want to deal with monads. You can use OOP for the AST, but don't want to box integers into an OOP class. You like dynamic typing for one type, but it's a bad fit for another.

They wrote a C/C++ preprocessor in D, but this now appears to be abandoned. https://github.com/facebookarchive/warp

Warp [0], which was a huge marketing win for DLang is not maintained anymore. Not sure if it is being used at all. Will there be any D projects in Facebook? [0] https://github.com/facebookarchive/warp

Excellent work, perseverance proves! D is a very good language, avoiding most of the pitfalls of C++. I have wondered why D isn't picking up. Even Facebook has abandoned Warp [1]. Other than the lack of corporate backup, The complexity of the language gets out of hold as we move forward. DMD is the official compiler, but it doesn't optimize as much as LDC/GDC does. LDC/GDC is not available on the Enterprise platforms on which C++ is used (at least on the servers with RHEL/CentOS). There are 3 different compilers and the resource is not concentrated on improving just one. I agree that competition is good for health, but when things are not picking up why not focus the efforts on making the better the best (probably GDC/LDC)? Albeit few community members are very helpful and humble, personal attacks are a common thing in the forum. The foru

Facebook does [1][2][3]. [1]: http://www.drdobbs.com/mobile/facebook-adopts-d-language/240... [2]: https://github.com/facebook/warp [3]: https://github.com/facebook/flint

Note warp commits, the project is not too active. Maybe it's mature enough and requires few updates, I don't know as zapcc uses the clang Preprocessor and not warp. https://github.com/facebook/warp/commits/master

> I've literally seen 20x or more speedups in multithreaded cases just by making sure I reuse every buffer rather than create new ones. Reuse rather than free and reallocate is a core practice whenever you feel the need for speed, regardless of the memory allocate strategy used. For some very fast D code: https://github.com/facebook/warp Minimizing the amount of heap memory allocated is a core strategy.

Facebook uses Warp[1] as a fast replacement for the c/c++ preprocessor. [1]https://github.com/facebook/warp

> Does anyone else find it sorta ironically odd that one of the masterminds behind this great stuff is now a .... gasp Facebook ... employee?? Would you be referring to the business morals or technical requirements of Facebook? You need a lot of good hacks to deal with large bulks of data. For example: https://github.com/facebook/warp I heard Goooogle developed Go partially because they were fed up with the time taken up compiling massive C programs.