Slashdot Mirror

Having used languages with and without garbage collection, my view is that
garbage collection is often very nice... but I don't really mind the "lack" of garbage collection in C and especially don't miss it in C++.

My opinion is that it takes some effort on the programmer's part to learn to use C safely. I'm not sure why, but this answer seems to suprise some people. Do they seriously expect that in the real world-- of software or of anything else-- that they should be able to pick up any tool they want and understand how to use it well right away? Appearantly so, but it's pretty silly, isn't
it?

C++ and C are like very sharp carving gouges: It's up to you to learn how to use them properly, to hone them peridically, and to build safe habits. You need to do this in any language that you use, but the sharper the tool the more important it is to bear this principle in mind. A lot of people try to pick up these sharp tools, and then blame the gouge when they've cut themselves. It's no suprise, because they did not take the time to learn to be careful.

In my view your best bet for using a programming language safely is to develop
certain habits and adopt idioms that cause you to simply not write code with some types of errors. In the case of resource-freeing errors, when you open a door, you must remember to close it. It's not complicated, but you have got to turn it into a real habit, something you just do-- and it follows that there will also be some patterns that you should train yourself to just never write. Give it a go (and give it some time).

That will go a long way, but I'm afraid that there's some bad news: even that is not enough. I've been writing software in C for 17 years now, and although without a doubt I write fewer errors than I used to, I still do not produce error-free programs. Eventually, I make plenty of mistakes. Complexity does that.

Some very good news: Memory management in C++ is so nice that very frankly I do not miss /either/ garbage collection or C-style memory management when I am using it. (And of course, you can use either of those with C++ just fine.) There are all kinds of tools and patterns to help you out, although again it's going to be up to you to use them and make a habit of it. There's the "resource aquisition is initialization", smart pointers (built into the standard library, provided by Boost, and roll-your own), new and delete, malloc() and free(), statically allocated memory, and garbage collectors for you to link in. Take your pick! Use the right one for the job.

Bjarne Stroustrup explains all of this extremely well. Here's a link or two to his FAQ and what it has to say about C++ and garbage collection:

        http://www.research.att.com/~bs/bs_faq.html#garbag e-collection
        http://www.research.att.com/~bs/bs_faq2.html#memor y-leaks
        http://www.research.att.com/~bs/bs_faq.html#advanc ed

Think about it for a while. Remember that memory is only one kind of resource that we need to manage. It's up to you to ferret out and apply the tools available to you.

If you want a garbage collector, why not use one? But it's not the only way to achieve the ultimate goal of producing reliable, efficient software.

Having used languages with and without garbage collection, my view is that
garbage collection is often very nice... but I don't really mind the "lack" of garbage collection in C and especially don't miss it in C++.

My opinion is that it takes some effort on the programmer's part to learn to use C safely. I'm not sure why, but this answer seems to suprise some people. Do they seriously expect that in the real world-- of software or of anything else-- that they should be able to pick up any tool they want and understand how to use it well right away? Appearantly so, but it's pretty silly, isn't
it?

C++ and C are like very sharp carving gouges: It's up to you to learn how to use them properly, to hone them peridically, and to build safe habits. You need to do this in any language that you use, but the sharper the tool the more important it is to bear this principle in mind. A lot of people try to pick up these sharp tools, and then blame the gouge when they've cut themselves. It's no suprise, because they did not take the time to learn to be careful.

In my view your best bet for using a programming language safely is to develop
certain habits and adopt idioms that cause you to simply not write code with some types of errors. In the case of resource-freeing errors, when you open a door, you must remember to close it. It's not complicated, but you have got to turn it into a real habit, something you just do-- and it follows that there will also be some patterns that you should train yourself to just never write. Give it a go (and give it some time).

That will go a long way, but I'm afraid that there's some bad news: even that is not enough. I've been writing software in C for 17 years now, and although without a doubt I write fewer errors than I used to, I still do not produce error-free programs. Eventually, I make plenty of mistakes. Complexity does that.

