Slashdot is powered by your submissions, so send in your scoop


Forgot your password?

Slashdot videos: Now with more Slashdot!

  • View

  • Discuss

  • Share

We've improved Slashdot's video section; now you can view our video interviews, product close-ups and site visits with all the usual Slashdot options to comment, share, etc. No more walled garden! It's a work in progress -- we hope you'll check it out (Learn more about the recent updates).


Comment: Why D isn't more popular (Score 4, Insightful) 386

by dentin (#48860571) Attached to: Is D an Underrated Programming Language?

I've looked at D before. It looks promising, and I've considered using it. The reason I don't is a bad reason, but it's the most common bad reason: legacy code.

I have two hundred and sixty four thousand lines of code in my personal project/library archive (my own code, not counting custom versions of external packages like openssl and portaudio), all in C/C++, all with a unified build system, that's been ported and debugged on serveral platforms. Every new project I start uses those core libraries and header files. When I think about switching to a new language, my biggest concerns are how new code will integrate with my existing, how the new language will make use of my existing libraries, and how to remain productive in a dual language environment. The long term gain might eventually make it worthwhile - but it might also just cost me time should the new language die out or not support a platform I need it to.

I simply can't justify the gamble.

Comment: Noob burner making obvious suggestions (Score 1) 342

by dentin (#48190043) Attached to: An Algorithm to End the Lines for Ice at Burning Man

Bennett, please just shut the fuck up about your improvements to burning man. For your traffic flow 'improvement', you notably didn't provide simulations, suggested a broken alternative, and didn't even bother to fully understand the situation before jumping in with both feet. For this one, you've done something similar.

In particular, the problem when the ice line is backed up is -not- because the ice wasn't prefetched. It's because half the time they can't get it out of the trucks any faster, and half the time they can't get the customers out of the way faster. Adding prefetch to a throughput bound system does not improve performance. If you had the experience of going through the lines more than a few times, you'd have maybe picked up on that before offering your advice.

I'm not going to say that traffic isn't a problem, or that ice queues aren't stupidly long at times. But these are hard problems, and they have been thought about extensively by smarter people than you, smarter people who have more information and experience than you. You insult all of them by discounting that so blatantly.

Comment: Re:Is the complexity of C++ a practical joke? (Score 1) 427

by dentin (#47674377) Attached to: Interviews: Ask Bjarne Stroustrup About Programming and C++

Oh yeah, (a) is definitely true, but that's no reason to blackhole it immediately, especially if it does something good at the parsing layer. There have been plenty of instances of 'deprecated' features being used for several years with compiler switches to allow it.

Comment: Re:C++ is an over bloated monster (Score 1) 427

by dentin (#47672513) Attached to: Interviews: Ask Bjarne Stroustrup About Programming and C++

Personally, I do a lot of the following:

- learn the minimum aspects of the language needed to navigate your specific codebase, and learn them very well
- copy/paste of terrible syntax to avoid compiler failures
- avoid using templates if at all possible
- create strongly typed specific-use classes that export only the minimum functionality of the underlying libstdc++ classes without using templates
- keep all pointer casting to well defined, central locations
- all production code runs with asserts on all the time
- thou shalt never use multiple inheritance. Ever.

Regarding managing inheritance and figuring out inheritance trees and which classes own what functions where, I'm still basically at a loss and I've been fighting that problem for years. The best advice I can give is try to keep your inheritance trees as shallow as possible; but for real world systems, it often doesn't make sense. I have a set of socket libraries which pretty much has to be 4-5 levels deep in spots to do what it needs to do properly, and it's disconcerting to have to look back to for example layers 1 and 3 to try to figure out what's going on.

Comment: Re:Is the complexity of C++ a practical joke? (Score 1) 427

by dentin (#47672315) Attached to: Interviews: Ask Bjarne Stroustrup About Programming and C++

Further, in my opinion, we should look at the most common coding conventions and consider adding pieces of them to the compiler and language specification if it makes sense to do so. Naming of functions almost certainly doesn't make sense; but requiring braces after all conditionals very well might (and may make compiler parsing of other constructs easier to handle.)

The most common coding styles almost always touch on what would be 'best practices' in the field. Adding those 'best practices' to the core language specification seems like something that should at least be considered.

Comment: Re:Is the complexity of C++ a practical joke? (Score 4, Insightful) 427

by dentin (#47672231) Attached to: Interviews: Ask Bjarne Stroustrup About Programming and C++

This is a very good set of observations, and I also feel that C++ has become a 'niche language for insiders'. The syntax is difficult; it's remarkably easy to shoot yourself in the foot in unobvious ways; and porting can be problematic, as no two compilers compile the same code the same way. Trivial mistakes such as pointer aliasing are often compiled -silently and without error-, producing different results at different optimization levels, and -this is considered normal-. Over the years, you learn these things and you figure out which things to avoid, but for new people coming into the language, it's a huge barrier to entry.

If the goal is to really get a lot more programmers to use it, the base syntax almost certainly needs to be improved. Rather than providing some obscure syntax to do some obscure library feature, make it easy to do simple things and make the language as idiotproof as possible. Make compilers either strictly produce well defined output as per the spec, or throw an error. Do -something- to improve template syntax.

Pretty much all of the new features I've seen in the C++11 spec are niche features, things used by high-end library writers with 20 years of experience to do complicated library things. That's good, libraries are important. But libraries will not translate into users if normal users cannot use them, and libraries will not translate into users if the language itself is the bulk of the learning curve.

Comment: Re:Do you ever feel bad? (Score 1) 427

by dentin (#47672095) Attached to: Interviews: Ask Bjarne Stroustrup About Programming and C++

Further, since C++ is often called 'a better C' and is not backwards compatible with C compilers, will there be specification changes to sanitize and improve the lower level C aspects that are problematic? Examples would be strict parsing of the language without compiler dependent ambiguity, removal of duplicate constructs such as the ternary operator, requiring braces after all conditionals, strictly defining the bit width of standard types (int = 32 bits, short = 16 bits, char = 8 bits), etc.

Comment: Complexity (Score 1) 427

by dentin (#47672029) Attached to: Interviews: Ask Bjarne Stroustrup About Programming and C++

"Are there any plans for future c++ specifications to focus on readability and debugging at the source level, as opposed to adding new features?"

As everyone well knows, maintenance and debugging are by far the most time intensive aspects of software engineering. Over the years, I and many of the others I work with have evolved various 'personal standards' in our use of C and C++; these personal standards are almost entirely to aid in debugging and readability. A few examples from the C side:

- pretend that the return type of the = operator is void, disallowing both "a=b=c" and "if (a = b)" constructs
- all 'if', 'while', 'for' etc statements must be braced
- certain types of simple arithmetic operations, for example a signed 16 bit integer multiplied by an unsigned 16 bit integer, may only be handled by dedicated macros to ensure proper operation. These macros must be manually tested and verified on each platform the software is ported to.

Many of these things seem trivial, but they add up. I have seen many hours lost to unbraced 'if' statements; I have seen five different compilers require five different sets of casts to ensure that a 16x16->32 bit integer multiply produces the correct results. There are many holes in the language specification which allow compilers to silently generate arbitrary code, requiring extensive debug and testing time when porting to new platforms.

Both porting and maintenance would be eased by truly looking at the lower layers and making some difficult decisions to improve parsing and deprecate dangerous or confusing constructs. Are there plans in future specifications to do this?

APL is a write-only language. I can write programs in APL, but I can't read any of them. -- Roy Keir