Slashdot Mirror

("Proficient in C, C+, and C++" is a gem that springs to mind)

Note here that while indeed C+ do not exist, there is an actual programming language named C--

You may want to take a look at C--. It's got some good justifications for claiming to be a better assembly language than C.

Mod parent up one more, he deserves a +5. As an engineering student in the later 70s/80s, Fortran was all I knew or cared to know. My one Comp Sci course was beginning Fortran programming -- the whole thing is probably learnable in a few hours today. My final year thesis was a 6000 line Fortran simulation used to determine the feasibility of building a "Two Stage Spouted Bed Coal Pyrolysis Plant" in China (it was).

95 percent of the people who programmed in the early years would never have done it without Fortran.

It is easy to criticize, as many other posts have done, something invented half a century ago. Personally, I miss being able to use Fortran (or a procedural basic) to solve today's problems -- we've given ourselves over to the machine's favorite language (C) while we pat ourselves on the back for how smart we are now (as we create write-only code).

I wish this had become more popular. There's still time.

All the vision code is written in C-- ...

If you're talking about C--, what adwantages are there in writing code for the application in a code generator intermediary language vs. writing code in a language that has a front-end to C-- and optimizing that front-end?

The absence of "goto myfunc(param);" makes implementing coroutines or tail calls un-necessarily hard when using C (or compiling to C).

If your C compiler does not optimize obvious tail calls (e.g. return myfunc(param);), then your C compiler has a bug.

There is no valid reason for a very-low-level language to hide features available from assembler.

C is not a very low level language. You're thinking of C--.

Have you come across C--, which is actually designed as a portable compiler target language?

Lower level than C in some ways (since it doesn't bother with things that the higher level language should be handling), but supports other things that C doesn't, like exceptions, and optimized tail recursion.

Still experimental, but interesting.

One of the things that it isn't is a virtual machine like Parrot.

Designers in abundance, salesmen all around but what I need is a coder and a C to sail them on.

But this C is tiny and difficult to sail so I'll hand them all an upgrade to C++ and let them wail.

This shrieking is ill met, I stop and look profound as I have a solution it's C pound.

My coders all have left me with this ugly stinking mess I should have not given them more and more but merely better less.

Some alternatives to ant/make are

• cook (probably the best contender),
• Mk (which is like bitkeeper+make),
• Jam,
• cake (does anyone use this any more?), and
• the Plan 9 mk.

There's also something called Cons, but it needs perl to work. See this.

I haven't found a good alternative to autoconf yet. There used to be Metaconfig, but I don't know who maintains it any more (or where). It produces configure scripts similar to what you see when you configure perl. This guy uses some unreleased software package for his build systems that tend to work really well -- for C code under Unix.

Come to think of it, if someone ports/writes a build tool in C#, you'd be set.

I'm not a great fan of OO languages (just how much syntax do you really need?), but it would be wonderful if somebody would get rid of the pointless `new' keyword for object construction, add algebraic datatypes and pattern matching, and add closures as first class objects.

But when you use genuinely modern declarative languages (Mercury, OCaml, Haskell, ...) there's no real incentive to go back. It's like good hi-fi.