Language rewrite - any success stories?

On Wed, 30 Jan 2008 21:16:45 -0800, tbarta.TakeThisOut@gmail.com wrote:

> Not to downplay the advantages of a more "lightweight" language, but
> have you considered augmenting your C++ environment? Some things that I
> find make a big difference with C++ development:
> - precompiled headers: in an experiment with 5,000 SLOC for a
> raytracer (using gcc), this cut build times in half. If you're using
> Visual Studio, add in incremental linking and it's even faster.

VC++ appears to be a "faster" overall compiler than g++, as I recently
discovered.

> - proper dependency analysis. Visual Studio again handles this
> directly. If you're using GNU tools, you /definitely/ need a Makefile
> and either `makedepend` or `gcc -MM` to autogenerate dependencies from
> #includes. It really reduces the number of 'clean builds' you'll have
> to do, so any incremental compile-link phases take less than 1 second.
> - what text editor / IDE do you use for programming? In both vim and
> emacs, you can run make directly from within the editor, and they make
> it simple to step through build errors if any occurred. If you're using
> a real IDE, this is a moot point, I suppose.

That's not the issue. My environment (SlickEdit 11) handles this.

> - KISS. Do you really need accessors for everything? Adding the
> boilerplate get() and set() functions isn't very exciting, and it's more
> or less useless on small projects. I know it's OO heresy to advocate
> public members, but remember that the tool (C++) is there to serve you,
> not the other way around.

I think you missed the disclaimer that the code was a silly throw-away
example of idiomatic lisp (at least I hope so) vs idiomatic c++, not an
example of my real coding style.

> - Know your data structures. If you're talking about using a hash
> map to store properties, why not do that in C++? You have std::map,
> stdext::hash_map in Visual Studio, or __gnu__cxx::hash_map in GCC.

It was an example only, of a completely different project, purely to show
how lisp macros can reduce boilerplate.

For that matter, I'd use std::tr1::unordered_set<> rather than any non-
standard extensions.

> Yes. There are a few ways to reduce that:
> - use templates to reduce the number of times you have to write
> something.
> - avoid memory management in your application layer; if you need
> dynamic memory, hide it in a data structure. That way, your application
> layer ends up (almost) as clean as a higher-level language.

Duder, I'm not sure what your advice is trying to be. I know how to write
idiomatic RAII c++. That's not the issue. My issue is that *for my
purposes* compilation is very slow under g++.

I've just found out (and responded to Krice upthread) that VC++ *for my
purposes* is at least 3 times faster.


> The "rule of 3" (which I assume means assignment/copy constructor/
> destrucs easy to avoid if you use better member data structures,
> allowing the compiler-generated defaults to be sufficienttor) i. Take
> full advantage of the STL and boost.

I use a lot of boost. Boost is very template-heavy, which (under g++ at
least) seems to vastly increase compile times.


> Heck, if you're not planning on
> copying your data structures, there's no reason to even implement
> assignment/copy-ctor in the first place.

Well no, you don't have to *implement* them, but you absolutely should
*define* them - giving a link error rather than using the implicitly
generated versions.


> All in all, I think it's up to what you are most interested in
> exploring. If you want to play with inter-language bindings, do that.
> If you want to learn a new language, do that. If you want to learn your
> text editor and the arcane tricks of optimizing the GNU toolchain, do
> that. If you just want to finish your roguelike... do that, and just
> take a coffee break or go pee whenever it's time to compile.

My point wasn't supposed to be as much that compile times are long. If
compiles were a rare and wondrous thing, then an extra 30 seconds
wouldn't really matter that much.

But development in C++ (as someone else upthread pointed out) consists of
"edit / compile / fix typo / compile / fix typo / compile / run / edit"
ad nauseum. Interactive language development notifies you of typos/errors
immediately, and completely skips the compilation stage.

A

awhite <spudboy.DeleteThis@iinet.net.au> wrote:
>On Wed, 30 Jan 2008 21:16:45 -0800, tbarta.DeleteThis@gmail.com wrote:
>> Heck, if you're not planning on
>> copying your data structures, there's no reason to even implement
>> assignment/copy-ctor in the first place.
>
>Well no, you don't have to *implement* them, but you absolutely should
>*define* them - giving a link error rather than using the implicitly
>generated versions.

Define? Hell no. If you define them, you *won't* get link errors, you'll
get bugs. *Declare*? Sure, preferably as private members if you don't
want them to be usable.
--
\_\/_/ some girls wander by mistake into the mess that scalpels make
\ / are you the teachers of my heart? we teach old hearts to break
\/ --- Leonard Cohen, "Teachers"