Some very good news: Memory management in C++ is so nice that very frankly I do not miss /either/ garbage collection or C-style memory management when I am using it. (And of course, you can use either of those with C++ just fine.) There are all kinds of tools and patterns to help you out, although again it's going to be up to you to use them and make a habit of it. There's the "resource aquisition is initialization", smart pointers (built into the standard library, provided by Boost, and roll-your own), new and delete, malloc() and free(), statically allocated memory, and garbage collectors for you to link in. Take your pick! Use the right one for the job.

Bjarne Stroustrup explains all of this extremely well. Here's a link or two to his FAQ and what it has to say about C++ and garbage collection:

        http://www.research.att.com/~bs/bs_faq.html#garbag e-collection
        http://www.research.att.com/~bs/bs_faq2.html#memor y-leaks
        http://www.research.att.com/~bs/bs_faq.html#advanc ed

Think about it for a while. Remember that memory is only one kind of resource that we need to manage. It's up to you to ferret out and apply the tools available to you.

If you want a garbage collector, why not use one? But it's not the only way to achieve the ultimate goal of producing reliable, efficient software.

one step closer to my fembot fantasy girlfriend, featuring(Audrey UK)'s voice from http://www.research.att.com/projects/tts/demo.html

One could enforce using a system in object space, rather than memory space, too, and compile this to native code with little or no peformance loss — this is what the Microsoft's research project Singularity, mentioned on here not long ago, is suggesting.

Back to the topic, though, in practice, the performance hit of managed code is negligable in most cases, and the extra safety it provides is far more valuable. Nobody can write bug-free code. Making entire classes of serious bugs impossible to implement is a very good thing.

There's a few more problems, unfortunately, to C than you allude to, but there is work in creating a C-like language which is more safe — Cyclone comes to mind if you're interested. :)

think again. AT&T still reaps the benefits of monopoly.

http://www.att.com/cls/products/corded.html

Who do you think rents these phones? It is the elderly, those on fixed incomes who can least afford to spend money foolishly. All because AT&T brainwashed these people into believing that they had to rent their phones from AT&T in order to get phone service. Sure some people might be aware that they can buy a decent phone for the cost of a couple months lease, but many probably just pay the bill because they really don't know they have a choice.

My mother had a AT&T leased phone which was built into the wall in the early 70's which we figure she and my grandparents before her had spent thousands of dollars on over the life of the phone. And beyond the life of the phone, since it had broken many years before and could not be replaced or serviced any longer. Finally after threats they would come and rip it out of the wall (leaving a gaping hole) if she did not continue to pay their blood money, she told them fine to come by and rip it out of the wall, but she wasn't paying them any longer. That was the end of the story for a phone that is rather famous in my family and remains built into the kitchen wall and no AT&T representative with a crowbar has come knocking at the door as they had threatened.

To sugar coat the history of "The Phone Company" and to speak as if their dirty practices are all water under the bridge or that somehow that being a monopoly has nothing to do with the way a company treats its "customers" is beyond reasonable. There is no such thing as a "natural" monopoly. You can apply the same false logic to any business and argue about efficient use of resources and the waste of competition. Large monopolies are only possible under government regulation and since the advent of the corporation there is nothing natural about them. And eventually it is inevitable that monopolies treat their customers like any other resource, to be squeezed for every last drop.

On the other hand, AT&T had a nifty lab of their own. http://public.research.att.com/

I don't see what the hubbub about all of this is, though. The forced split of AT&T was a success, in so much as creating competition and removing the public's reliance on a single firm. With this acquisition by one of the largest baby bells it brings the company back in line to compete. It's not like they'll suddenly be allowed to buy out Verizon and create another monopoly on that scale.

To top things off, even if they were to obtain a monopoly on the telephone system again it would never be as powerful as the one they once had. Today we have Cell Phones and VoIP. There's other means of efficiently communicating over long distances. They would basically have to buy control over most of the network comprising the US portion of the Internet to be able to come close to what they once had. I just don't see that happening any time soon.

All those techniques yield competitive performance to C in user space. Why do you think they wouldn't do so in kernel space?

I'm speaking from the perspective of a microkernel when I'm arguing this, so perhaps that illuminates things for you. A small implementation with critical code paths that fits nicely within L1 cache are essential for high performance. Can you honestly tell me with a straight face that JITC techniques, garbage collection, and other high-level features are competitive with C for producing such code? Point me to a high-level language you think is usable in a kernel, ie. with all or some of your desired feature set, then show me where it gives you direct low-level control over memory layout and data structure representation, and control over the runtime.

The only efforts I've seen in this regard are BitC, Nitro, and Cyclone (projects that actually have implementations that is). None of them are there yet.

I don't think any of those systems will ever result in a practical OS; they were/are research projects.

I suggest you read more about the history of EROS. It was initially designed as a direct reimplementation of KeyKOS, the first commercial timesharing operating system to support mutually suspicious clients. It's been used in ATMs and other mission-critical operations for decades. EROS has since improved on the KeyKOS design. There is absolutely no reason why CapROS could not become a practical system. There is nothing research-centric about EROS/CapROS except its unfinished nature.

>Not that I agree with the original poster, you can certainly emulate C++ in C.

Somebody should already have said this, but, for that matter, you can *WRITE* C++ in C... Bjarne did :)

( http://www.research.att.com/~bs/bs_faq.html#bootst rapping )

No really, it's funny...

<understatement degree="gross">Having tons of developers isn't necessarily an advantage when designing the core of a runtime system.</understatement>

Thanks for your open invitation join the big party going on in the kitchen, and throw my own ingredients into the delicious rock soup you all are cooking. Please seriously consider my proposal to add generalized overloading of white space to Parrot, based on Bjarne Stroustrup's brilliant and well thought out paper: Generalized Overloading for C++2000.

What good is Parrot, if it can't support all the wonderful features of C++?

-Don

With an attitude like that, I'll bet C++ would really appeal to you, too -- you should definitely check it out! Why wait for Perl 6 when you can start learning C++ today!!! C++ has just as many cool buzzwords as Perl, and it tries to go down even more dead-end paths at once! You'll just love operator overloading and templates, and you'll want to use all its advanced features at once in every program you write! But if you don't have time to learn C++, then why not adapt its best ideas to Perl?

You'll really be amazed by Bjarne Stroustrup's brilliant extension to C++: "Generalized Overloading for C++2000", and I'm sure you'll want to delay the release of Perl 6 some more until all these cool features can be appropriated and hacked into the Parrot VM.

Here are some of the most amazing features of Generalized Overloading in C++2000, that you will never be able to live without, once you've tried them:

With the acceptance of the ISO C++ standard, the time has come to consider new directions for the C++ language and to revise the facilities already provided to make them more complete and consistent. A good example of a current facility that can be generalized into something much more powerful and useful is overloading. The aim of overloading is to accurately reflect the notations used in application areas. For example, overloading of + and * allows us to use the conventional notation for arithmetic operations for a variety of data types such as integers, floating point numbers (for built-in types), complex numbers, and infinite precision numbers (user-defined types). This existing C++ facility can be generalized to handle user-defined operators and overloaded whitespace.

[...] Here, I describe the more innovative and powerful mechanism for overloading whitespace. Consider x*y. In programming languages (e.g. Fortran, Pascal, and C++), this is the conventional notation for multiplying two values. However, mathematicians and physicists traditionally do not use the operator *. Instead they use simple juxtaposition to indicate multiplication. That is, for variables x and y of suitable types,

x y

means multiply x by y.

[...] Overloading Separate Forms of Whitespace

There are of course several forms of whitespace, such as space, tab, // comments, and /* */ comments. A comment is considered a single whitespace character. For example,

/* this comment is considered a single character
for overloading purposes
*/

It was soon discovered that it was essential to be able to overload the different forms of whitespace differently. For example, several heavy users of whitespace overloading found overloading of newline ('\n'), tab ('\t'), and comments as the same arithmetic operator is counterintuitive and error prone. Consider:

double z1 = x y; // obvious
double z2 = x
y; // obscure
double z3 = x /* asking for trouble */ y;

In addition, different overloading of different whitespace characters can be used to mirror conventional two-dimensional layout of computations (see below).

Stavtrup claimed that it was important to distinguish between different number of adjacent whitespace characters, but we did not find that mechanism useful. In fact, we determined it to be error-prone and omitted for Standard C++.

Overloading Missing Whitespace

After some experimentation, it was discovered that the overloading mechanism described so far did not go far enough. When using the mechanism, the physicists tended to omit the space character and write

xy

rather than

x y

This problem persisted even after the overloading rules had been clearly and repeatedly explained. What was needed wasn't just the ability to overload explicit use of whitespace, but also implicit application. This is easily ach

http://www.research.att.com/cgi-bin/access.cgi/as/ njas/sequences/eismum.cgi

I am sorry, but the terms
1, 4, 8, 13, 21, 30, 36, 44
do not match anything in the table.
If your sequence is of general interest, please send it to me using the form provided and I will (probably) add it to the data base! Include a brief description and if possible enough terms to fill 3 lines on the screen. I need a minimum of 4 terms.

Other than that, there's the Commentator...

Interestingly, and informatively, I think, everything you're saying about MS and C# could be said about Sun and Java. I was doing Java in the 1.0 and 1.1 days. For 1.1 they changed the event model, so you had to unlearn the former and learn the latter. Then they came out with Swing, just as you were getting a handle on all the AWT classes. By only the 2nd version (1.1) a disconcertingly large number of API's were already deprecated.

But a) Java was new, and b) the company behind it had big plans for it -- capturing market share. That's the ultimate goal any corporation has for their proprietary language. And I'm not down on corporations or their proprietary languages -- I used VB for a little while, and recognized that it was very good for what it was. But in general, better to have a non-proprietary committee-driven language, like C++, where additions are considered at great length (an understatement!) by those who are (mostly) only interested in what's best for the language and its developer community.

On your comment on C++, it is in no such stage of any such disease. It's inventor, in recent thoughts on the next version (featured here on Slashdot a few months ago), is very cognizant of the drawback of dumping every good idea into a language such that there are 6 or 7 ways of doing the same thing. He understands that not every library should be standard (included with the language/standard).

Note that the page you linked to for your impression that C++ leads to the specification of sublanguage dialects is from 7 years ago, with the last update being 4 years ago, to add "don't use reserved words as identifiers" (duh). Things like "don't use exceptions" and "don't use C++ standard library features" (!!!) date back to, as mentioned there, Visual C++ 1.5! Most of that document is either obsolete or profoundly bad advice, today.

That said, as a final thought, I will agree that sublanguage dialects of computer languages do exist, but generally a single shared one, not incompatible ones. Maybe when a language is new, different subsections of the developer community will go off in different directions and try different new features to the bepuzzlement of others, but over time best practices are realized and books are written that convey them to new users, and an equilibrium occurs, so that everyone is generally on the same page. It helps if people try to code to that, too.

Just feed Eliza some random input from an irc channel and pipe its output into ATT&T TTS system and then into the phone for the telemarketer.

Option 2)

And if you are really lucky (and spammed), team up two telemarketers with each other, just as we saw with skype here.

I used to work for AT&T's Network Disaster Recovery organization. As you can see at http://www.att.com/ndr they've got about 100 of those trailers. The catch, with respect to the current disaster, is that they're mostly for recovering long distance, not local service. And without the local infrastructure, there's not much traffic to get in or out of the area.

Some of my former co-workers are trying to recover one metro New Orleans location even now, but there's not much they can do for the city proper. They're probably operating the Emergency Communications Vans at some shelters (see picture at http://www.att.com/ndr/humanitarian_relief.html/) to allow people to call out, but the need is so great that even at max capacity, they aren't going to have a huge impact.

(Personal boast: I led the design and installation for the Frame Relay, ATM, and IP trailers.)

I used to work for AT&T's Network Disaster Recovery organization. As you can see at http://www.att.com/ndr they've got about 100 of those trailers. The catch, with respect to the current disaster, is that they're mostly for recovering long distance, not local service. And without the local infrastructure, there's not much traffic to get in or out of the area.

Some of my former co-workers are trying to recover one metro New Orleans location even now, but there's not much they can do for the city proper. They're probably operating the Emergency Communications Vans at some shelters (see picture at http://www.att.com/ndr/humanitarian_relief.html/) to allow people to call out, but the need is so great that even at max capacity, they aren't going to have a huge impact.

(Personal boast: I led the design and installation for the Frame Relay, ATM, and IP trailers.)

Why is the Internet less reliable? I think it's a combination of things. First, as you suggested, it's young, and is constantly undergoing massive change. The telephone network had years of relative stasis in which to stabalize. The Internet is still experiencing huge growth in capacity and capabilities, as the network and the connected devices grow by leaps and bounds (c.f., Moore's Law. :).

The second thing is that the Internet is a general -purpose network. People do the damndest things with it. Napster and Bittorrent drastically changed the traffic patterns on the Internet, just like the Web did before them, and like NNTP (news) did before that. Phone engineers had fairly accurate models of call traffic behavior and could plan around those .. at least, until modems came around and people started dialing in to the Internet.

The final thing is one of management complexity. The Internet is a looser confederation of interconnected systems. There are thousands of ISPs in the U.S. alone, compared to the handful of telephone companies. This distributed operation is a powerful thing for innovation - any schmoe with a great new idea (56kbps modems, DSL, cable, wireless, free space optics, carrier pidgeons) can start an ISP. But it also means that the trust model is a little flakier and that you've got to get more people to work properly to make the network stable. There may also be a commodity cost argument in terms of what the average customer is willing to pay for. Particularly when their 911 service doesn't run over the Internet.

Re the ARPAnet: If you look at the Internet inside of one ISP or autonomous system, it's quite a bit more reliable than the end-to-end picture when you're going from your house through two ISPs to some remote service provider. AT&T and its ISP friends will happily sell you a 99.99% uptime SLA on their Internet service, if you pay for it, and I believe they can probably meet it most of the time. The basic packet switching technology works exceptionally well, and can deliver great availability. But things get very complex when you scale that up into the entire Internet and start involving not just the raw links of a single ISP, but many organizations, servers, DNS, etc.

AT&T has a pretty awesome global operations center:
http://www.research.att.com/areas/visualization/pr ojects_software/photo_global_center.jpg

I've been looking for a decent version of something like this for ages. I've previously investigated Agent Frank, WebMate, IProxy, and I've used WBI. All seem lacking in some way.
PPS looks promising. I'd like to see the search functionality of PPS integrated into the proxy so you can do a search right from the browser and it can show you live links......

I grew up in central NJ, got my first taste of programming at the Explorer post run by the Telephone Pioneers at Holmdel, and worked at the adjacent Middletown and Lincroft sites for five years. I was a visitor at Murray Hill frequently over that time, and always felt a little awe-struck walking around in there. This news, along with Lucent selling the Holmdel site (story at Asbury Park Press), leave me feeling all too old. Sic transit...

You might be interested in Cyclone, a safe variant of C that's influenced by ML and attempts to retain as much of the low-level control of C as it can; it uses what's called region-based memory mangement, which in theory provides useful alternatives to regular GC. (I haven't actually tried to write anything in it, though, so I can't say how practical / easy to use that kind of thing is.) MLKit does something similar, I think.

Bat is the only human tracking system I have seen implemented that actually works.

It takes a lot more than just having a wireless link to do tracking. However, the Bat system was attempting to track location to the cm if you just want to figure out what room someone is then I can think of ways to do it. The general result is that you still need either gps (which is unreliable indoors) or beacons in each room in order to make it work.

However, once implemented the Bat system's researcher discovered that it actually wasn't all that useful a system for just being able to locate a person. The practical applications for human tracking are context aware components and space analysis. Context aware systems are a long way off and space analysis is only interesting to managers and architects so I wouldn't bother putting the time into attempting to implement this.

You are a US PATENT SYSTEM EXPERT!

- Declare PHP a Canadian invention. The Danish Government doesn't want you to know this, but Mr. Lerdorf WAS A CANADIAN CITIZEN.

Nice, and what language is PHP written in? C++? Which was invented by... A Dane! See for yourself.

-H

What you don't seem to know is that MS Windows is utterly missing the wonderful collection of little tools available on every UNIX platform

What you don't seem to know, is that you get all those little UNIX tools in Windows, including the ones made by Microsoft.
http://www.research.att.com/sw/tools/uwin/
http://www.microsoft.com/windowsserversystem/sfu/p roductinfo/features/default.mspx
Now in UNIX nowadays, particularly Linux (BSD guys tend to be more conservative (*)) sometimes there's huge bloat for system configuration: you might need Ruby, Python, Lua, Perl, Scheme, Rexx, Bash, C, C++, and any other language people invent. And in some package managers, dependencies must resolve to a particular version of these languages, even though, for instance, the guy _never_ used generators, but still asked for Python 2.3. It's a big mess sometimes. That's why some want to keep it small and code in C for the most part (e.g., OpenBSD), for better or for worse. OTOH, C sucks.

(*) Even though you even get to see Forth and Modula3 code in FreeBSD, for instance. But they're chosen for a reason, not just "hey, this language is kewl, dude!"

Did you read the article?

Don't tell us, tell Bjarne!

C++ language features
http://www.research.att.com/~bs/evol-issues.html

C++ standard library features
http://lafstern.org/matt/wishlist.html

Anyway, your language without buffer overflows would not use pointer arithmetic, so would create a zlib a lot slower than the one we now, even if you optimise your high level language to the max.

As for mandatory array boundary checks, they can really be optimized away whenever they are not needed. Most trivial example: in case the complier has verified that the loop counter is within the boundaries of the array, no check on access is necessary. Provided the optimizer is good, there won't be any significant difference between the optimized code with mandatory checks and the code where all necessary checks are added manually.

It can even be possible to allow real pointers and pointer arithmetic, have certain source-level compatibility with C, and still have the code which has all necessary checks and is not prone to buffer overflows. E.g. check out Cyclone, which was discussed on Slashdot some time ago.

On-Line Encyclopedia of Integer Sequences entry:

http://www.research.att.com/projects/OEIS?Anum=A10 4101

AT&T Internet ProtectSM is a security alerting and notification service that offers advanced information regarding potential real-time attacks (viruses, worms and distributed denial of service or DDoS attacks) that are in the early formation stages.

Ok, but does bash or ksh run on windows? This is for their own OS, not unix.

It does natively (no cygwin) with Unxtools for Windows! Eventhough sh.exe is zsh, not bash of ksh.

It's the first thing I install on a Windows machine.

I guess you've never seen bash or ksh for Windows then.

Java is not cross-platform -- it is a platform. If all you know is the Java language and its API's, then that's the only platform you know. If someone asks you to write them an NT service or a Windows system tray application, you can't because you don't know that platform. If the VB runtime were ported to every system imaginable, it still wouldn't be cross-platform because it is a platform. If all you know is the VB language and it's IDE and how to string together OCX's, you are writing platform-specific code. Just like the Java and Windows developers.

On further investigation, you're right that Shamir didn't discover ZKPs. What he did write was a paper which introduced a ZKP system which was suitable for making unforgeable identity cards.

Since you were after evidence, the best I could find was this column from the Journal of Algorithms in 1988. It notes that "the US Army briefly tried to classify" the paper, citing a New York Times article from 1987 by James Gleick. Sorry, I don't have anything which has more of the story than that. (I originally read a fuller account it in a Martin Gardner article from Scientific American 15 odd years ago.)

But impossible to follow, is this:
Only comment the things that are hard to understand. The problem here is that you probably understand everything you're writing.

One way out might be to have a less-talented programmer give it the once over, and point out anything s/he didn't understand, for you to comment upon.

That, and as Dr. Stroustrup (Bjarne) said in class today, your code constructs should be directly analogous to what they are trying to describe in real life... But I guess this goes down to self-documentation.

Needless to say, it's a rather specialized database system, designed for problems on the order of "record all the event data needed for phone bills"; you're not going to run it on MYSQL in your basement. And it's not a complete sample of headers, much less message bodies (AT&T carries about 2 Petabytes/day of traffic), but it's an interesting start for detecting many kinds of weirdness. There are other ways to collect lots of traffic - routers mainly do packet counters of various sorts, so you're only getting aggregates rather than details, but they're good for other kinds of problems.

Well - it's kind of difficult to defend against a criticism so vague and (going by context) inconsistent. I mean, if you're going to say that C++ smart pointers are all ugly kludges (as I can't see a way you'd think auto_ptr is an ugly kludge but shared_ptr isn't), then you should really be comparing it to the alternatives - umanaged raw pointers which (as you've pointed out) leave you fucked in the case of exceptions. And if you think that they're ugly kludges too, then you pretty much think all of C++ is an ugly kludge :). Which is fine with me, don't get me wrong - just that you shouldn't specifically point towards the smart pointer technique as being an ugly kludge of a solution (to the problem of exception-safe dynamic memory management without automatic garbage collection).

There's also the minor detail that writing auto_ptr<T> t; inside one block is much tidier (and, IMO, clearer) than writing T* t = new T(); in one block and then matching that pointer up with a corresponding delete somewhere else. It's also safer - even before you bring exceptions into the picture.

As a final point, C++ does have true garbage collection as an optional extra. I haven't used it myself, but apparently some people do, and it works fine.

While anything allocated on the stack will be destroyed when an exception is thrown, any resources allocated during execution will leak (ex: handles or memory allocated on the heap).

Wow, this is stunningly wrong. That's what destructors are for - they will free any resources that your local objects allocated/acquired. That's the resource acquisition is initialisation paradigm, and it ensures that resources are always freed when you leave a scope. This is contrary to using a goto for error handling, where you still have to be careful that every execution path goes through the cleanup code. And of course, how are you going to ensure that some future maintainer doesn't add a "return" somewhere, bypassing your cleanup code altogether?

This is one of the really nice features of C++, by the way. It's much cleaner than finally blocks.

Not all computer generated speech sounds completely robotic. AT&T has had it's Natural Voices Speech Engine demo around for some time. I'm surprised that more text-to-speech programs haven't used this. I suppose licensing is pretty 'spensive.

In fact these devices would be cheap enough to set up a whole classroom with VNC based terminals.

Mount a solarpanel on the back to recharge the display batteries and you would help save the planet! Down with rooms full to 300-400Watt power sucking PCs!

This is what you need: the "Bat Ultrasonic Location System", developed at ATT Cambridge labs (former).

From this page:

We have deployed the ultrasonic location system throughout our building, using 720 receivers to cover an area of around 1000m2 on three floors. The system can determine the positions of up to 75 objects each second, accurate to around 3cm in three dimensions.

"No," he replied, "it is a very interesting number; it is the smallest number expressible as the sum of two cubes in two different ways."

If you want to know how else 1729 is interesting, you can look it up in The On-Line Encyclopedia of Integer Sequences.

Of course, every positive integer is interesting. Proof: Assume the contrary. That means there exists a smallest uninteresting positive integer. Hey, that's pretty interesting! A contradiction.

I think it'd be cool if Neil Sloane, who maintains the Encyclopedia, wrote a program that started with an ordered set containing all integers up to some huge number and removed every integer from every sequence in his database. It'd be very interesting to see what was left...like, the most boring numbers we know. For now.

My point was that technology changes, and so does the code to implement it. If we have later versions that do better, it's only because we have prior versions that we can leverage.

My point was that the criticism of the author (Tiemann) of those prior versions because they aren't "as good as" today's code is lame, unfair, and just throwing rocks for the sake of rock-throwing.

For a minute there, I thought this article was going to be about how millions of teenage girls are displaying frightening symptoms: siting inside all day instead of socializing, playing computer games all day, turning away from reality. I guess the Sims has the power to turn girls into guys. But that's not what this is about...

Since this is presented as a tool on which to base political policy, I am quite alarmed.

While you are making a joke, this actually brings into question several of the assumptions underlying this model. The social networks employed by this model are very simple compared with real life. Even though they are rigged to have similar power-law statistics, the model used may not be able to reach useful results. Critical details in the social networking of super carriers and patient zero are handled poorly, IMHO and that's only based on the article, basic college stats and high school level intro to sociology.

For instance, for any STD model will have to take into account the many over layed and distinct networks of sexual interactions. Sexually active high school students such as in your teenage girl joke have a very different social network pattern from adults. Another pattern is common among college students. Trying to use the model from the article would lead to incorrect results for their population and would deviate significantly from reality.

basic scientific research

law enforcement... military defense

development of open protocols like TCP/IP

providing health insurance that doesn't leave you filing for bankruptcy if you get sick

Stephen Hawking my foot!

http://www.research.att.com/projects/tts/demo.html

That's an amazingly nice TTS engine that AT&T is playing with. Check it out. Type in some text, and they'll render it to speech for you and give you a link to the file.

You're right, they are left over equipment from AT&T Labs Cambridge, which were redeployed in the Laboratory for Communication Engineering at the University of Cambridge.

But they're more than prototypes, the phones work really well even six years after being built (mainly due to their thin-client architecture, as only the servers need to be upgraded to run more complex services, not the edge phone hardware).

It's a bit of a shock to see this randomly show up on Slashdot, but for those interested readers, here's a WIP paper about what we're doing with them these days (using the Active Bat location system to migrate mobile phone calls via Bluetooth to the nearest environmental phone among other things).
As I said, the paper is very much WIP, and is being hacked up after being freshly rejected from a conference so the link is liable to disappear :-) Feel free to get in touch with the main man behind the phones, Rip Soham, if you are interested in more details (contact details in the link).

As far as I know, no commercially available VoIP phone uses VNC these days, which is a real pity as its a really neat way to offer easily upgradable services to the end user (forget running mobile code on the edge device, compute power is cheap these days).

--
Wanna iPod Photo?

Either that or some kind of VPN at least. The VNC authors don't consider the data stream secure even. See this FAQ for more details on that. The password is also limited to 8 chars, btw.

Since no user name is used, a hacker just needs to break your password and they have easy access to your system. During login a random string is sent to the viewer, encrypted with the user password and sent back. I suspect that someone evesdropping on the full conversation could probably work out the password with some effort.

So..

• Use a VPN, SSH or some other way to encrypt the datra stream for VNC
• Firewall access to VNC from the Internet
• Under Windows, set preferences to log you out or lock the session when you disconnect (At least the person getting in will have to also know/guess your windows password.)

I've come to the opinion that under all but the most extraordinary circumstances, a company should not work on developing custom applications in-house. They should either farm them out to a development company, or they should adjust their processes to work with existing Commercial Off The Shelf (COTS) applications. Concentrate on your core business and you're probably better off. If your core business is not software, you probably can't do a successful software project.