Charles Simonyi leaves Microsoft

tibbetts writes "The New York Times reports (printable version) (Free blah di blah) that Charles Simonyi, the former chief architect at Microsoft and creator of Bravo, a text-editing program that later became Microsoft Word, has left the company to form his own startup. The focus of his new company is to "simplify programming by representing programs in ways other than in the text syntax of conventional programming languages," which is highly ironic in light of his infamous Hungarian Notation style of naming variables. Perhaps more amazingly, 'Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.'"

Comments

He probably

[Fenresulven]

'Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.'
He probably threathened to reveal some rather embarassing details about how Microsoft has abused it's market power if they didn't give it to him.

Re:He probably

[Gimpin]

Sounds like the theme to the movie "The Insider". Guess software could be considered as dangerous as smoking...considering it was written by MS$ it might very well be.

Re:He probably

[ToasterTester]

Guess you didn't read "Unlike the other three men, Mr. Simonyi, who holds a Ph.D. in computer science from Stanford University, always worked on the technical side of the company rather than as a business manager."

He didn't work on the business side of the company. He was a hard core geek, thinks, codes, and collects a check.

Re:He probably

[Anonymous Coward]

6,189,143 - Method and system for reducing an intentional program tree represented by high-level computational constructs

Abstract
A method and system is described for generating executable code for a computer program, A programmer creates an intentional program tree using a syntax-independent editor. The editor allows a programmer to directly manipulate the intentional program tree. The intentional program tree has nodes. Each node represents a high-level computational construct of the computer program. For each node representing a high-level computational construct, the system transforms the node into an implementation of the high-level computational construct using low-level computational constructs. For each node representing a low-level computational construct, the system generates executable code that implements the low-level computational construct. The system further provides that where a high-level computational construct has a plurality of implementations of the high-level computational construct, the system transforms the nodes by selecting one of the implementations and transforms the node in accordance with the selected implementation. The system further provides that the implementation is selected by automatically analyzing semantics of the intentional program tree.

5,790,863 - Method and system for generating and displaying a computer program

Abstract
A method and system for generating a computer program. In a preferred embodiment, the present invention provides a program tree editor for directly manipulating a program tree. A program tree comprises of plurality of nodes corresponding to computational constructs. The program tree editor receives commands from a user that are independent of a programming language syntax. The present invention also provides a display representation generator for generating a display representation of the program tree. The display representation generator retrieves nodes from the program tree and displays a display representation of the node. A user of the present invention preferably interacts with the program tree editor based on the display representation.

---------------
These patents probably not that broad in the crowded field of "visual representations of program structures".

So MS not really giving up that much.

They figure, hey, if the guy achieves success based upon these patents then they will be much more valuable to us in our cross licensing with IBM, Sun, HP, etc.

Re:He probably

[MrResistor]

'Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.'

If they are his patents there's likely very little MS can do about it, except maybe try to sue him into oblivion, which is where the blackmail material would come in handy.

Also, if the patents belong to him, he could just respond to a lawsuit with obscene royalty charges, effectively using MS' own money to fight MS.

If I were MS I'd just let him go and do his thing, and let him try and "compete" in the "free market".

Re:He probably

[Salamander]

That's so totally wrong that I hardly know where to begin. Patents have both inventors and owners, with only the latter really meaning anything legally. It's standard practice throughout the industry for employee agreements to require that ownership of patents be turned over to the company, so all the actual inventor(s) get is their names on the patent and maybe a bronze plaque if the company's feeling generous (which they weren't for my patent). There's very little Simonyi can do about it; the employer almost invariably holds all the cards.

Re:He probably

[R2.0]

'Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.'

Hrrrmmm - Does this mean that, if he gets struck down by God in a blinding flash of light, he could be converted and release his stuff under GPL?

Quick - you get the camera flash, and I'll get the sodium pentathol...

Re:He probably

[MountainLogic]

Just a thought, cMicrosoft wanted cSimonyi very bad at the time they hired him. They may have cut him a deal in his hiring contract on the IP. Especially as he brought alot in when he hired on.

Re:He probably

[Salamander]

He didn't work on the business side of the company. He was a hard core geek, thinks, codes, and collects a check.

...all of which means precisely nothing. Nada. Zilch. Top-level (and often even mid-level) technical staff sign the exact same employee agreement as the business-side folks, and the part about "all your patents are belong to us" is there specifically for them. Dr. Simonyi might indeed have had some extra-special agreement, but if so it's because he's Simonyi and not because he's a geek instead of a suit.

Re:He probably

[Anonymous Coward]

Patents have both inventors and owners, with only the latter really meaning anything legally

Sorry to nit pick on one detail, but:

If the inventor(s) are not listed correctly (if an individual contributed toward the invention but was not listed as an inventor on the patent) then the patent can be invalidated.

So the inventor designation does have legal ramifications on a patent.

Re:He probably

[verbatim]

You forgot the end of the sentance:

'Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.'

Last time I checked, works for hire belong to the company - not the employee. This is generous of Micro$oft. It gets to that sticky area that when you develop something, even in your spare time, there is a chance that the company you work for can claim it (they have first 'dibs' on it). There are a lot of instances where companies sue the pants of employees when they try to do this.

Then again, Microsoft may let him go now and come after him later - let him turn it into a success and then claim it was a work-for-hire later.

It's why 'freelance' open-source developers should be careful to make sure their current (and any future) employer won't snatch away their work.

Re:He probably

[Salamander]

It is indeed possible that Dr. Simonyi had such a special arrangement, but he doesn't just get rights to the ideas because he developed them (what this post's great-grandparent seems to assume). Exclusive ownership of intellectual property by the employer rather than the actual inventor is so commonplace that it's the exceptions which are noteworthy.

Re:He probably

[Salamander]

Point taken, and thanks for the info. I hope some kind moderator will take a break from glue-sniffing long enough to mod that up.

Re:He probably

[verbatim]

lol. I was going to include that as an example but chickened out at the last moment.

Re:He probably

[MountainLogic]

Of course. Today it's called work for hire .

Re:He probably

[Drachemorder]

That's why you never, EVER let your employer know anything about anything you do that isn't done explicitly for their business if you can at all help it.

What they don't know can't hurt you.

Re:He probably

[MrResistor]

My comment was based entirely on the wording of the quote from the article, specifically "intellectual property he developed and patented", which seems to indicate that Simonyi has some claim to ownership of those patents.

I am very much aware of common industry practice. I am equally aware that there is an exception to every rule, a concept you still seem to be struggling with. I was merely trying to present the possibility that this may, in fact, be one of those rare exceptions, a possibility that is not entirely unlikely given someone of Simonyi's calibre.

Re:He probably

[MrResistor]

Nope, GPL covers copyright. Patents fall under completely different rules. The GPL (or similar license) would be totally ineffectual in the patent arena.

Re:He probably

[MrResistor]

Last time I checked, works for hire belong to the company - not the employee.

You are correct in the general sense, but only because that's a clause written into most employment contracts. There is no law that says things work that way.

If you have the clout to renegotiate those clauses, as I beleive Dr Simonyi would have had at the time he was hired, It is entirely possible for you to retain the rights to any IP you create.

Re:He probably

[kribor]

Not so fast there. There is a lawsuit going on right now over just such an issue. The std agreement covers any intellectual property developed by the employee during his tenure, unless such work is disclosed and excluded from the agreement at the start of employment.

Re:He probably

[Zeinfeld]

If they are his patents there's likely very little MS can do about it, except maybe try to sue him into oblivion, which is where the blackmail material would come in handy.

There is plenty Microsoft could do. However Microsoft tends to behave as a rational actor.

The release does not discuss the funding of the new venture but I would not be at all suprised if Gates, Balmer, Microsoft were investors. If so providing access to IP is not suprising.

I would not be suprised if there was not some sort of reciprocal IP agreement so Microsoft can use IP developed by the new company.

It is unlikely that the new company is going to grow so big that it puts Microsoft in the poor house. On the other hand they can probably buy it if it does lok like it has a winner.

Companies like Microsoft tend to find it very hard to get existing sales and marketing organizations to accept a new product that might canibalize an existing market (see Christiansen's Inovator's dilema). It is actually more effective to buy in R&D even at what appears to be a ludicrous premium over the cost of building from scratch.

Take Vermeer as an example, it is very unlikely that they would ever have made $180 mil in sales let alone profit. Microsoft has earned many times that from distributing their product, Frontpage through their existing channels.

Re:He probably

[Anonymous Coward]

It seems that nobody replying in this thread seems to know anything about what they're talking about.

Charles Simonyi was one of the original four MS employees. He was with Gates, Allen, and Ballmer from the beginning. He hired & led the teams that developed Microsoft's office applications (Word, Excel, etc.). Since the early '90s he has been leading a team of researchers working on Intentional Programming, a new approach to building programs that's still about 10 years ahead of its time (I suggest you read up on it). As far as I understand it, he's leaving Microsoft because the company is no longer interested in spending a lot of R&D money on something that is still too far from marketability.

He's not walking away with IP rights to Word et. al. He's retaining his rights to the work on Intentional Programming, including a bunch of patents. And the reason why he's allowed to retain those IP rights has nothing to do with threats to expose MS business practices. Like I said, the guy is one of the original 4, and he still owns billions in MS stock. He's allowed to take his work on Intentional Programming with him because of his special status and relationship with Gates & Ballmer and because the company is not going to continue pursuing that line of research anyway.

Can we get over the conspiracy theories now?

Re:He probably

[Jon_E]

right on - you may want to check out the story in the Bellevue Eastide Journal for more depth - it sounds like he and Bill worked out a deal where MS has first dibs on whatever they produce since they both determined that MS wasn't ready for Intentional Programming .. makes sense - I've always seen Microsoft's strengths in unintentional random programming and pointless garden-pathed eye candy.

Re:He probably

[stephanruby]

He probably threathened to reveal some rather embarassing details about how Microsoft has abused it's market power if they didn't give it to him.

Or he negotiated his contract before he was hired by Microsoft. By the time he was hired by Microsoft, he was already a Star at Xerox PARC, so he had the leverage.

On a side note, I read an excellent book on negotiation recently. It's called "Start with No" by Jim Camp. Its first edition just came out on July 2002 and I found it much better than the "Getting to Yes" negotiation book.

Hungarian notation?

[Anonymous Coward]

I always prefered Reverse Polish myself.

Re:Hungarian notation?

[jd142]

Could you give a longer example of RPN? I can't see the difference between:

6
enter
12
+

and

6
+
12
enter

In both cases I press 5 keys, "6", "+", "1", "2", and "enter" it is only the order that changes. And I can't think of an example of how it would work to save keypresses.

Re:Hungarian notation?

[dpilot]

Others have given examples, but here's the core:

Reverse Polish Notation calculators are really stack machines, and the stack is exposed to the user. On an RPN calculator, operations are generally done between the Top Of Stack and the Next On Stack, leaving the answer on TOS. The Enter key pushes TOS to NOS, but also delimits so you can type another number.

So in the simple example given:
6 - TOS=6 NOS=??
Enter - TOS=6 NOS=6
12 - TOS=12 NOS=6
+ - TOS=18 NOS=??

The stacks in HP calculators were (don't know if this has changed) 4 deep, and that was generally enough. There is a key to exchange TOS and NOS, and a Roll key to roll the whole stack.

Back when RPN got its foothold in the calculator business, algebraic calculators were handling parenthesis poorly, if at all. Some had a single parenthesis, some had one level of nested parenthesis. RPN avoided the issue, by making the user think differently.

Re:Hungarian notation?

[Dannon]

The only time I ever used RPN routinely was on my old HP calculator, using the 'stack'... and I remember it being darned useful for doing multi-step calculations where I wanted to double-check the 'result' at each step. For example, just pulling numbers out of nowhere:

log(((1223+423)*(3897-13))/2)

would be:

1223
423 + (display: 1646)
3897
13 - (display: 1646, 3884)
* (display: 6393064)
2 / (display: 3196532)
log (display: 6.504....)

But then, the screen got smashed in my bookbag. Darned cloth case. After that, I got a TI-92, just for the solid cover. And impressive 3d graphing.

Re:Hungarian notation?

[JWW]

Me too, seriously.

Re:Hungarian notation?

[laserjet]

Sure. Say you want to do the following calculation on (1) an HP 48G calc, and (2) a TI-8x calc:

(3+4)^2 + (9-2)^2 + 7

On a TI, You enter :
{,3,+,4,),^,2,+,(,9,-,2,),^,2,+,7,[Enter]
---- -18 keys.-----

On a HP calc, you could enter:
3,[space],4,+,2,^,9,[space],2,-,2,^,7,+
- ----14 keys.-----

Of course, magnify this in a larger problem and you can see that it is a bit quicker. It doesn't matter really, but I prefer RPN because it follows more how I think.

Re:Hungarian notation?

[sporty]

You mean "too me".

Liar :)

Re:Hungarian notation?

[NortWind]

Could you give a longer example of RPN? I can't see the difference...

In RPN, the operation requested is done *when* you press the button. With algebraic, the requested operation is done "at some later time". You don't need to memorize any rules of precedence with RPN, what you push is what you get.

Re:Hungarian notation?

[edremy]

The stacks in HP calculators were (don't know if this has changed) 4 deep, and that was generally enough.

It has changed: basically the new ones[1] have a stack that's as deep as the memory on the machines. Generally, there's not much need for more than 5 or 6 deep unless you're doing serious programming.

[1]Of course, there are no new ones. Thank you Carly for once again proving you don't know jack about HP.

Let's hope...

[Washizu]

Let's hope he isn't allowed to take Clippy the animated paper clip with him. die Clippy die.

Re:Let's hope...

[Washizu]

Clippy lives on in the machines of millions of unsupported Office 97 users.

Re:Let's hope...

[krammit]

Obligatory Simpsons reference:

"I don't want to kill Clippy."
"Then why did you write 'die clippy die'"
"No, that's German. It's 'the clippy the'"

Re:Let's hope...

[Tablizer]

Clippy is being replaced by Jar Jar: "mesa think you need help"

He he, mod up!

Go all the way, make a Jar Jar OS. It would be the conversation peice of every geek in town. You have to open all your files and programs by happy clumsy accident. "Bumpy pokey, Oh looky looky, me find porn."

The "Annoyance" routines could be reused later for the Wesly Crusher OS.

Re:Let's hope...

[AJWM]

Call me a 'troll' a million times, but you *still* lack decent evidence OOP is objectively better

Nonsense. Of course OOP is objectively better. What, you think FP is functionally superior? ;)

Grab him!

[n2dasun]

Quick, get him to work on OpenOffice!

Re:Grab him!

[goldspider]

Sorry, I'm pretty sure he'd want to be paid for his time, expertise, etc. I suspect that the lingering evil effects from working for Microsoft would include the desire to be fairly compensated to support himself and his family.

Re:Grab him!

[Computer!]

You're right, the Open Source community is much better at playing catch-up than innovating anyway.

Re:Grab him!

[n2dasun]

Maybe he is someone with good talents/ideas who had to conform to hold the job he was in

Re:Grab him!

[n2dasun]

Hmm. My tags got used as html, somehow. Anyway, as i posted:

<devil's advocate>Maybe he is someone with good talents/ideas who had to conform to hold his job</devil's advocate>

Fleeing the ship

[doublem]

And the Smart Rats are fleeing the ship. I wonder what he knows that we don't know.

Re:Fleeing the ship

[Anonymous Coward]

I'm sure he is a millionaire many times over and probalbly still holds loads of MSFT shares.

Maybe he just wants a change of scenery, get a chance to lead his own group.

Re:Fleeing the ship

[john82]

He knows where the bodies are buried. Think of all that has occured at MS that he might be privy to. Anyone else leave MS lately and been allowed to take their brain with them?

"Let me take my IP with me Bill, or I'll rat you out for all the stuff MS has pulled over the years."

Re:Fleeing the ship

[AdamBa]

Actually he's a billionaire according to the latest Forbes (or was it Fortune?) richest Americans list.

- adam

Re:Fleeing the ship

[targo]

Oh give me a break.
1) The guy had been working for Microsoft for 21 years (how long have you worked anywhere?)
2) He's a billionaire (how much money do you have?)

These are perfectly good reasons to move on and try something different. In fact, most people in the industry switch companies much, much more often, so this is actually a rather positive sign for Microsoft (that people are staying for so long).

Re:Fleeing the ship

[Melantha_Bacchae]

doublem wrote:

And the Smart Rats are fleeing the ship. I wonder what he knows that we don't know.

Microsoft's biggest foe is coming to Redmond town. All three of him. And he's bringing a *lot* of very large friends.

The X-box doesn't stand a chance!

The god that saved Nintendo from Microsoft's jaws in December 1999 is coming to defend his old friend.

Godzilla Destroy All Monsters Melee

October 29, 2002
GameCube and GameBoy Advance

I'm going to play Godzilla and beat the stuffings out of Orga/Millenium/Microsoft! ;)

If you can't wait that long, the Godzilla Ultimate Collection (Godzilla, Godzilla vs. Mothra (1964), Godzilla's Revenge, Terror of MechaGodzilla, and Rodan) was released on DVD today by Sony Tristar.

His power is unequalled.
His battles are legendary.
His return is near...
Godzilla 2000
If you can't take the heat, RUN!

From the "Godzilla 2000" trailer Tristar tried so hard to hide.

MS Word Competitor in the works?

[FortKnox]

Makes you wonder what he'll be shooting for? A cheaper, compatible MS Word competitor?

And a word on hungarian notation. It makes me want to puke. Your variables should be named well enough that it shouldn't need extra letters to tell you the type.

Re:MS Word Competitor in the works?

[zog karndon]

Well, I suspect that he's going to finally finish his (long-term) development project for Intentional Programming, much as the article said. Intentional Programming is an interesting approach to development, where your source isn't represented as a text file, but as a tree & set of transforms. When I saw a presentation about 8 years ago, it was quite reminiscent of a Lisp system with programmable unparsers to render the source tree (it's NOT a flat representation) in almost any source language you chose (e.g., Pascal, C, C++, or VB). It will be interesting to see where it has gone since then.

Re:MS Word Competitor in the works?

[Tet]

And a word on hungarian notation. It makes me want to puke. Your variables should be named well enough that it shouldn't need extra letters to tell you the type.

More to the point, the compiler will tell you when you've got the type wrong anyway. Hungarian notation is completely unnecessary, and (IMHO, of course) those who claim it makes for easier reading need their heads examined. It serves no purpose, and for that reason alone, shouldn't be used...

Re:MS Word Competitor in the works?

[sv0f]

Well, I suspect that he's going to finally finish his (long-term) development project for Intentional Programming, much as the article said.

Agreed. The other big guy at the company is Gregor Kiczales, the guy behind metaobject protocols and aspect-oriented programming. The latter is definitely a cousin of intentional programming.

When I saw a presentation about 8 years ago, it was quite reminiscent of a Lisp system with programmable unparsers to render the source tree (it's NOT a flat representation) in almost any source language you chose (e.g., Pascal, C, C++, or VB).

Well, if Lisp is consigned to the programming language ghetto, at least Lispers (like Kiczales) keep trying to educate the unwashed masses.

Hope he checks out IBM

[ToasterTester]

IBM has done a lot of experimentation on developemnt systems along these lines. They never caught on. I remember seeing IBM demos trying to create development systems that anyone could drag and drop their own programs together.

Re:Hope he checks out IBM

[FunkyELF]

Lego Mindstorms lets you drag and drop programs together :)

Re:Hope he checks out IBM

[wolverine1999]

One of the early ones in the 80's was called THE LAST WORD. I remember reading about it in PCW.

Re:Hope he checks out IBM

[vlad_petric]

I remember seeing IBM demos trying to create development systems that anyone could drag and drop their own programs together.

I agree with you that they indeed *tried* to do that, but they ended up with a system (Visual Age) that was in fact a lot harder to use than a traditional "notepad-style" environment.

Not everybody can do programming, it requires a special kind of imperative, cause-effect type of thinking. Such visual tools will (maybe) manage to make one aspect of programming easier, but I don't think they'll ever manage to make the whole easier enough so that aunt Tillie could do, let's say, her own custom expense manager. And the reason lies in the fact that most software projects are unique in at least one aspect. This uniqueness in most cases requires a Turing-complete programmer.

Visual Age was eventually replaced by Eclipse which is, in terms of the programming interface, as standard as you can get.

The Raven

Re:Hope he checks out IBM

[ReelOddeeo]

One of the early ones in the 80's was called THE LAST WORD. I remember reading about it in PCW.

Perhaps you mean THE LAST ONE.

They ran big ads for it for months in major computer rags. It promised the sky. The end of programming as we know it. Comming next summer.

It sure generated a buzz. But when it finally came out and both humans and review writers got hold of it, the buzz turned out to be a real fizzle. Your local library probably has magazine archives from the period.

Re:Hope he checks out IBM

[stephanruby]

IBM has done a lot of experimentation on developemnt systems along these lines.

I believe SmallTalk-71 already had some of those drag-and-drop programming capabilities and Xerox PARC released SmallTalk-80 to IBM sometimes in the 70s.

Re:Hope he checks out IBM

[ShawnD]

I remember seeing IBM demos trying to create development systems that anyone could drag and drop their own programs together.

Commodore tried too. Anyone else remember AmigaVision. This was a flowchart based language for the Amiga intended for doing Multimedia presentations.

It had all the normal programming stuff, plus the ability to display animations, images, play music and sound, control a LaserDisc player (that dates it) and work with dBase III files. Here is a screenshot I took with a simple program (Probably wrong since I just threw down some icons and never tried to run it.). And yet that hideous red thing at the bottom is the mouse pointer. I think it is supposed to be an A.

Re:Hope he checks out IBM

[MR_Flaimbait]

Lego Mindstorms programming interface is actually a special hacked down version of Labview. Catch 'em while their young.

Re:Hope he checks out IBM

[LegendLength]

I've done a couple of years of (home) experimentation also. I had a few different approaches, 3d objects with links between them, structured grids and other things.

It always came down to links between objects being too complicated to look at and comprehend.

I'm sure someone will make a good visual system one day though.

Re:Hope he checks out IBM

[Shirotae]

Perhaps you mean THE LAST ONE.

I remember that! We used to joke that version 2 would be called THE NEXT ONE.

I hate Word because it imposes its fixed ideas of how I ought to work, and makes it very hard for me to work in the way that suits me. It is just about adequate for trivial documents like business letters, but is hopeless for anything serious. Some so-called high-level programming tools have the same characteristic - if your problem is within the space they are designed for they can get a result quickly, but for problems outside that space, they are a total disaster.

If some new programming system has the same characteristics, then those who see only the trivial problems will love it, and, if they are foolish, impose it on those who are working on serious large scale projects. Those who have superior tools that they are prohibited from using will be blamed for the resulting mess, and once again anyone who speaks up saying anything sensible will be branded a troublemaker.

Re:Hope he checks out IBM

[dmelomed]

iMATIX has an interesting system called Libero. Libero is used to build a state machine. Similar to a flow chart. After you're done, it generates everything but the code used in states. You then write state code. According to iMATIX, it saves you from writing spaghetti code, and is great for large/complex problems.

http://www.imatix.com/html/libero/

WTF?

[Picass0]

"Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there."

????!!!!!Errrrr??????

(conspiracy) Something seems to be going on here.(/conspiracy)

Re:WTF?

[Neumann]

If you read the article you would know that Microsoft gets first dibs to buy the company if he creates something useful and then puts it up for sale.

This is a great strategy: If he creates a great new product, buy him out. If he crashes and burns, you didnt lose anything.

Re:WTF?

[Aknaton]

Well, what if he sells the technology but not the company?

Hungarian Notation

[Art_XIV]

Even Hungarian Notation is a big improvement over having no naming conventions at all.

Re:Hungarian Notation

[TheSunborn]

yes, and using Dos is a big improvement over not having an operation system at all, but that don't mean that we should use Dos.

Re:Hungarian Notation

[Numeric]

That is true. Look at the Slashdot's username, they use PascalCase or camelCase naming conventions that were based on his ideas of Hungarian Notation.

Anyway, I had to research "naming conventations" so I of course I came across his name.

Re:Hungarian Notation

[jawtheshark]

Well it all depends on how you see it. Ever had to change an int to a long in a very very huge program? That's kind of a big search 'n replace. Besides I really think that it makes code unreadable... If I don't know what type a variable is, I prefer to look up the declaration. But then I just probably am a bad programmer.
Just name the var what it is supposed to represent. If it is representing an age, call it "age" and not "iAge". Just my opinion.

Re:Hungarian Notation

[God! Awful]

Even Hungarian Notation is a big improvement over having no naming conventions at all.

To all the die-hard C programmers who refuse to make the Linux kernel C++ compatible because they are using variable names such as "new", let me point out that this wouldn't be a problem if you had called the variable nNew, gNew, new_p, or any kind of mangled name at all.

Sometimes the key is just to have a structure, and it doesn't matter what the structure is.

-a

Re:Hungarian Notation

[peterpi]

Not if your code is readable enough in the first place.

If it's so difficult to figure out the type of your variables, then you really are in deep crap, and sticking a few characters in front is not going to cure the underlying cause.

I had to interface with DirectInput once (which uses hungarian notation) and it very nearly killed me.

Re:Hungarian Notation

[Peyna]

iAge tells you how that age is represented. If I saw a variable called 'age' I wouldn't have a clue what the type was. It could be string for all I know. Not everything is as obvious to everyone else as it is to you. You should code so that you and a person who just picked up the code off the street (and knows how to code that language) are both able to understand it without difficulty. Easier said than done.

Re:Hungarian Notation

[jcr]

To all the die-hard C programmers who refuse to make the Linux kernel C++ compatible because they are using variable names such as "new", let me point out that this wouldn't be a problem if you had called the variable nNew, gNew, new_p, or any kind of mangled name at all.

Let me just point out that C++ is not a feature.

-jcr

Re:Hungarian Notation

[AJWM]

iAge tells you how that age is represented.

Which is exactly what's wrong with it, unless you're programming in assembler. Programming in higher level languages (yeah, some would debate that C qualifies here) is all about abstraction.

Besides which, "iAge" doesn't tell you anything useful about how that age is represented -- is that number in years? months? days? hours? centuries? Depending on the underlying application (are we talking about adults, infants, bacterial cultures, archaeological relics?) it could be any of the above. That's the danger of Hungarian notation -- it gives the illusion of conveying information when it doesn't really.

Anyway, for all you know, a month ago somebody decided they needed to redeclare "iAge" to "unsigned short" and was too lazy to rename the variable in 32,178 lines of code. The compiler sure doesn't enforce it.

Re:Hungarian Notation

[gmack]

If it's not easy to see at first glance the original coder messed up.

Hungarian notation simply bandaids over otherwise unreadable code. It's *not* a proper fix

Re:Hungarian Notation

[SlashDotterX]

...Wow, this is kinda weird! I started using something *very* similar to this after my first year at uni 'cause I got sick of scrolling up to the top of my code because I'd forgotten the 'type' of a particular variable - for example, calling a JComboBox called CustomerTitle, jcbCustomerTitle. I didn't know it was any kind of established method (although someone might have mentioned something about it when they told me about Steve McConnell's book "Code Complete"). Wow, I feel vindicated now!

Re:Hungarian Notation

[Sabu mark]

iAge tells you how that age is represented. If I saw a variable called 'age' I wouldn't have a clue what the type was. It could be string for all I know. Not everything is as obvious to everyone else as it is to you.

Yeah, that would be a big problem if you couldn't be bothered just to read the declaration:

unsigned short age;

Hmm, what could age be? A string? An array of doubles? How confusing! Better name it unsigned_short_integer_representing_someones_age to be sure. Not everything is as obviouus to everyone else as it is to me.

Re:Hungarian Notation

[Nick of NSTime]

In my Visual Basic and QuickBasic days, I used type declaration characters. $ was string, & was long, % was something else, ! was single, I can't remember the rest.

Re:Hungarian Notation

[Thornkin]

I agree that Hungarian is not very useful today. You have to remember though that it was invented more than a decade (2 decades?) ago when compilers weren't what we have now. When the K&R-style C compiler didn't have strong typing, Hungarian was quite useful. Nowadays your compiler will catch your errors and warn you but back then it didn't.

Re:Hungarian Notation

[2short]

"Ever had to change an int to a long in a very very huge program? That's kind of a big search 'n replace"

Yes I have, and yes, I suppose it was a really big search and replace. I think it took the machine a a full three seconds. man that sucked.

Seriously though what the hell difference does the size of the search and replace make? Thats what computers are for.

Re:Hungarian Notation

[overshoot]

Hungarian Notation (with the embedding of C-language typing welded to all of the data in the system) is one of the main reasons that Microsoft had such an ugly time going from 16- to 32-bits and why MSWindows still isn't 64-bit clean.

Re:Hungarian Notation

[gmack]

"Isn't this backwards? Hungarian notation is meant to make readable and easily reuseable code. If somebody starts using a different convention halfway through a project then I feel bad for the programmers because this doesn't make sense."

Where exactly does it help?

If it's mid code the defintion shouldn't be more than a screen away. If not, the function is simply too large.

It's not function calling because your reading the variable off the definition anyhow and if that's not sufficiant then there should be a comment explaining what it needs.

It simply doesn't help unless youve broken some other rule for creating readable code.

I've never had a problem dealing with changing conventions when the rest of the code was well written.

Re:Hungarian Notation

[Bizaff]

Yeesh, people are always turning this into some kind of stupid holy war. It's a tool, just like anything else.

We've used hungarian notation for a couple years where I work, and believe it adds value. Everyone hated it at first, but it sure helps you when you're wondering why looping your BYTE variable from 0 to 300 doesn't work.

Some people may not need to know base types for certain things, but in the embedded world it comes in handy. You can't necessarily make everything an int, when a char will do.

Pick tools that will help you and don't use ones you don't want to. It doesn't make much sense to bash them simply because you choose not to see or try to use the value they provide.

Re:Hungarian Notation

[2short]

And when the "age" is a member of a base class so the declaration is not even in the same file?m_uAgeInYears please. (I think age should be unsigned, but I don't care if the naming convention tells me it's a short)
Naming conventions are good things.

Re:Hungarian Notation

[2short]

"If it's mid code the defintion shouldn't be more than a screen away. If not, the function is simply too large."

Member variable. Base class. Declaration is in a different file.

Re:Hungarian Notation

[Peyna]

Naming conventions are great, just keep the same throughout a project and you can use whatever you want to. I refuse to look at any code with variables named after your cats.

Re:Hungarian Notation

[Leimy]

So apparently religious feelings about a programming language are now deemed insightful on slashdot.... interesting.

Re:Hungarian Notation

[mccabem]

If a piece of software is written in C++, then C++ happens to be a feature of that software.

Now machine language could not be considered a feature, as that is what is *really* the true nature of the program.

Get it?

Re:Hungarian Notation

[tauntalum]

My IDE shows me the type of my variable when I wave my magic cursor over it... It's important to have a meaningful name, but these prefixes are a pain in the ass and add very little value if all they are doing is indicating the type...

Re:Hungarian Notation

[dpt]

To all the die-hard C programmers who refuse to make the Linux kernel C++ compatible because they are using variable names such as "new"

It's because the kernel is written in C, not C++. They are two different languages. There is no such language as "C/C++".

I will use public, new, and private as much as I like in C. This will only get worse with C99, which thankfully diverges completely in many ways from C++, so that the whole "C is a subset of C++" rubbish is now officially dead. It never was true, but now it's easier to explain to the slow and lazy.

Re:Hungarian Notation

[ClosedSource]

The real problem is documentation, in particular for public interfaces. Windows lParam and wParam used to be different sizes but now they're the same. MS decided it was better to cheat on Hungarian Notation than it was to invalidate all the existing Windows documentation.

Re:Hungarian Notation

[ClosedSource]

"If, on the other hand, you're a serious programmer, working on software that is literally millions of lines long, you're not going to have time to run through searching for declarations every time you want to use an existing variable."

Well, if you have to look through a lot of code to find a declaration, than you must be talking about global variables which hopefully are few and far between if the code is modular or object-oriented. If the variable name is descriptive, it should be fairly obvious what can be combined and what can't. In any case, most language compilers will complain if their is a type mismatch.

Re:Hungarian Notation

[ClosedSource]

Naming conventions are overrated. The only rule I follow is that the name should describe what the variable represents. I don't try to embed the type, or the subsystem name or other relationships into the name. All of these things are subject to change and can create maintenance problems.

Naming conventions are also a great way to participate in code reviews without contributing anything to the quality of the code. Reviewers can look for non-compliance in variable names instead of looking for errors in logic.

Re:Hungarian Notation

[God! Awful]

To all you idiot language designers, let me point out that if you had not stolen common identifiers and turned them into reserved keywords, then variable names like "new" would not cause problems.

Not using common words as function/variable names is just common sense. God forbid you name a function open() and then you later need to link in the socket library.

-a

Re:Hungarian Notation

[jcr]

So apparently religious feelings about a programming language are now deemed insightful on slashdot.... interesting.

Well, for dismissing my opinion of C++ as a "religious feeling", fuck you too!

As it happens, my opinion of C++ is based on years of painful experience, followed by the relief that came from abandoning it in favor of languages that were designed, not accreted.

-jcr

Re:Hungarian Notation

[andr0meda]

It's quite the opposite realy.

You know what one of the first rules of refactoring is ? (as chaning a type is in effect a refactoring operation, be it a very small one)

It's "renaming". Here's why:

If you rewrite 'int iAge' into 'float fAge', the rest of the code does no longer compile correctly. So in effect, the hungarian notation helps you keep the code correct, as you have to look up those places where the varaible name has changed. This way you might spot type casts that would otherwise give incorrect results. It might not be imoprtnat for basic types, but for objects in an inheritance tree with e.g. operator overloading, I assure you, it helps ! :) (ok, operator overloading is bad practice, but that's besides the point)

It's particularly usefull to mark wheather a variable is a local varaible or parameter, a member of a class, or a static global. Usually in methods, the name of a parameter is practically the same as the member contained in the class (e.g. get/set methods). If you mark the members with a prefixed 'm_', you do not have to invent stupid names to make the difference between the parameter and the member, and it will be clear to everyone who reads you code where that varaible is declared, and what it's lifetime is. This again avoids typical but avoidable debug frustration. :)

I think it's very usefull, even today. All those fancy overview class windows and inspectors are nice but if you're looking at code, you want to be able to quickly see what's going on, and clarity is a key factor in that.

Re:Hungarian Notation

[jawtheshark]

I knew you were going to reply this. Oh, well... you know as well as me that I didn't write C or C++ in ages. Anyway, I still find it visually ugly and I like beauty (you knew that didn't you?). The worst kind is actually when using Hungarian on objects, how I loathe btnOk..urks... worse are when people use it on custom-made objects. Seen ostdlfinscapStartdate, which means "Object Life Insurance Standard Capitalisation". Yes, and I actually saw this in *Java* code. You think that is readable? Well, I don't.
Besides, aren't dangerous typecasts now warnings in C/C++? I hate warnings so much that I always make sure there are no more warnings in any of my code. So technically I still would get warned.

Oh, well... be glad you don't have to maintain my code but I sure as hell won't be using Hungarian anytime soon.

Re:Hungarian Notation

[2short]

You really find yourself changing the type of a variable used in hundreds of files???? For that matter, you have a variable used in hundreds of files???? Nice encapsulation!

Re:Hungarian Notation

[andr0meda]

Well those tings look ugly, I won't contend that :)

I would probably rename 'btnOk' to 'ButtonOK' if it's an object. I prefer long readable names as opposed to short hashed ones, since nme completion does all the searching for you these days, that can not be the problem. Readable code comes from readable words n the first place, type info only helps to clarify the underlying mechanics of the semantics.

And yes, dangerous type casts allways have been warnings in c++. It's the typecasts that aren't dangerous, like implicit conversions in operators, that might give rise to unexpected behavior. Depending on your compiler, they show, or they just don't.

Did you know I allways wrote 'behaviour' instead of 'behavior'? Funny..


Oh, well... be glad you don't have to maintain my code but I sure as hell won't be using Hungarian anytime soon.


Haha. You know, I don't maintain code tout-court. ;)

I'll shut up now..

Re:Hungarian Notation

[prisonernumber7]

Does the following not tell you exactly what type age is? Other than being senseless, I guess anybody sees what the following method does. This principle applies in general because methods/functions should be short, pregnant, tidy and most of all obvious. Anything else is bad design.

/**
* isToBeRetired - Check whether a person is to be
* retired due to their age.
* @param age The person's age.
* @return true If the person is to be retired.
*/

bool isToBeRetired( unsigned char age )
{
return ( age > 64 );
}

Registration-free link

[Spy Hunter]

Registration-free link courtesy of asahi.com/english/nyt

Re:Registration-free link

[Anonymous Coward]

er the link in the article doesn't require registration.....

programming

[ktulus cry]

Forgive me, but how does one code without text syntax?

Re:programming

[Waffle Iron]

Forgive me, but how does one code without text syntax?

You must be too young to have ever seen a flowchart.

Re:programming

[e2d2]

It would most likely be a visual medium, meaning you compose applications using visual models to represent your logic. If you need to create a class you could drag a class model onto your application. I doubt anyone could truly get away from ANY text implementation though - how does one provide the actions and properties of a type without using text based compiling? It will be interesting to see what they come up with.

This has been done before but has not been very successful, depending on how you measure that success, but it has not taken off. I remember specifically seeing one new .Net IDE that allowed one to create a application using visual models, just can't remember the name. They had a contest on the back of some developer magazines challenging users to create an example app using their tool to win a prize (back of Dobbs maybe?). Anyone know the name?

Re:programming

[Eccles]

Macromedia's Authorware is an example of an icon-based "programming" language.

Re:programming

[Twister002]

The BizTalk servers use Visio to do this I believe.

They allow you to define objects, then create relationships between objects w/o having to code is that what you are thinking about?

Ever heard of LabView?

[Anonymous Coward]

There's a programming language called LabView (http://www.labview.com). Programs in this language aren't textual but rather lke graphical machines that you can easily visual the data flow through. This doesn't ultimately make programming necessarily easier though... scientists without CS degrees that still want to program their scientific instruments just often happen to have an easier time visualising LabView programs, that's all.

Re:Ever heard of LabView?

[redbeard_ak]

In Grad school I used LabView to program a lot of data acquisition and even some control (it was kinda scary using a Mac Quadra to digitally control a $50,000 hydraulic press). This was obviously some time ago. I think the two advantages of Labview were the visualization (as you stated) and of obliviating the need to remember arcane syntax (I was programming fortan prior to that... shiver). Today toys like visual studio catch most of my syntax errors, leaving me free to make others. I still think some programming experience is required to get the most out of labview - you still need to know programming structures (comparisons, loops, etc). Its just a shorter trip from flowchart to program.

Re:Ever heard of LabView?

[jaoswald]

Yeah, I've heard of LabView. As a programmer, I hated it (caveat: this was 1995).

The thing that hooks you onto LabView is you've got a bunch of test equipment that you want to automate. National Instruments has a HUGE list of "virtual" instruments that match the ones on your bench. Great, you say: these modules will be just the thing, and I'll be done in no time at all, because they've done all the work. WRONG.

The main feature of the NI VIs was that they could reproduce, on your computer screen, a GUI version of the front panel of the test equipment. (The other trend was to sell you a piece of test equipment that plugged into an expansion slot of your PC or an external chassis, and had a GUI instead of a front panel, but that is a separate topic.)

Well, big f**king deal. If I wanted to click an button-shaped icon on a GUI all day, I would have stuck with pushing the real button on the front panel. I want to write a PROGRAM, i.e., something more abstract than pressing the button.

The only real abstraction that LabView provided was a block which could have dataflow "wires" connected to the terminals. Once there were more than four terminals (think, function parameters), it became impossible to keep the wires neat, or keep straight which terminal was which.

Plus, the blocks were either ridiculously low-level (a GPIB command or two) or ridiculously baroque (a series of GPIB commands, with input wires for every possible setting of the instrument). I often had to resort to looking at the source, reading the GPIB sequences, then reading the instrument manual to translate into English.

Any kind of structured programming, other than blocks (functions) required some hokey GUI expression, often involving multiple-page (like tabs in a modern dialog box) displays. By design, you couldn't see the multiple branches of a case statement at the same time. Plus, the need to keep sane wiring meant that these pages kept growing to hold the most complex case, so programs of any sophistication became huge.

Forget it. I ended up writing my data collection code in a bastardized Pascal-like language supported by my data analysis program (Igor Pro). That was gross, but at least I could write a for loop without going insane, and I got a decent graphing environment.

Re:Ever heard of LabView?

[Mr. Frilly]

Gotta agree with you on this. I spent two years working with labview circa 1997. It's really easy to get a small program up and running in labifew, and it's really a great environment for rapidly developing data acquisition software.

The problem comes in when you try to write either a large program, or a program that involves more then data acquisition/data analysis. For the later, you no longer have a good collection of pre-designed blocks for what your doing. For the former, every time you want to insert new code, you wind up spending time moving wires and blocks around to make space on the screen for the new code. Extending on existing code rapidly becomes a gui nightmare.

That being said, if you restrict labview to uses for which it was really designed for, it can be an extremely useful tool.

Re:Ever heard of LabView?

[lavezza]

My job requires me to program in LabVIEW. National Instruments (makers of LabVIEW) has added a lot of high level functions that allow me to do things that my German counterparts (multi-national company) need 5x more time to complete in C or C++.

I agree that many programmers don't like the visual data-flow method of programming. But LabVIEW has always been geared toward engineers and scientists, not compsci grads. I don't think any LabVIEW user would claim that LV completes with C or C++ for general app development (don't try to program a LabVIEW spreadsheet, even if it is technically possible)

The biggest advantage for someone like me is being able to see how the data flows. Also, LabVIEW is interactive, place stops and data probes while the program is running.

For programs involving data acquisition and presentation, LabVIEW is a lifesaver (provided your equipment has LabVIEW drivers, or you have rolled your own.)

Then again, everyone should use the tool that allows him or her to most productively attack a problem. I can solve DAQ problems quickly in LabVIEW. My German friends are starting to solve new problems in LabVIEW (one C holdout :). If you are more productive in another language and can still solve the problem, go for it.

Re:Ever heard of LabView?

[lavezza]

I agree. However, things have changed since the LabVIEW 4 days.

Non-DAQ apps: I know you weren't knocking LV, but it's important that everyone knows that is all LV is targeting. Some people say LV sucks because it can't do everything C can. Well, neither can Javascript, and I don't want to use a compiler written in Perl. It is a great tool for its domain. That said, a lot of new LV features are actually written in LV. NI has said (jokingly) that they are close to being able to rewrite LV in LV. I wouldn't be surprised.

Large Programs: A lot of problems result from not using best practices. Part of the blame is that LV is so easy to get up and running. Programmers never learn the correct way to do things. I've been doing LV for 5 years and I'm just getting really good. Some companies have very large programs written in LabVIEW. Our largest had over 200 user panels (windows) that accessed over 4000 channels of data. I know of larger.

Re:Ever heard of LabView?

[gte910h]

Still shitty as hell in 2002. I had to use it to do some data aquisition and control this spring. After about 2 months of messing with the system, one day I realized that I could do it all with commands over the GPIB bus, commands to write out to a text file, and a VBA script. I was never so happy to write VB in my life.

Its hopeless trying to debug deeply nested programs with it, and its really difficult to express some control structures clearly or at all.

Paper clip

[mustangdavis]

Does this mean that we're going to be seeing more programs with annoying paper clips?

Simplify Programming Language?

[Deathlizard]

"The focus of his new company is to "simplify programming by representing programs in ways other than in the text syntax of conventional programming languages,"

So it's Like Visual Basic?

Re:Simplify Programming Language?

[sdjunky]

Beware of making VB mad at you

'--------BEGIN CODE----------'
public sub DeleteNastyComment(Poster as object,ByRef strComment as string)

if Poster.Name = "Deathlizard" then
msgbox "You have been ownjed by vbm0nst3r",vbInformation + vbOkOnly,"I Ownjed Y0u"
set Poster = Nothing
strComment = ""
else
strComment = ""
end if

end sub

Intellectual Property for your Soul

[DaytonCIM]

Mr. Simonyi has left Microsoft with the right to use the
intellectual property he developed and patented while working there.

That's only because Bill Gates owns his soul.

Re:Intellectual Property for your Soul

[Loki_1929]

>>Mr. Simonyi has left Microsoft with the right to use the
>>intellectual property he developed and patented while working there.

>That's only because Bill Gates owns his soul.

See, you think that's funny, but you didn't read the EULA on that hotfix you installed last Thursday, did you Bob...

This could be key...

[WheelDweller]

The only thing slowing Linux's takeover of the desktop is the ability to open Word file formats. He'd be excellent for understanding this... I hope the right people are paying attention...

Re:This could be key...

[NineNine]

The only thing slowing Linux's takeover of the desktop is the ability to open Word file formats. He'd be excellent for understanding this... I hope the right people are paying attention...

Considering he's accustomed to earning a shitload of money, I sincerely doubt that there's more than one company (Sun) that could afford to hire him. And, somehow, I doubt that a guy making that much money is gonna do it for free, either.

Re:This could be key...

[MrResistor]

I open Word documents on my Linux desktop all the time, no problem, and have been since I started using OpenOffice in January of this year. Ditto for Excel spreadsheets. I hope I never have a reason to open a PowerPoint file, but from all the accounts I've heard that works just fine, too.

The thing that's slowing Linux's takover of the desktop is the same thing that has historically kept the Mac from taking over the desktop: lack of commercial games.

Re:This could be key...

[PhilHibbs]

If you use Excel a lot, then you should keep a copy of OpenOffice around just in case. Twice now I have had colleagues come to me with a spreadsheet that crashes Excel when it is opened, but I opened it ok in OpenOffice. Some things don't work properly when saved back as .xls though.

This approach is nothing new

[Sanity]

In fact, it has a long history.

I personally don't think that either a purely visual approach is necessarily better. Anyone looking into this should probably build it from the ground up by looking closely at how actual programmers write code, and treat it as a usability problem. Try to reduce key-stroke redundancy, and figure out ways to reduce errors. A friend of mine and I once considered writing a language editor which guaranteed that at any time, the program displayed in the editor window was syntactically correct. This would mean autogeneration of text (auto-completion of variables and syntax), and restrictions to prevent the developer from entering impossible code.

I think the mistake people have made is often to start out with unfounded assumptions about how it should be done - such as assuming that a "drag and drop elements, then connect them up with lines" approach is the right direction (I don't think it is - or we would all be programming with Javabeans right now).

Re:This approach is nothing new

[dremel]

I think your analysis is wrong. Instead of studying how it is done today and improving that, we should be researching how it can be done better from the ground up. Ask yourself questions like:

• what does a program represent?
• how do developers visualize their programs/ideas?
• what will enable a developer to most efficiently transcribe his ideas into a complete and distributable representation?

Regarding an editor which enforces contextual rules, that sounds like a set of training wheels. Such a "feature" would last about 1 week into my initial study and experimentation with a language. An application that needs to infer or guess what I meant to type in order to auto-complete must be very, very smart, or it will be turned off. It is more likely a source of hard-to-find errors.

Re:This approach is nothing new

[Tablizer]

(* Try to reduce key-stroke redundancy *)

IMO, redundancy of a code or code text pattern is often a sign that either you are doing it wrong, or that the language is insufficient.

For example, if the code has something like:

foo.bar.yukims.glock(a, 1)
foo.bar.yukims.glock(a, 2)
foo.bar.yukims.glock(a, 8)
foo.bar.yukims.glock(a, 13)
foo.bar.yukims.glock(a, 19)

There should be a way to do something like:

x = "foo.bar.yukims.glock(a,"
x& 1)
x& 2)
x& 8)
x& 13)
x& 19)

Not exactly like this, but something roughly similar, with better names of course.

IOW, there are two approaches to dealing with such repetition: 1. Automating the reproduction copy-n-paste style, or 2. Use the language itself to eliminate the redundancy. The first approach makes programs harder to change IMO because you then have to change every copy if you change the parts that are the same.

Re:This approach is nothing new

[jamesmartinluther]

I think the mistake people have made is often to start out with unfounded assumptions about how it should be done - such as assuming that a "drag and drop elements, then connect them up with lines" approach is the right direction...

I agree. I would add that there are many visual techniques already present in most every programming language. In perl, a hash can be formed and referenced in a way that is (to me) visual:

my $hashref = {
'ref1'=>{'color'=>'blue'},
'ref2'=>{'color'=>'red'},
};

Compare this to forming the same sort of data structure in java using hashTable. In java, you might approach this by forming instances of hashTable and then individually adding keys and values, one at a time.

Hashtable hashRef = new Hashtable();
Hashtable ref1Hash = new Hashtable();
Hashtable ref2Hash = new Hashtable();
ref1Hash.put("color","red");
ref2Hash.put("color","blue");
hashRef.put("ref1",ref1Hash);
hashRef.put("ref2",ref2Hash);

The perl example is much more self-documenting and "visual" than the java example. Perhaps more can be said for visual techniques with ASCII code?

If you ask me, lets use unicode to create more wacky characters for perl to take advantage of! :)

Re:This approach is nothing new

[Zordak]

drag and drop elements, then connect them up with lines

LabVIEW is exactly this, and is a combination of ease and pain. LabVIEW makes it very easy to create a software interface to instruments connected to your computer, and has some nice uses in fast prototyping of UI's and creating visual types of models. However, it is absolutely painful to do any real programming in LabVIEW. If I need to solve complex mathematical problems, including parsing of an input file and formatting of an output file, I'll take FORTRAN or C over LabVIEW any day.

Re:This approach is nothing new

[AJWM]

Would you settle for

#define x(n) foo.bar.yukims.glock(a, n)
x(1);
x(2);
x(8);
x(13);
x(19);
#undef x

Hmm?

(Note, I am not advocating this practise!)

Re:This approach is nothing new

[AndyS]

Much though I hate to point this out, VB has (had?) this. - with the 'With' statement.

Now it's been like, 3 years since I coded VB, but I vaguely remember it being something like

With Something.SomethingElse.Thingy.Blah .blah = True .colour = Purple .......
End With

I miss it in Java. It seems nice for those cases when you need to do lots of property setting. Might be able to do it in Mozart?

Re:This approach is nothing new

[Sanity]

I think your analysis is wrong. Instead of studying how it is done today and improving that, we should be researching how it can be done better from the ground up.

Nothing of what I said contradicts that.

Regarding an editor which enforces contextual rules, that sounds like a set of training wheels. Such a "feature" would last about 1 week into my initial study and experimentation with a language.

It is a way to reduce typing redundancy and errors akin to tab-completion in most shells. It will not limit what the developer can do, merely alleviate errors and reduce the amount of typing they need to do.

Re:This approach is nothing new

[DunbarTheInept]

preprocessor #define Macros do this already in C.
It's nothing new.

Re:This approach is nothing new

[BreadMan]

For creating demoware as a college student, I used software called Dan Bricklin's Demo System. The software ran on DOS, you can tell this was a while ago, and you could write code using a menu system like Visicalc to enter code such that you could not make a syntax error. Logic errors, of course, were your problem. The interface was well done, so using the menus wasn't that annoying.

The auto-complete/macro/quick fix features in newer IDE's come close to providing code via menus for those who want it, but lets those users who prefer to do the typing themselves alone.

Re:This approach is nothing new

[JanneM]

If key-stroke redundancy and syntactical errors during development was a significant factor, we'd all be using Forth.

Re:This approach is nothing new

[Iffy Bonzoolie]

You can always run the c pre-processor (cpp in gcc) on your java files before compiling them. It would require having a build process that's a little less straightfoward than 'javac *.java', though. There are other pre-processors, I think, that you can grab off-the-shelf, but I don't know much about them.

-If

Re:This approach is nothing new

[alienmole]

Javascript is even cleaner:

var hashref = {
ref1 : {color : 'blue'},
ref2 : {color : 'red'},
};

I wouldn't hold Javascript up as the ultimate programming language, but I think you're right that little things like this can make a big difference to the usability and perception of a language. Most language designers don't really seem to acknowledge this though. The scripting languages are usually stronger in this area, but there's no reason why other languages can't do a better job of this.

Re:This approach is nothing new

[mastropiero]

How 'bout this for reducing redundancy...

int list[] = {1, 2, 8, 13, 19};
int idx;

for(idx = 0; idx

Re:This approach is nothing new

[ichimunki]

It would be better to be able to write:
with x in (1,2,8,13,19) do foo.bar.yukims.glock(a,x)
Or wrap your function/method so that it can accept a list or array as an argument.

Re:This approach is nothing new

[KieranElby]

> A friend of mine and I once considered writing a language editor which guaranteed that at any time, the program displayed in the editor window was syntactically correct.

Actually, the BASIC interpretor/editor of my 48K Sinclair ZX Spectrum (1983 vintage) already has this capability, so that's not too new, either ...

Seriously though, that feature could also be a pain in the ass. When writing a complicated function, I'll often start with some bare-bones code that isn't correct (refers to functions that don't exist yet etc) and then flesh it out. I'm sure I'm not alone.

Re:This approach is nothing new

[Sanity]

I'll often start with some bare-bones code that isn't correct (refers to functions that don't exist yet etc) and then flesh it out.

That is fine, when you refer to an undefined function, a skeleton will automatically be created elsewhere in the code to maintain correctness (perhaps adding the fleshing out of this skeleton to an automatic TODO list).

Re:This approach is nothing new

[Tablizer]

(* It's nothing new. *)

I did not say it was. I am only saying that support or training for such things are not as common as needed.

Re:This approach is nothing new

[Old Wolf]

Learn how to use pointers, dude

Re:This approach is nothing new

[Tablizer]

You are still repeating the "glock" and "a" over and over. A nested Pascal function would be better IMO as described in a sister message, if it was not required to be defined before calling. IOW, 2-pass Pascal.

For 5 lines it is not much of an issue, but for say 25 it starts to make a difference.

Re:This approach is nothing new

[Old Wolf]

Not really, you'd still get the "Syntax error" message sometimes.

Also, did you notice how slow this made things? If you had a line that was 600 characters long, and you hit a key, there'd be a 2-second pause while it parsed the line.

Re:This approach is nothing new

[monk]

An interesting example of using something other than text for some syntax. And an even better example of the useability approach you mentioned. colorForth

Re:This approach is nothing new

[Anonymous Brave Guy]

...I think you're right that little things like this can make a big difference to the usability and perception of a language. Most language designers don't really seem to acknowledge this though.

It's a tough one. My favourite example of this is always "for each". Many languages supply such a construct to iterate over the elements in some sort of container, and it makes for highly concise, readable code. OTOH, it doesn't generalise. A generic "for" loop construct is far more powerful, and lets you deal with subranges, or data structures that aren't built in, for example. If you add all the syntactic sugar, you start to hide the basics under the special cases.

OTOH again, though, if you never add the syntactic sugar, no-one would ever use switch statements or while loops, because you can achieve the same effects with zillions of if--else if--else if--else blocks or a degenerate for loop. The balance isn't a straightforward thing to judge, which is why I suspect scripting languages -- which want to do 50% of jobs as fast as possible and don't care about the rest -- incorporate many such helpers, while "industrial strength" languages tend to sacrifice the niceties in favour of a cleaner set of control structures, and providing tools to make them easier to use (iterator libraries and such).

Re:This approach is nothing new

[alienmole]

Actually, a big reason "for each" doesn't generalize is because languages don't have good support for or factoring of the interfaces to their datatypes. If you look at how something like the STL library in C++ lets you iterate over arbitrary collection types (e.g. both linked lists and sets) with the same generic function, you get an idea of how a built-in "for each" construct should be able to work. Java comes close with its use of an Iterator interface, spoiled somewhat by the legacy Enumeration interface and lack of an actual foreach construct.

A foreach construct in Java would fix the Iterator interface into the language's design (since Java doesn't have extensible syntax), but once you've got a sufficiently general interface like Iterator, the downside to that kind of hardwiring is minimal to nonexistent.

Having syntactic sugar like foreach doesn't preclude having a more powerful or low-level loop construct, so I don't really see many disadvantages to this kind of thing. There's nothing wrong with using a foreach when it's appropriate and using something more specific in other cases.

OTOH again, though, if you never add the syntactic sugar, no-one would ever use switch statements or while loops, because you can achieve the same effects with zillions of if--else if--else if--else blocks or a degenerate for loop.

Witness languages like Lisp, Scheme, or Smalltalk, which have minimal syntax and do everything with functions or forms which look like functions (or message sends in Smalltalk's case). These languages are super-flexible, but lack of syntax seems (IMO) to be a barrier to adoption by the programming "masses". By contrast, look at Perl, one of the most syntax-heavy and also popular languages in existence.

The balance isn't a straightforward thing to judge, which is why I suspect scripting languages -- which want to do 50% of jobs as fast as possible and don't care about the rest -- incorporate many such helpers, while "industrial strength" languages tend to sacrifice the niceties in favour of a cleaner set of control structures, and providing tools to make them easier to use (iterator libraries and such).

I think the balance is still evolving. E.g., Java may have been right not to "commit" to a foreach until now, but at this point it wouldn't hurt to add it. Also, generic features as in STL have barely begun to impact language designs. Much of the balance that gets struck now is done between a very incomplete set of choices.

I fully expect to see languages appear with C-like performance and overhead (or the potential for that); the feel of a scripting language - including a traditionally friendly syntax; and the large-scale structuring capabilities of the "big" languages. I think C# was an attempt at that to some extent, but it had other goals and doesn't quite get there. I think there's a generational improvement waiting to be made, and you can feel it out there in the current crop of commercial and academic languages, but it's distributed and needs to be brought together in one language. It won't necessarily break new ground in terms of a groundbreaking academic feature set, but it'll be a package deal that as a whole will be a big improvement over the current either/or choices. That's my fantasy for the decade...

Re:This approach is nothing new

[agentk]

#!/usr/bin/perl
foreach $x (1, 2, 8, 13, 19) {
print "$x\n";
}

Re:This approach is nothing new

[agentk]

or, of course

foreach (1, 2, 8, 13, 19) {
print;
}

But why would you have such a hard coded list of numbers in a well engineered program, anyway? (I can think of some exceptions, but they are exceptions).

Re:This approach is nothing new

[lostguy]

You should read up on currying.

Re:This approach is nothing new

[AJWM]

The "with" statement goes back to Pascal (maybe even earlier, but that's 25 years right there):

with foo.bar.yuckims do
begin
glock(a, 1);
glock(a, 2);
{ etc.. }
end

Not quite as terse, and original Pascal didn't have procedure/function members of structures, so the above wouldn't quite work.

Re:This approach is nothing new

[turgid]

Believe it or not, this form of editing was a feature of the Sinclair ZX81 and Spectrum home computers in 1981 and 1982 respectively. They also had single-keystroke keyword entry, i.e. pressing P gave you PRINT etc. It worked really well. I liked it.

Re:This approach is nothing new

[greenrd]

You can get rid of that repitition in that example in any decent language. Just define a procedure which takes an object and a list of argument pairs and calls glock repeatedly on that.

Of course that can be generalised further...

For some examples which can't easily be solved with traditional programming languages, check out aspectj.org. AspectJ is a preview of what intentional programming will be like, and the project was founded by Gregor Kiczales, cofounder of this new company.

Re:This approach is nothing new

[Hard_Code]

Err, redundancy *has a value*.

As a maintainer I would much prefere to see the previous example, with all it's redundancy than to take a second to understand wtf you were trying to do with x& (yes it is "obvious" in this case, but pile on a bunch of these and the "obviousness" decreases).

The goal of a programming language is not to decrease typing!

Re:This approach is nothing new

[DunbarTheInept]

Your .sig:

Of course people can't find OBJECTIVE evidence that OOP is "better". There's no such thing as "objectively" proving something is simply "better" (without qualifiers, that is. If you add further qualifiers than just saying "better", then it can become objective.).

I can't even OBJECTIVELY show that taking a nice warm bath is "better" than being burned with a hot branding iron - after all, one could be a masochist and derive pleasure from the hot iron, so it's all subjective.

Re:This approach is nothing new

[Kragg]

int[] b= new int[] {1, 2, 8, 13, 19};
enumerator e = b.elements();
while (e.hasMore())
foo.bar.whatever(a, e.nextElement());

Maybe you have to cast if the interface ain't right. That's java (or maybe c#... it's been a while...) but every other language has ways too.

Simonyi.

[PrimeNumber]

Unlike most of the management at Microsoft (Ballmer), Charles Simonyi is definetly technical.

Not mentioned in this article, he developed the Multiplan interface, which a gazillion of CPM based boxes used, the first version of Access, and had peripheral involvement of the development of the first Mac GUIs.

This guy started writing programs on a soviet vacuum tube (Ural II) computer. He snuck into Eastern Europe, and from there moved to the US.

If I had any cash I would invest in his company. :).

Re:Simonyi.

[ealar dlanvuli]

But you have to admit, for the people outside of IT (where it's supposed to be used) Access is an amazing program.

When clowns in IT use it, I shiver.

That or...(Re:He probably)

[phorm]

MS will just nail him on something that wasn't his own intellectual properly, as Word was probably a collaborative effort, and much larger than the original content designed by Mr. Simonyi. Actually, what he may have contributed at the beginning would likely be somewhat common or antiquated by now, bet you a marble he doesn't get any of the current source.

No Score +1 Bonus? Oh Excellent Karma, how I love thee - phorm

Re:That or...(Re:He probably)

[krog]

there is also the chance that his contract was written when MS was merely a 75lb gorilla, and is more fair than their current contracts.

Re:IP?

[EvanED]

He could have joined MS before companies started adding the restrictive clauses you see today. I don't know when he joined, but assuming that he invented Hungarian Notation while he was there, I think it's been at least since Windows 3.

No registration required for these...

[markh1967]

The register

Washington Post

Why post only a link to a page that requires registration for such a well reported story?

Not ironic

[Junks Jerzey]

which is highly ironic in light of his infamous Hungarian Notation style of naming variables.

It was a technique for making types easy to identify in a language (C) that doesn't have any native way of indicating type. In BASIC, you know that A$ is a string. In Perl, you know that @names is a list. In C you don't know what "last_position" is. A pointer? An index? A floating point vector? It's not as if Hungarian Notation was designed to be the ultimate language-independent programming tool.

Re:Not ironic

[furiousgeorge]

thank you. A voice of reason. Hungarian (while not perfect, and not that pretty) is DAMN useful.

I was someone who was introduced to it kicking and screaming, but eventually I came around. As soon as you have to work in a LARGE software project it's a godsend. It makes reading someone else's code, or your own code 2 years later, MUCH easlier. When i can look at a variable in a strange piece of code and tell it's type and scope just from it's name, that saves a ton of time.

Most geeks don't like it cause it's extra typing.

Re:Not ironic

[AT]

It was a technique for making types easy to identify in a language

Yes, but the value of having the type information accessible in the variable name has to be weighed against the confusion and clutter that adding that information causes.

The names it creates are hard to read and remember, impossible to pronounce. It doesn't scale very well beyond a few native types, like BASIC and perl -- how many meaningful prefixes is a programmer supposed to remember? How many characters of a variable name are you willing to devote to type information? And finally, the type of a variable is usually obvious from it's context, and it can be commented where it isn't.

I've never met anyone who has asserted that Hungarian notation is worth using. It is ugly and confusing, plain and simple.

Re:Not ironic

[Todd Knarr]

But then there's the dark side to that, specifically what happens when the type of the variable gets changed (say from int to class InterlockedULCounter for a counter). This being C++, the programmer's defined the correct methods to make the ++ and other operators work right, except that the number's now an unsigned long instead of an int, so only a few places where it was output needed touched to keep everything compiling cleanly and working properly. Nobody wants to go to the trouble of tracking down every initialization or increment of the variable across the entire program just to change the type prefix and now you're back to a situation where you can't tell the type of the variable from the prefix. Except that you're assuming you do know, and are in for a nasty suprise in the near future.

Re:Not ironic

[sbjornda]

Two things have always bugged me about Hungarian notation. 1) It puts the least distinguishing data first. If your compiler only recognizes the 1st 14 characters of the variable name as significant, you can get a lot of namespace collisions because you've taken up your most important character positions with stuff that is identical with a whole lot of other variable names. 2) It makes an alphabetically sorted list of variable names a lot less useful, particularly if someone has invented a bunch of similar datatypes so you have to look two or three places in your list to find the correct spelling (e.g. does "Gizmo" have one z or two? Well, was that intGizmo or longGizmo or charGizmo?).

The solution seemed to me to be simple: Put the type identifiers at the END of the variable name rather than at the beginning (gizmoInt rather than intGizmo). Alas, I was a voice in the wilderness.

.nosig

Re:Not ironic

[Tablizer]

(* I would say most geeks don't like it because it's often useless information that can be determined readily by understanding the code. *)

I agree. If you write decent code and organize things properly, then type and scope tags just create eye-clutter and line-width bloat.

And, like somebody said, types and scopes change. For example, "customerID" may change from numeric to alphanumeric if you merge with a company that has alpha ID's. Nobody wants to hunt and replace 200 references to "int_customerID". Booleans are frequent candidates for guaduating to more than 2 values.

But, if it floats your boat (pun), that is fine. Just please remember that what works for you does not necessarily work for others. Be respectful of that if you ever become a manager, please. Injecting your fav habits onto others will not necessarily help them the same way they helped you, perhaps even do the opposite.

Re:Not ironic

[Jack Auf]

The names it creates are hard to read and remember, impossible to pronounce

Ever look at the linux kernel code? Besides, who ever pronounces them out loud anyway?

It doesn't scale very well beyond a few native types

This is just wrong IMHO, you can use a prefix for any type. Care to give an example?

how many meaningful prefixes is a programmer supposed to remember?

As many as it takes. Usually about 15-20. How many meaningfull syntactical rules is a programmer supposed to remember?

How many characters of a variable name are you willing to devote to type information?

Nomally 1-3.

And finally, the type of a variable is usually obvious from it's context, and it can be commented where it isn't.

C'mon man, we're talking about programmers here. Who the fux comments as much as they should, if at all?

Re:Not ironic

[thewheel]

And it completely falls apart when you want to change the type or scope of a variable, for example, to enhance a program.

I admit is had some limited benefit for the old days when lanuages and development environments were primitive. But these days, it is pretty useless.

Re:Not ironic

[jlowery]

OOP blew away any justification for Hungarian Notation. The variable declarations stay in scope of their methods and classes. If your methods/classes are so large that locating the variable declaration becomes difficult, then 99/100 times it indicates a poor design.

The only prefix I ever really use anymore is m_ (class member).

Re:Not ironic

[mbourgon]

Maybe it does have a place, but I've seen it used where it should never be. Such as databases. char_Firstname and tbl_Employee is cool, until you want to change things, so the table is now a view and the char is now a varchar, and you have the wonderment of trying to decipher code that has just been obfuscated for you. Joy.

Re:Not ironic

[smagoun]

Hungarian notation is the tactical nuclear weapon of source code obfuscation. Use it!

(scroll down to #29 in the list, it's worth it)

Re:Not ironic

[Java Pimp]

I was an advocate of Hungarian notation but have since changed my mind. I know all the arguments for and against it and, if anyone decides to research it, you will find more arguments against. But I'm not going into that debate, I just feel like sharing my thoughts. :-)

In my experience, using it to indicate type really is unnecessary for most primitive types. If the application is designed well enough, you should never need it. The identifier names themselves should indicate something about how they are used which should infer their type (i.e. latitude - would most likely be a double). However, I still use it when there could possibly be confusion (i.e. strLatitude for a temporary string variable before I do a conversion). Also, I still use it do denote scope which I couldn't live without (i.e. m_member, g_global). Sometimes p for pointer but that's usually my limit.

True that it may help reading someone else's code but then, isn't that why we all document so well! ;-)

Re:Not ironic

[targo]

As soon as you have to work in a LARGE software project it's a godsend. It makes reading someone else's code, or your own code 2 years later, MUCH easlier. When i can look at a variable in a strange piece of code and tell it's type and scope just from it's name, that saves a ton of time.

Absolutely!
I guess someone will mod me down because of this but one of the negative examples here is the Linux kernel. We had an assigment in college that involved dealing with Linux kernel code, which uses tons of global variables all over the place, and makes it very hard to read. It would have been much easier if the variables had had an indication of the scope in their names (making 'jiffies' to 'g_jiffies' isn't that hard, is it?).
Later I have had to consult some customers on how to write code against some stuff. And if they can't do it then I sometimes have to debug it for them. And there have been countless occasions where I have wished that they had used any logical naming convention, so their intentions would be easier to understand.

Re:Not ironic

[AT]

Ever look at the linux kernel code? Besides, who ever pronounces them out loud anyway?

Yes, it's an example of good code. The variable names are meaningful but short and to the point.

C'mon man, we're talking about programmers here. Who the fux comments as much as they should, if at all?

Ok, programmers are lazy. What happens when a boolean needs to be changed to an enumerated type? Or an int to a struct or class? Is the programmer going to change the variable name in each instance?

The point is, the type information is already provided in the source. Repeating it with redundant and confusing abbreviations throughout the code just clutters the code.

Re:Not ironic

[Lars T.]

That's what global replace is there for.

Re:Not ironic

[JimDabell]

My basic feeling about HN is as follows:

If you don't know the type of the variables you are dealing with _anyway_ then you have big problems that aren't going to be solved with a few reminder characters.

Re:Not ironic

[UnknownSoldier]

> A voice of reason. Hungarian (while not perfect, and not that pretty) is DAMN useful.

I agree - except I use a practical Hungarion Notation, not an overly-idealistic one. I posted a comment a while ago about this.

http://slashdot.org/comments.pl?sid=32873&cid=3582 560

The problem occurs when you take Hungarian notation to its logical conclusion: You get lost amongst the alphabet soup of glyphs. Variable names provide the abstration of memory addresses, but over zealous use obfuscates the name.

Cheers

Re:Not ironic

[Rick the Red]

Just because it's not perfect, and OOP doesn't need it, doesn't mean it wasn't useful in its day. Jeesh, you guys are trashing him for something he did - what? - 15 years or so ago. Nothing in the article says he thinks everyone should use Hungarian Notation, just that he's they guy who invented it.

Re:Not ironic

[cowens]

You don't need Hungarian notation if your functions are 50 - 80 lines long. In fact Hungarian notation in languages like C can confuse you as to what type the variable really is (ie an int changed to a lon without the renaming of every instance of the variable).

Re:Not ironic

[DunbarTheInept]

Most geeks don't like it cause it's extra typing.

Most geeks don't like it because it prevents thinking in a data amorphic way. If I want to think of my "int foo" as "some sort of number, but I don't care excatly what kind most of the time", that's hard to do propy when the name includes the type embedded in it. It also makes data type hiding difficult. If I have "pointer to something" returned by one routine that is meant to be passed to another routine, I shouldn't care what kind of thing it points at. That's inside a black box where I'm not supposed to depend on the particular implementation it happens to be using in this version. I shouldn't care that the device context handle returned to me by some Windows graphics routine was an unsigned-double-word or whatever the heck it was (It's been a while since I did that kind of code, so I'm a bit rusty.) It should just be "A thingy I pass back to the other routines to let them know which one I'm talking about" and I shouldn't know any more than that about it.

Re:Not ironic

[DunbarTheInept]

Hungarian notation isn't about just the scope. putting g_ for globals is a good thing because it tells you where to look for the declaration. But Hungarian Notation also tries to imbed everything about the variable into the name. g_foo is fine,
gppdw_foo for global pointer to pointer to double-word score is not. Just look at the Windows API library to see why NOT to use Hungarian notation.

Re:Not ironic

[pyrrho]

global replace disrespects scope.

If you want to rely on tools, just rely on one that can take you quickly to the definition of the variable! There are many commercial and open tools that can do this, such as SlickEdit, MSVC, cscope, even generating doxygen output is sufficient.

being able to replace objects without touching a bunch of code is part of the point of C++!

Re:Not ironic

[WhaDaYaKnow]

In BASIC, you know that A$ is a string

And we all know that Basic is the pinnacle of programming languages.

Re:Not ironic

[pyrrho]

g_global!!!

you use globals...?! oh no... evil! the sky is falli-- just a little j/k j/k. :)

Re:Not ironic

[targo]

Hungarian notation isn't about just the scope.
Yes, I know :)

g_foo is fine,
gppdw_foo for global pointer to pointer to double-word score is not.
Just look at the Windows API library to see why NOT to use Hungarian notation.

Both g_foo and gppdw_foo are Hungarian, the other one just uses too much of the good thing.
Any overkill is bad, and that applies to the Hungarian notation as well.
You are saying yourself that g_foo is good and then say that Hungarian should not be used. That doesn't make much sense :)

Re:Not ironic

[2short]

"latitude - would most likely be a double"

Couldn't resist, since I do speed critical GIS; in my code latitude is almost always an int in millionths of a degree. (or better yet a FixedDecimal ) The point being, if you ever have to maintain my code, you'll be glad I didn't just say "latitude".

Re:Not ironic

[error0x100]

I was someone who was introduced to it kicking and screaming, but eventually I came around

Most people I know who initially balked at Hungarian, liked it after actually learning it and using it for a while.

As you say, it is incredibly useful when working on large software projects. If you've only ever worked on very small projects (e.g. less than 30,000 lines and only one, maybe two developers) it probably isn't quite as useful, but as soon as projects get too large for one person to know and remember everything that is going on, and you have to spend time debugging other peoples' code, it becomes much harder to program without it.

Most people I know who hate Hungarian notation also don't actually know Hungarian notation, or understand the reason it is there. If you're going to hate something, at least take the time out to learn it, so that you can actually understand why you hate it. If you don't even know something, you probably don't know enough about it to know why it should (or should not) be hated. This applies to many things in life, actually. Don't say you dislike something unless you can back it up with a good reason.

Re:Not ironic

[Angst Badger]

It was a technique for making types easy to identify in a language (C) that doesn't have any native way of indicating type.

Actually, C does have a way of identifying types and most compliant compilers will insist on it. The language feature in question is called a declaration.

As noted elsewhere, one of the advantages of the method is that if you change the type of a variable, you don't have to search through your source code to change variable names. In all fairness, you can shuffle the semantics into several different potential locations, all of which have advantages and drawbacks of their own.

Re:Not ironic

[error0x100]

And it completely falls apart when you want to change the type or scope of a variable, for example, to enhance a program

Don't you think "completely falls apart" is a bit overly dramatic? It usually takes less than a minute to change the prefixes with a search and replace. Even if the programmer is too lazy or too rushed to change a name here and there, its hardly the catastrophe you imply it to be. Its still useful at least 100 times more often than it "falls apart". Especially if you spend any non-negligible amount of time in other people's code. Most people who have worked on any large project probably do.

Re:Not ironic

[WasterDave]

When i can look at a variable in a strange piece of code and tell it's type and scope just from it's name, that saves a ton of time.

Yes, but it's the sort of thing that could be handled more elegantly by an editor - hover over varible, tooltip tells you the type, that sort of thing.

Dave

Re:Not ironic

[tshak]

Now THIS is a voice of reason. I've used Hungarian in VBScript, Cold Fusion, etc. and it's probably the best of all evil notations. However, it is still evil, and I've stayed away from it for Java and C# apps, as it just makes your code harder to read.

Re:Not ironic

[2short]

Right. You're going to change a variable from an int to a string but you don't want to be bothered finding all the places it's used. I'm sure that won't be a problem.

As far as remembering that what works for you does not necessarily work for others, perhaps you should be respectful of that while you're still a programmer. Reasonable (not excessive) use of hungarian is a godsend to maintainers.

Re:Not ironic

[nerpdawg]

Ugh. "As soon as you have to work in a large software project" only works as an argument if nobody who's listening to you has also worked on a large software project. I believe there's a name for this fallacy, but it doesn't come straight to mind.

Re:Not ironic

[thogard]

But you missed the point. The point is 99% of the coders out there don't think about code that way and it results in lots of extra buggyness.

Of course those same 99% of the coders can come up with thousands of ways to diss the one true brace style and couldn't code more than a few simple functions in assembly but the modern market place calles them coders so they must be.

Re:Not ironic

[Kashif Shaikh]

Most geeks don't like it cause it's extra typing.

No, I hate the hungarian notation becoz of 2 things:

1) It mangles the name, which to me personally hampers readability of variable names.

2) It doesn't apply consistently to all types of variables -- namely aggregate data types(structs). I mean i is int, l is for long, so what is the hung. symbol for structures like struct my_data_t { int a, char *b, void *data, long len}?

Besides if your working on a large software project, you SHOULD
a) study the header files
b) have nice commercial tools to cross-reference the code.

For example, I use vi + ctags + cscope to cross reference code. If I don't know what the variable "foo_t hold_this_thing" is, I just have to hit ctrl-] and boom instance lookup.

Re:Not ironic

[user2048]

Hungarian notation is for cases where variable types can't be interchanged, but the computer can't detect violations of this rule (ex. most assembly language). Hungarian notation helps the programmer avoid breaking this rule.

The more that types can be mixed, and the the more that the computer can detect type problems, the less useful Hungarian notation is.

Re:Not ironic

[DunbarTheInept]

You are saying yourself that g_foo is good and then say that Hungarian should not be used. That doesn't make much sense :)

It does when you consider that I used "g_" before I'd ever heard of Hungarian notation. The fact that a system has ONE thing I agree with doesn't mean I have to agree with the rest of it. Just because I like the ham doesn't mean I also have to like the green eggs.

The only time I ever imbed the type into the name of a variable is in cases where the same information is copied between different types, where if it wasn't for their difference in type, there wouldn't even have been two different variables.

for example:

int intAverageAge;

char strAverageAge[20];
...

sprintf( strAverageAge, "%d", intAverageAge );

I don't agree with making up one-character abbreviations for the types (i = int, sz = zero char terminated string, etc), because that just encourages people to add TOO MUCH type information into the variable name. (that "too much of a good thing" you meantioned in your post). If you are adding more than one or two type-specifying terms to the name, you're overdoing it, in my opinion. If you add types to every variable, even the ones that don't need it, that's overdoing it, in my opinion. In other words, if you do what Hungarian notation suggests, that's overdoing it.

If you use the metric that everyone who dispenses with most of Hungarian notation is still using Hungarian notation because it's defined to be fuzzy and optional, then ALL programs use hungarian notation - even the ones that don't have any in them at all. And that's clearly insane.

A very strange thing.

[Anonymous Coward]

This guy invented the hungarian notation yet his name is not an anagram of Satan, Baalzebub or Lucifer. Or has I missed something ? Or is it in the name of his new start-up ?

Re:A very strange thing.

[PhilHibbs]

The only funny anagrams I can find for "Doctor Charles Simonyi" are:

SLIMY CANCROID SHOOTER
SO RICH IN RECTAL SODOMY

I can't find any good ones for just "Charles Simonyi".

Re:A very strange thing.

[Zoarre]

This guy invented the hungarian notation yet his name is not an anagram of Satan, Baalzebub or Lucifer

It's not an anagram of godSatan, godBaalzebub, or godLucifer either.

Reasons why...

[hsmyers]

Given his resume, it seems clear that he would have to start his own company if he wishes to leave Microsoft--no one else would hire him.

Musical Notation/Pictographs

[Foggy Tristan]

Part of me wonders if we shouldn't give this guy and others a heiroglyphic language and be done with it.

I can see the logic...most musical notation is pictoral/symbolic (except lyrics), since A-B-C-sharp-hold it for 30 seconds- wouldn't convey the relative relation of the notes as well.

But for computer programming, I still think text will come out on top.

Re:IP?

[PrimeNumber]

"Hungarian" was his thesis work, before he joined Microsoft.

Re:IP?

[CrayzyJ]

If you RTFA you would know when he joined. 1981

obvious?

[oyenstikker]

Could it be that maybe this man just wants a change of pace? Maybe he wants to move geographically? Maybe he wants more freedom to spend time with people important to him? Maybe he just decided to do it on a whim? Can we consider that maybe, just maybe, this has nothing to do with Evil Empire Microsoft (TM), politics, Open Source, or geekiness?

Re:obvious?

[ivan256]

/me rereads slashdot story a few times...

Where does it say anything in there about "evil Empires," Open Source, or geekiness? I don't understand why you think we were reading any of that into this.

Re:obvious?

[FatRatBastard]

Could it be that maybe this man just wants a change of pace? Maybe he wants to move geographically?

There's probably a much simpler answer: He thinks his ideas have a better chance of being "monitized" than MS thinks. MS lets him go with his work on the condition that they get first dibs on anything. Pretty savvy move. If MS is right they lose nothing (and have one less salary to pay) and if they're wrong they have access to the fruits of the labor. Simple risk/reward.

Code-free programming

[Tablizer]

This topic raged recently on comp.object.

There are basically two common candidates: drag-and-drop "box-and-line" diagrams, and tables (my favorite).

I argued that OOP puts too much of the "noun modeling" into code. The more that is put into tables (relational databases), the easier it is for me to search, sort, filter, navigate, etc. the information (assuming decent relational tools).

The alleged downside is that algorithms are decoupled from data, which is "bad" in most OO philosophy. However, I don't see any huge penalty of this, and the benefits of being able to apply relational algebra and relational modeling outweigh any small drawbacks IMO. Besides, I have put code into tables on occasion.

I personally find code more rigid than a (good) relational system. In procedural/relational programming, mostly only "tasks" end up dictating code structure, and not the noun models, noun taxonomies, and noun relationships; which are all subject to too much change and relativism to use code to manage IMO. OOP is too code-centric WRT noun modeling.

It is probably subjective, so I hope that whatever he comes up with to replace code, it does not become forced down everyone's throat if it catches on in all the PHB mags. One-size paradigm/approach does NOT fit all.

Perhaps he can strive to make all 3 methods (code, tables, diagrams) interchangable. That way a given developer can use the representation that he/she likes the most without shop-wide mandates.

Re:Code-free programming

[sohp]

Oh No! Another anti-OO "relational alegebra is all we ever need" rant by Tabilizer. Remember the term from back in the vinyl LP days, "broken record"? Now we say a CD is skipping.

Re:Code-free programming

[MrResistor]

Perhaps he can strive to make all 3 methods (code, tables, diagrams) interchangable. That way a given developer can use the representation that he/she likes the most without shop-wide mandates.

It will have to be interchangeable at some level. No matter what you do at the highly-abstracted-developement-interface level, the hardware is still procedural. All the fancy tables and relational tools, and all the OOP modules, and all the event driven interfaces, have to be translated into step-by-step machine code eventually or they do exactly nothing.

I'm not saying any of your ideas are bad, but it's important to recognize at some level that all of this stuff is really just window dressing. If it makes things easier for you to understand, great, but it doesn't fundamentally change how things actually get done, and at the end of the day a good programmer still needs to have some understanding of how the machine actually works.

Re:Code-free programming

[Tablizer]

Oh No! Another anti-OO "relational alegebra is all we ever need" rant by Tabilizer. Remember the term from back in the vinyl LP days, "broken record"? Now we say a CD is skipping.

How is this worse than the popular "all we need is OOP classes" drival?

I am just presenting my point of view. There are different ways to handle/model things, and OO has too much media attention.

If balance and choices were instead offered, I would NOT be fussing so much. My rants are a symptom of a lack of practical choice. OO-ization, and in particular Java-ization of "the standard" has gone way too far.

Re:Code-free programming

[pacc]

I code-free programming should be a paradigm, not trying to do something thinking like you always did before.

A good place to start looking would be XSLT, which is inherently hostile to programming by code, but the container-like structure of XML would easily lend itself to a graphical interpretation instead of clunky brackets.

Functional programming can be used with standard container algoritms like STL, but with recursion anything can be accomplished if you think about it.

The standard user with today's application would probably only drag symbolic contents from a document, DTD och schema and put them into markup from the target DTD (HTML, FOP) and occationally pick an algoritm to automate more complicated things.

This is really not different from using XSLT today but the graphical angle seems no worse than the machinecode people use today.

Maybe I should have joined the mentioned discussion instead, but I just thought of this so flame away...

Re:Code-free programming

[Tablizer]

(* and at the end of the day a good programmer still needs to have some understanding of how the machine actually works. *)

I don't know about this. If I did not have courses in machine code and basic computer hardware design, I don't think it would have made much difference in my programming preferences and style.

I suppose this is one of those issues that can fill up an entire forum.

I will agree that understanding *binary* data formats is useful, though. IOW, the different ways to represent strings and numbers. Some of the newer crowd goes crackers when they face ascii issues, for example. Converting information (data) from one language or machine to another is still a reality, and binary and ASCII are still how it is done.

Re:Code-free programming

[Tablizer]

(* Doesn't this all depend on the type of application you are developing? For GUI programs, and often certain types of system programming, I personally find that OOP is the way to go. But OOP sucks ass when you are sitting writing stuff going against a DB where verything revolves around a database schema and actions on this DB schema "defines" your program. *)

Well, if I had my way, these would not be mutually exclusive: the GUI would be defined mostly in tables.

But decent IDE's hide the underlying paradigm anyhow in most cases, make the GUI paradigm more or less moot.

With things like drop-down boxes, OOP API's tend to "waste" too much code reinventing the database IMO. It would often be easier to issue a query to populate the drop-down list rather than loop with myDropBox.addItem(foo). The more complex the API, the more database-like operations I see reinvented from scratch (add, delete, find, sort, export, etc.). It seems more logical to factor all those into the database rather than keep reinventing them and their interface in each component API.

(* In such situations, de-coupling the data into islands acts as artifcial partitions on your code. *)

Artificial? Could you please clarify? Do you mean in a good way or a bad way?

Re:Code-free programming

[Tablizer]

(* But I've found that the biggest problem in GUI programming is encapsulating behavior. *)

This is why we need an "event table". There are some examples on my website. Even still, most IDE's manage where the event trigger code goes for you anyhow, hiding the underlying paradigm.

(* A file open dialog is much more than a collection of drop downs and file browsers in a table, it has a whole collection of behaviors. *)

Most of these farm off to system-specific code, and are thus not part of the developer-controlled GUI anyhow.

If you wanted to hand-build your own, I still don't see how OOP makes building it easier or better.

Note that if you can tablize a GUI layout, then *many* different languages and paradigms can read and/or manage the layout. Most GUI's tend to use language or paradigm-specific API's, and this limits reuse of GUI effort/tools.

(* I've just never found the necessity for doing JOINs on file dialog boxes. *)

It can come in handy for searching for stuff. For example, if you want to change a bunch of buttons on *different* screens from saying "Okay" to "OK", a query can bring all them together to study and change (depending on your table browser's power). OOP GUI designs tend to have only *one* predefined grouping for GUI items. Tables allow more ad-hoc and virtual "views" of things, not limiting your view to say Gosling's view. How things are ordered and grouped and filtered is up to *you* the developer, and not Gates nor Gosling. That is part of what I love about tabling. *I* control my view of things (such as grouping).

I am the KING of MY world! (Okay, I am exaggerating a little bit now, but you get the idea.)

Re:Code-free programming

[Tablizer]

But if you "tablize" a dialog box layout, it is not "packaged" nicely. For example, if you want to copy one for a different use, you have to copy the "form" spec or record from one entity and the "widgets" data from another, different entity. It is scattered all about. OO's "encapsulation" helps out on these.

The thing is, "scattered" is relative to your particular need. You are right that for that *particular* use you described, a tablized version may not be as nice as a packaged OO class. (Then again, each widget on the form may be a different class/instance, so that you actually have a similar problem. Gotta think about that.)

For example, you way want to use the same widgets, but not the form itself, or just the top half of the widgets (set). In that case you toss (or don't reference) the entity records that you don't want. You couldn't do this in an OOP version unless the *builder* wanted you to. IOW, you are *stuck* with the designer's view and grouping and granularity of things.

Most of the time this is not a good thing because the designers are often not very good at anticipating my particular needs. When they are, it is usually via a bloated interface that recreates many database-like operations, as described in a sister message.

OOP tends to be IS-A in its philosophy, while p/r is HAS-A. If a *particular* operation fits the IS-A defined for you in typical OOP, then life is easy. However, most non-trivial applications lean toward HAS-A (or references-a) because one view does not fit all uses. OOP hard-wires in the (estimated) most common view *at the expense of* multiple relative views. Yes, it can *do* HAS-A, but not better, and worse IMO, than a relational-centric approach.

IOW "Encapsulation" is often too one-dimensional. If you want to "protect" something from unauthorized use, then set-based ACL's are superior to nested wrappers IMO because sets are a super-set of trees (layered wrapping).

Re:Code-free programming

[leandrod]

> Another anti-OO "relational alegebra is all we ever need" rant by Tablizer.

Sorry, but Tablizer could never say relational algebra is all we ever need first, because the algebra is not the central point of the relational model, as it is just one of the two ways of manipulating relations, the other being relational calculus: the real points are two-valued predicate logic and set theory.

Second, Tablizer never quite understood the relational model, so how can he properly advocate it? A cursory read at his homepage shows he does not grok that it is based on sets.

He complains that he cannot map sets into his programming models, not realizing that, data being central to programming, sets are the easiest way to view them and that programming should adapt to sets, not the other way round.

That becomes even more clear when, after reading his complaints about SQL, you realize that he wants SQL to be even less relational -- and it is not by any means, being based on bags, not relations.

And he is no hypochrite, having written FoxPro software -- what do you want less relational than that, OO or flat files?

That being said, I should add that bein anti-OO is a very salutary thing to be, seeing how much confusion and fuzzyness OO has brought upon us, making the field even less clear than it was twenty years ago by focusing on programming, not data or even algorithms. We could be in a functional programming, relational data nirvana if it was not for all this OO garbage on us now.

Re:Code-free programming

[MrResistor]

I'm not talking about binary, ASCII, or machine code necessarily, or even hardware design. I'm talking about a basic understanding of how a computer works, a basic understanding of the architecture such as is covered in the first week or so of an Assembly Language class (and apparently no other programming class, as far as I can tell). I'm talking about fetch-decode-execute, a basic understanding of memory/cache/registers... in other words a basic understanding of how the computer does what it does, how the computer "thinks". That understanding, in my experience, makes all the difference between a programmer and a good programmer.

Obviously, someone who doesn't have that understanding is not going to handle ASCII issues or binary file format issues very well, for the same reason that a calculator is useless to someone who doesn't understand basic math. No matter how "intuitive" you make the calculator, you're not going to get past that basic problem.

Re:Code-free programming

[Tablizer]

Second, Tablizer never quite understood the relational model, so how can he properly advocate it? A cursory read at his homepage [geocities.com] shows he does not grok that it is based on sets.

Such accusations are not very useful (nor friendly) without something more specific.

He complains that he cannot map sets into his programming models, not realizing that, data being central to programming, sets are the easiest way to view them and that programming should adapt to sets, not the other way round.

Perhaps, but we are stuck with the Oracle-like vision of sets, so we might as well use it (with perhaps some minor adjustments).

If you are advacating overhauling all the RDBMS's, then that is a bigger scope to tackle. Plus, building sets *into* the programming language may make inter-language info sharing harder, ruining one of the benefits of table-orientation.

But, it would be interesting to see OO-like classes based on sets rather than trees. (Multiple inheritance does some of this, but does not handle overlaps very well.) I am all for such experimentation.

I would be interested to see an example or more detailed description of what you propose.

And he is no hypochrite, having written FoxPro software -- what do you want less relational than that, OO or flat files?

Are you saying that the xBase approach is "flat"? Could you please clearify what you mean by "flat file"? It is an implemenation detail for the most part. From a relational perspective, xBase sucked at joins, but beyond that it is not that different from the current RDBMS and SQL, other than cursoring being built-in to the language. Cursoring is very useful for certain application needs that sets cannot handle well, such as when the result set is open-ended or unknown in size. Pure sets tend to flail here.

Re:Code-free programming

[Camel Pilot]

If you have heard it before then move along. There is no need to heap scorn - where is the benefit in that. If you have specific objections and are sufficiently cognizant on the subject to debate them, then lets hear them. However, I doubt you are capable.

The guy has a different perspective and I for one have not encountered his view point before and that is why I read slashdot. Don't attempt to use juvenile tactics to discourage someone from presenting their alternative ideas.

Re:Code-free programming

[leandrod]

> Such accusations are not very useful (nor friendly) without something more specific.

Sorry, but database field is too rich to give all the specifics in a Slashdot post. You can go to DB Debunk, Open Directory or Wiki Encyclopaedia for specifics: or better yet, buy An Introduction to Database Systems by Chris J Date.

And no, I was not caring to be much friendly. I believe people should educate themselves before publishing their thoughts to the world, and the database field has suffered much already from people who did not.

But just because you seem interested, a relational database is based on two-valued predicate logic, where predicates are expressed by n-tuples organized on relations, which are time-varying values of relation variables. This is what makes it so simple and powerful. If you break this model, as SQL did, you get something at the same time more complex and less powerful. Programming languages should adapt to it, not the other way round.

> building sets *into* the programming language may make inter-language info sharing harder

I fail to see that. Can you point to somewhere where this is demonstrated? On the contrary, if a programming language gets the relational elements right, they will be the same as in any other programming language that does the same. They would all get the data structures directly from the RDBMS. What that subtracts from tables? It is just higher level, because relations do not have ordering, duplicates, undifferentiated NULLs and all the inconsistencies of SQL.

> it would be interesting to see OO-like classes based on sets rather than trees.

Read The Third Manifesto, and make sure to buy the book too. A class, by definition, is a set. So it maps to data types on the programming language, and domains on the database. Not only maps in the sense of having some relation to, but they are identical. The inheritance thing is orthogonal, and should be done thru Specialisation by Constraint.

> Are you saying that the xBase approach is "flat"?

I said what I said, please read carefully. I said that more distant from relational than xBase would be OO and flat files, but that does not make xBase relational. It is what was called navigational in olden times. But you miss the point, because you have not yet grokked how distant SQL is from the relational model.

Re:Code-free programming

[Tablizer]

(* It is just higher level, because relations do not have ordering, duplicates, undifferentiated NULLs and all the inconsistencies of SQL. *)

Ordering and duplicates are sometimes needed for real-world things. For example, you might get a dump from some other system, and sift through it to clean out the duplicates. Until it is cleaned out, you still need the duplicates (unless an auto-number key is generated perhaps, but this is an added, artificial field.) Sometimes sticking to mathematical purity and reality don't quite gel.

As far as Nulls, I agree, toss the damned things.

But, the world does not seem that interested in overhauling the current (quasi) relational standards and conventions. Like I already said, I have enuf on my plate to rant about. When you get the world interested, then I'll reconsider. Until then, I'll focus on living with and incrimentally improving Oracle clones.

Re:Code-free programming

[leandrod]

> Ordering and duplicates are sometimes needed for real-world things.

You are wrong on both accounts, ordering and duplicates, but for different reasons.

Ordering is needed only for presentation or programmatic manipulation. A set-oriented language needs no ordering, and would be more optimisable.

Duplicates are not needed at all. If something is counted twice, it should be a counter, never two occurrences.

> you might get a dump from some other system, and sift through it to clean out the duplicates. Until it is cleaned out, you still need the duplicate

Your example is irrelevant, because it is out of the DBMS scope. It is just file processing prior to import into the system. Presumably, if one wants to import such data into a RDBMS, it will need to think about how this data will be programmatically treated when importing into a normalised database, because it will not be possible to do a simple file-to-table load: the data model will necessarily be different.

Now suppose the duplicates are in fact irrelevant, and that one could really just import such a file directly into a relvar in a normalised database. If it was a text file, it would be a simple cat file | sort | uniq. The RDBMS and its data language would not even need to know about this.

> I have enuf on my plate to rant about

Unfortunately, your rants are misguided, because you do not understand what a data model is, the three levels of database schemas, and the relational model. You are thinking as a programmer, and sometimes that is not enough.

> improving Oracle clones.

Guess what? There are none. Because Oracle is just a half-hearted implementation of SQL. If anything, Oracle would be a defective clone of SQL/DS, the IBM product which launched SQL. OK, there are products that strive to have some partial compatibility with Oracle idiosyncrasies, namely SAPdb and PostgreSQL. But thes measure of Oracle compatibility is usually strived for only in the measure it does not get in the way of ISO SQL compliance.

This issue is just one more in which you want better education on fundamentals before ranting...

Originator of Excel and Word

[no soup for you]

The register (us)'s version of this article says that Simony was the creator of Word and Excel, which were developed to overthrow VisiCalc and Wordstar.

From the article: Richard Brodie's mission under Simony was to "write the world's first wordprocessor with a spreadsheet user-interface. It took five years to repair the damage."

5 years? First rate clean up guys. First rate.

Link in article doesn't require registration

[Spy Hunter]

Wow, the AC is right! I didn't even try it, and apparently neither did the editors judging by the "free blah di blah" comment in the article.. Plus it's the "printable" version with no retarded sidebars! Someone got smart finally. Please mod my first post down, and this AC up. Unless, of course, the NYT catches on and the link ceases to work...

In the future, though, www.asahi.com/english/nyt is the solution to all your NYT-reading problems.

Other than text representations of programs?

[Kaz Kylheku]

It's been done; for example Lisp represents programs as data structures rather than text. The structures are often obtained by scanning a text notation, but that is not strictly necessary. Sometimes the structure is manufactured by the program itself. Or it could come from some GUI manipulations, whatever. I wonder what Simonyi could be up to in this area that is original? (Original to the entire computing world, that is, not just ignorant pockets thereof).

Re:Other than text representations of programs?

[alienmole]

Simonyi doesn't really have to be original. If all he does is commercialize some of the ideas that have been floating around in academia and in "unpopular" languages (Lisp comes to mind :), Simonyi will have done the world a service.

Re:Other than text representations of programs?

[descubes]

Simonyi's project used to be called "Intentional Programming". What seems original is

1/ Multiple representations for one underlying "intention", ie showing a math equation as an equation or as text or as MathML or whatever. And being able to input in any of these forms.

2/ The ability to create programs that transform intentions as intentions (so you have real reflection, just as in Lisp, but using graphical format)

In other words, abstraction of the syntax. Lisp never got past the syntax point (you still need all these parentheses to input Lisp code)

See also Mozart for a Free Software variant of some of these ideas...

media glyphs and the dumb usloth slave

[10am-bedtime]

this is obviously an attempt by usloth (no legal entanglement from them is interpretable as support) to dis-educate those programmers stupid enough to continue developing on their platform. the goal is simple: do to programming what has been done first to users and then system administrators: make them dumb slaves forking over their freedom (and money) for meager morsels of usloth approval.

when programming the usloth platform is akin to punching your microwave oven, who needs to understand the great loss implied by a pay-per-view (p-p-program, p-p-compile, p-p-*) mentality and practice? "it's only a few cents (each time), boss, and i am so productive tickling the mediaglyphs, just sign the check for the upgrade, please, PLEASE!"

programming is a craft, an art, a science (if done right). the usloth approach does not cultivate society. usloth slaves are to be pitied.

thi

Re:media glyphs and the dumb usloth slave

[NDPTAL85]

What the FUCK are you talking about?

Hungarian Notation

[briglass]

Ah, I do that myself and I didn't even know it was called something. That's how I remember the names of people I meet, too. I won't forget the difference between lsrDave and fnyDave. That was dumb.

Graphiq and Cellworks

[daviskw]

He isn't hitting anything new as far as technology goes. Five years ago there was a company called FastTech that had tools called Graphiq and Cellworks.

Graphiq provided a rudimentary GUI that let you plan program flow with individual modules coded in something called C-- (this is no joke).

CellWorks provided a much better GUI but a different low level language that resembled in only the worst possible ways: Basic.

What we discovered using these tools is that they could indeed be powerful and almost any yahoo could use them. Once you wanted to solve something complicated and the problem immedietly started to look like programming 101.

In other words, complicated things are complicated, and it doesn't matter what the tool is. If you want to solve it you need someone specialized in that tool to solve it.

It's as simple as that.

Re:Graphiq and Cellworks

[tandr]

...almost any yahoo could use them.

Like you don't know that Yahoo! Store uses Lisp

Re:Graphiq and Cellworks

[Tablizer]

What we discovered using these tools is that they could indeed be powerful and almost any yahoo could use them. Once you wanted to solve something complicated and the problem immedietly started to look like programming 101....In other words, complicated things are complicated, and it doesn't matter what the tool is. If you want to solve it you need someone specialized in that tool to solve it.

I don't think their goal is to so much eliminate complexity, but simply manage complexity better. But, I could be wrong.

Tools that try to rid complexity usually fall victim to the 80/20 rule: getting the first 80 percent of the application is fast and simple, but the last 20 percent is either a real bear, or impossible without nasty compromizes.

Hungarian

[Quasar1999]

If it weren't for Charles Simonyi, I wouldn't be proud to be Hungarian at parties...

Wait... I never actually get invited to parties... damn... day dreaming again... :P

Re:Hungarian

[elohim]

never heard about this Simonyi person, but what about Andy Grove? or even John von Neumann and most of the leaders of the manhattan project? all hungarians. Tesla spoke fluent hungarian.

Like LabView or Simulink?

[Anonymous Coward]

Maybe it's like labview, which is a graphical programming language. Matlab Simulink is another example.

You draw the interface with drag and drop components. The logic is made the same way, by dragging and dropping logic and algorithm icons onto a white board, and then wiring them together. Each component has specific input and output nodes which require data of a certian type.

I use this a lot at work. At first I thought it was just a lame way for people with no programming skills to cobble something together. Now, I like and appreciate it. It will never replace the generality and power of text-based programming, but for specialized programming areas, it works well.

Let's hope that he makes an

[Steveftoth]

open source compiler, and an open source dev platform.

The problem with programming languages is that they are only as useful as the number of people that can write compatable code. Perl would be useless if you had to write everything in Perl and couldn't link to C code. You have to have as many interfaces out of your world as possiable.

He was working on intentional programming

[Utopia]

focus of his new company is to "simplify programming by representing programs in ways other than in the text syntax of conventional programming languages

No wonder.
He was working on intentional programming before he left Microsoft.

Re:IP?

[aunchaki]

I doubt that he negotiated this arragement upon his leaving. He more likely arranged it long ago, when his future value to the company outweighed the potential value of his contributions.

This does seem unusual (and not just for Microsoft). He had to have hammered this out long before his creations spawned a cash-cow like Word.

In the age of corporate consolidation...

[E-Rock-23]

Will Microsoft wait till the new company comes up with something truely nifty, and then buy it up (like they did to get their hands on Halo)?

Re:In the age of corporate consolidation...

[sql*kitten]

Will Microsoft wait till the new company comes up with something truely nifty, and then buy it up (like they did to get their hands on Halo)?

Possibly. If you read the NYT article, it does say that Microsoft have already negotiated first-refusal if the company ever comes up for sale.

How one codes without text syntax.

[Kaz Kylheku]

You start by decoupling the text syntax from the data structure representation of the program. The Lisp language does this. Having this separation, you can continue to use the text notation to code for the data structure which makes up the true source of the program. Or you can write programs that construct that structure, perhaps out of pieces that you codify using the text notation. Or you can do something totally different: make a GUI which lets the user manipulate objects, and have that object manipulation generate data structures which represent programs that are compiled and executed. The technology for doing this has existed for a long time already.

He gets to keep his work....no suprise

[Dynedain]

Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.

If he patented stuff, he owns the rights to it and can use it if leaves MS. Now if his work was patented in MS' name, then he couldn't take it.

Right to crush^H^H^H^H^Hnegotiate...

[Spazholio]

And Microsoft holds a right to be the first to negotiate with Intentional Software if the company comes up for sale.

It sounds like Simonyi just handed the executioner his axe and said, "Now, don't use this UNLESS I say it's ok..."

Incredible!!!!

[Glanz]

This is the best news for thworld and the worst news for Monopolosoft since Myself.!!!! Great news!!!!!

Type makes a difference

[ACNeal]

Depending on the context, this can be quite useful. Especially if you want to refer to X in several different manners.

There is no one naming convention that solves all problems.

This notation style is quite nice of a contracting firm that has a lot of different eyes on the project through out its life.

If I know the graphical control is the only one of its kind on a form, say an option button, the prefix "opt" jumps right out at you in code.

Or let us say that you have a selection of an item, and then additional information to gather for that item. optItem and txtItem is a lot simpler and extremly obvious, as opposed to item_chosen_or_not and item_value.

Then again all my loop counters are i,j,k,l, etc. I really have a problem naming loop counters simple enough to not be annoying, and more descriptive than i. The loops tend to be pretty ovious upon inspection, so the time wasted thinking up a good name is just that, wasted.

There is no one right school. If everyone agrees on a convention that will be working on a specific problem, then that is a good convention.

Re:Type makes a difference

[gmack]

That works right up until somone changes the variable type and doesn't bother to rename every occurance of the variable. Think porting from 16 to 32 bit or 32 to 64.

It seems to me that a lot of these rules are simply there to cover for bad coding practice.
The best way to fix this is to make your functions short enough that the types are a quick glance away at all times.

Re:Not a flame or troll (no, really, I swear)

[briglass]

Yeah I saw this on CNN and BBC.

Yup

[0xdeadbeef]

But I hate it when my programs get stuck in the vacuum cleaner.

he's not the first

[mirko]

"simplify programming by representing programs in ways other than in the text syntax of conventional programming languages"

Has he heard about COLORFORTH ?

Re:No

[elphkotm]

Yes, mod him the fuck down because he's reasonable!

Comment removed

[account_deleted]

Comment removed based on user account deletion

Free blah di blah

[frovingslosh]

"The New York Times reports (printable version) (Free blah di blah)

Hey! The printable version that was linked to didn't blah di blah me when I tried to access it! Maybe this is the cure for all of the NYT registration stuff, link to the printable version rather than the one with ads. Of course, I'll miss seeing all of the ads, but I'm willing to make the sacrifice.

Re:Free blah di blah

[tibbetts]

That's why I included the direct link to the printable version. Don't trumpet this "hole" too loudly, though; it'd be a shame for NYT to take away the ability to go directly to the printable page. At the same time, maybe this isn't as great as it looks, since I can't find any way to go directly from the home page to the printable story links without manually massaging the URLs...

Re:Free blah di blah

[AragornSonOfArathorn]

heh... you're right. They'll probably figure this out soon, though and change it back to needing registration

Re:He wrote Word

[NineNine]

Bugs generally have nothing to do with a top level architect. This guy's created Microsoft's most successful software, the the software that everybody else tries to copy (Open Office, Star Office, etc.). This guy rocks.

Re:He gets to keep his work....YES suprise

[victim]

Companies can not get patents. Typically the human gets the patent and assigns the rights to the company.

A quick peek into the USPTO shows the Simonyi has something like 8 patents (probably from two applications, one of which was split into many parts) all of which are assigned to Microsoft.

So, Microsoft must have granted him rights to use the patents in his new venture. And Microsoft must have gotten something in return or they have not acted in the interest of their shareholders. What they got is the mystery.

Bravo was the first WYSIWIG editor

[leighklotz]

Charles Simonyi didn't just create "a text-editing program that later became Microsoft Word" as the Slashdot story says; he wrote the first WYSIWIG editor at the place that invented the concept, in 1974. Note that 1974/1975 saw the development of BITBLT, WYSIWIG editors, PDLs, icons, and pop-up menus.

See PARC's history and search for "Bravo", or read the summary below:

1975

Engineers demonstrate a graphical user interface for a personal computer, including icons and the first use of pop-up menus. This interface will be incorporated in future Xerox workstations and greatly influence the development of Windows and Macintosh interfaces.

1974

...Press, the first PDL, is developed by PARC scientists and greatly influenced the design of Interpress and Postscript.

The Bravo word-processing program is completed, and work on Gypsy, the first bitmap What-You-See-Is-What-You-Get (WYSIWYG) cut and paste editor, begins. Bravo and Gypsy programs together represent the world's first user-friendly computer word-processing system.

BITBlt, an algorithm that enables programmers to manipulate images very rapidly without using special hardware, is invented. The computer command enables the quick manipulation of the pixels of an image and will make possible the development of such computer interfaces as overlapping screen windows and pop-up menus.

Programmers

[Rupert]

First off, I am a long-time C++ programmer (and C before that) with a recent conversion to Perl for anything involving munging text files.

It has been brought to my attention that no sane programmer would design a record keeping system that involved giving the a customer a text editor and a manual and making him enter his records in a particular format in files with a particular name and extension. Yet that's exactly what we do to ourselves with programming languages.

What we need is something that goes from UML all the way down to ASM, and more importantly, all the way back up. Editable at every level in between. Use colour, fonts, sounds and whatever else you want to indicate the age of a piece of logic (at whatever level), who last changed it and /why/. If you're mucking around at the low level and it's making your high level design look a mess, take it as a clue that your design is not clear. Sure, there are exceptions that have to be coded for. Get them in the model at the right level and save yourself some work. I know programmers who have worn out the Cs and Vs on their keyboards, they cut and paste so much (yes, Windows, sue me).

I don't imagine this is going to be easy. However, the implementation is almost certain to be easier than getting people like me to start using it. Perhaps you youngsters should just write off everyone over 22 and start again. You'll thank us when we're gone.

Re:Programmers

[hey!]

It has been brought to my attention [mindprod.com] that no sane programmer would design a record keeping system that involved giving the a customer a text editor and a manual and making him enter his records in a particular format in files with a particular name and extension

I guess we can conclude from this that no sane programmer chooses programmers for his customers.

I think its' remarkable how well text editing files suffices to the needs of programmers. As a programmer who is the customer of other programmers, one deals with two aspects of their work: logic and metaphor. The things which are the most work-a-day useful tend to be rigorous in the logic department and rather pitiful in the metaphor department. The behavior of a data structure like a B-tree is rigorously defined. I do not expect to find sap running from its root to its leaves.

That's a silly example, but most of the time I see attempts to revolutionize programming comes down to creating new metaphors for logic. Programmers are terrible at metaphorical thinking (which is why we usually create terrible user interfaces), and once you are in the business of ginning up new metaphors, it's hard to know when you've gone from the sublime to the silly. Usually it's a short trip.

The most successful metaphors in programming are ones that are worn smooth with time and usage. The figurative computer file is more familiar than the real thing and the shortcomings of the metaphor are are not shortcomings because we know what to expect from a file's behavior. I'm not saying there won't be successful new ways of looking at programming, but I don't expect to see it revolutionized any time soon. I'm skeptical of systems that tie things up in some kind of seamless web of something-or-other because sooner or later the limitations of the metaphor being imposed on the programmer will become apparent.

Re:Programmers

[WhaDaYaKnow]

Use colour, fonts, sounds and whatever else you want

I know of a nice website you might like. Uses the same paradigm. ;-)

Re:Programmers

[GOD_ALMIGHTY]

That's what the Open Source Java community is trying to do.
Check out Argo UML, it generates code from the UML diagrams, which is not that original, but it's pretty good, and open source.
One of the main reasons the Java community is moving towards this concept is the reflection and introspection capabilities in Java, combined with the BECL project at Jakarta we can hand craft .class files if we want.

The frameworks like J2EE and Struts are implementing common patterns, aleviating the tedious coding and allowing us to focus more on design and architecture. Since these frameworks are well defined we have code generation tool like XDoclet and Middlegen that handle the needs of the framework while we only write the business logic.

Java looks pretty big with all the acronyms you'll find on Sun's site, but since the tools started to develop, most of the work is reduced to design, architecture and coding business logic. When I use a J2EE application server like JBoss I don't have to deal with setting up and tearing down database pool connections. JBoss provides my Enterprise Java Beans with this. Threading is handled by the server as well as persistence and synchronization with the database. Because these things are well defined and allow you to integrate hand coded stuff if you need more flexibility I am freed from solving the same problems that people have solved 15 times before. I can also migrate to a new application and be pretty certain that I'll be able to seperate the core logic from the system maintainence and utility code that any app would need.

It's not perfect YET, nor do we have the whole UML to ASM and back thing, but with gjc (java gcc front end) and the classpath project we're getting there.

You should see the reuse too. The well defined APIs and frameworks make integrating other people's code easy, and the OOPness of java allows everything to act as a library. Just look at any established open source Java project and you'll see they've built of many of the other projects out there.

Granted I'm a bit of a fanatic, I've been doing both open source and Java for about 6 years, but I've yet to see any development system that had this much promise and consistently delivered. Check it out, you won't be sorry.

You can find these projects at Sourceforge or jakarta.apache.org and xml.apache.org.

Re:Programmers

[ralphbecket]

Umm, no. What we need is something that allows us to precisely specify (i.e. not UML) the relationship between input and output at an high level of abstraction, in a form that can be automatically turned into an efficient, working program, with the minimum amount of attention paid to language-enforced bookkeeping.

Such things already exist and they are called declarative programming languages (check out Mercury, Haskell, OCaml, ML and so forth.)

(Note that imperative languages fall short of the ideal since the relationship encoded in an imperative program of any size is very hard to identify. This is one of the reasons why they're so difficult to debug.)

Unfortunately no-one has yet come up with a general purpose graphical notation that has the brevity, clarity and precision of mathematical notation. Declarative programming languages come closer to the mark than anything else.

My guess is that no 2D graphical notation will be sufficiently expressive for all but the simplest tasks (check out the work on interaction nets for best effort so far.)

not really

[ch-chuck]

Multiplan tanked, basically, because it ran too slow. The world went from Visicalc to 1-2-3. You can read the Billster say so himself here

BTW, everyone check out the rest of that interview, lots of interesting stuff, like "School Experiences: BG: 'We were kind of desperate to get free computer time one way or another. ' " and "Writing An Altair BASIC:
'I was fairly self-confident in those days. We didn't know how long it would take us. And it was kind of funny because we were sort of acting like we had it already.'".

aha !

[__aahlyu4518]

"simplify programming by representing programs in ways other than in the text syntax of conventional programming languages,"

Oh... you mean like Magic ?

fyi

[Anonymous Coward]

Calling Microsoft 'M$' is a sign that you're a retard.

The fact that you couldn't even do it right removes all doubt from my mind.

Re:fyi

[thegoldenear]

calling them MS$ is a sign of even worse

taken to extremes, anything is brutal

[mckwant]

I once saw a spec (back in my VB programming days) that had something like four or five parameters in the hungarian notation before you even got to the variable name. something like

intLocalFnnameModulenameX

THAT gets a little absurd, IMHO. Not arguing that intX, or even intLocalX isn't useful, but you can twist yourself around an axle pretty damn quickly with this stuff.

Programming language w/ visual features

[weird mehgny]

Here's one.

Here is the URL

[null-und-eins]

http://intentsoft.com/

Check out the FAQ, some entries are just hilarious.

http://intentsoft.com/faq.html#q11

bad choice of words

[deft]

'Mr. Simonyi has --left-- Microsoft with the right to use the intellectual property he developed and patented while working there.'"

"Left", as in he left it there, for them to use, or...

"Left", as in departed with that right so that it was no longer there and they couldnt use it.

dont tell me i need to read the damn article.... :)

Re:bad choice of words

[verbatim]

I think they mean

"Mr. Simonyi has [departed] Microsoft with the right to use the intellectual property he developed and patented while working there."

Meaning that Microsoft holds the patents and he has been given the right to use them without forking over license fees.

Re:bad choice of words

[great throwdini]

This is a good point. Does this ambiguity trip up non-native speakers in addition to native speakers aware of the duplicity in meaning, I wonder... Context seems to make the meaning somewhat clear, though. The presumed typicality of the first meaning leaves only the second as suitably "amazing"...

Re:bad choice of words

[youBastrd]

You're right, this is ambiguous. How about:

( ("Mr. Simonyi has left Microsoft")
"with the right to use the intellectual property he developed and patented while working there" )

Intentional Programming

[GuyZero]

Wow, I get to be the first person to post something actually informative.

Simonyi was big on what he called 'Intentional Programming' (yes, as opposed to UNintentional programming, which is what we've been doing all along I suppose.) It's been in the works since at least '94 which is when a classmate of mine went to work on the project after graduating.

He got shafted as the power inside the dev tools group shifted. Most of his group got cut loose and ended up looking for other positions, Oddly enough, Simonyi himself left the group and gave up on it a year or so ago apparently without telling the remaining core of the group.

See:

http://web.archive.org/web/20000815211509/http:/ /w ww.research.microsoft.com/ip/
http://www.edge.org /digerati/simonyi/simonyi_p1.ht ml
http://www.omniscium.com/nerdy/ip/
http://www .aisto.com/roeder/active/ifip96.pdf

Re:Intentional Programming

[Anonymous Coward]

Oddly enough, Simonyi himself left the group and gave up on it a year or so ago apparently without telling the remaining core of the group.

Not odd considering Simonyi's reputation: headstrong, brilliant, utterly impractical, lacking in organizational and leadership skill.

According to friends, Simonyi had a history of losing direct reports due to poor decisions and poor communication skills. Over time, he was ousted from important positions within Microsoft, and kept happy by having free rein over an Intentional Software research project; when this produced nothing practical after nearly eight years, he was ousted from that too.

I should also add that (according to these same friends) the work that Simonyi did accomplish in the research space was very novel and innovative; most posters claiming otherwise lack any concrete knowledge of Simonyi's techniques.

Assuming the organizational and managerial talent comes from elsewhere (and Simonyi certainly knows his strengths and limitations,) Intentional Software will be one to watch in five years' time.

Hugarian notation is EVIL

[wowbagger]

Hugarian notation is EVIL, and here's why.

Consider a large program, in which we manipulate lots of ints. We have lots of pointers to ints, so our code looks like:

....
int *piFoo = &bar;
*piFoo += 1;
*--piFoo = 5;


and so on.

Now, we discover that ints aren't big enough - we need to use longs.

....
long *piFoo = &bar;
*piFoo += 1;
*--piFoo = 5;

...


OK, now we have two equally bad choices:
1) We leave the variable names alone. But now they are lying, and therefor are introducing more errors.
2) We change the variables. Now what SHOULD have been a simple change is rippling all over the code.

Even if you do as you should, and use a typedef, things are still bad:

....
typedef int Thingy;

Thingy *pThingy_mythingy = 0; /* ????? */

....


How do you create the "warts" for typedefs without creating ambiguity?

It gets even worse if you have structures:

...
struct Narf
{
int *pi_Poit;
};

....
*narf.pi_Poit = 5;

....


Now, you have to rev all the items that reference that structure, all documentation that refers to that structure, etc.

I can somewhat understand the use of a leading "p" to indicate "pointer to ...." but otherwise the notation creates more problems than it is worth.

The proper place to trace variable types is not in the name of the type! It should ideally be traced by your editing environment, along with the location of the variable's definition, the location of it's instantiation, the location of it's initialization, and any comments that you want to assign to the variable.

Re:Hugarian notation is EVIL

[gidds]

Agreed in spades!

IME with C, the type is usually either irrelevant to what you're doing, or clear from existing code. It's far more important to know the scope of a variable with that, you can quickly find the definition if you do need to know its type. (And of course, having to keep paging up to find types is a sign of badly-structured code.)

A handful of single-character prefixes will do the job neatly, e.g. nothing for variables defined in this function, `p' for function parameters, `s' for statics defined in this file, `g' for global variables, etc. We found these far less obtrusive, and far more useful, than type prefixes.

(In Java, you don't even need those - the only useful qualifier is one to distinguish instance variables from local ones (e.g. a single underscore for the former). But even that's not necessarily worth the bother.)

Re:Hugarian notation is EVIL

[Amazing Quantum Man]

Yep. The only two Hungarianisms that I ever use are "p" for pointer, and "m_" for member (got that one from Visual C++). The latter one is useful for distinguishing between members, locals, and globals (though "::" works in for globals, and a member function should be small enought so you could see the declaration).

Re:Hugarian notation is EVIL

[Tim Browse]

Now, you have to rev all the items that reference that structure, all documentation that refers to that structure, etc.

Well, of course, that's why you don't let people see your data structures, and why you provide accessor functions to use structure values, so all this kind of thing is encapsulated.

For what it's worth, I don't use full Hungarian notation either. What I use can be summarised as:

• p - for pointers
• m_ - for member data
• s_ - for static member data
• g_ - for globals
• i - for an index
• f - floating point
• n - for an ID that is not necessarily an index
• c - for a count of a number of items

I find that subset helps me a lot.

I certainly don't distinguish between ints and longs, etc.

Tim

Re:Hugarian notation is EVIL

[wowbagger]

Well, of course, that's why you don't let people see your data structures, and why you provide accessor functions to use structure values, so all this kind of thing is encapsulated.

This is great in C++ (where HN makes even less sense) but in C it is a little hard to make accessor functions.

Plus, I could argue that if you are going to write foo->piBar = 0, that you should also write foo->piBar() - after all, isn't it important to know the return type of the function at a glance?

As to your rules: I'd rather have my code like this:

int option_count = 0;

than this:
int c_option = 0;

As for distinguishing between members and non-members, static, global and local, function parms and non-parms:

1) Globals very bad. File Statics bad. The number of globals and statics should be small enough that you have no problem remembering who's who. Also, the names should be VERY distinctive. If you need a convention for identifying globals or file statics you are ALREADY doing something wrong.

2) Members are either accessed off an object or within an object. In the first case it is very apparent they are members, in the second case the only things you could confuse them with would be locals or function parms.

3) Locals should be limited in scope enough that you can see the whole scope at one time. Therefor you don't need a way to differentiate them.

4) Functions should be small enough that you can see the whole function. The parmeter names should be obvious anyway.

Re:Hugarian notation is EVIL

[Tim Browse]

1) Globals very bad. File Statics bad. The number of globals and statics should be small enough that you have no problem remembering who's who.

Like gotos, a few globals or statics used wisely can be very useful. FWIW, I rarely use globals (usually when knocking something up to test an idea), and file statics I pretty much never use - I use class statics.

Also, the names should be VERY distinctive.

Did you miss the part where I said I put "g_" or "s_" at the start of globals/statics? What's the alternative? ThisIsAGlobalVariable_NumberOfUsers? Well, it's VERY distinctive, but I'm not sure it's what I'd use.

If you need a convention for identifying globals or file statics you are ALREADY doing something wrong.

I have a convention for globals and statics so that the poor maintenance programmer (you remember them? They don't know nearly as much about your code as you do) gets a big warning plastered across the variable, saying "This is not local!" I consider this good, and certainly not evidence that I am doing something wrong. If you think globals/statics are inherently bad, go read about the Singleton design pattern.

2) Members are either accessed off an object or within an object. In the first case it is very apparent they are members, in the second case the only things you could confuse them with would be locals or function parms.

Yeah, in an ideal world. But you're not in an ideal world - you're in a world where other programmers usually have to read and understand your code under time pressure. Personally, I give those guys all the help I need - not least because one day it will be me thanking the original author for making things clear.

As for "only" being able to confuse them with locals or parameters, I put an "m_" at the front precisely so it's not possible to confuse them. At all.

3) Locals should be limited in scope enough that you can see the whole scope at one time. Therefor[sic] you don't need a way to differentiate them.

4) Functions should be small enough that you can see the whole function. The parmeter names should be obvious anyway.

"Small enough?" So they fit on a screen? So I can't have functions larger than about 45 lines? (What I can see on screen)

"Should"? Citations please. (Mine? See Section 5.5, "How Long Can a Routine Be?" in "Code Complete" by Steve McConnell. The research is by no means conclusive, and sometimes seems to suggest longer routines are better)

Tim

I think the article is incorrect...

[leshert]

It states:

Mr. Simonyi's departure, to be announced today, will leave Microsoft with only three senior people from the team that led the company in the early 1980's: Bill Gates, a co-founder and the company's chairman; Steven A. Ballmer, the chief executive; and Jeffrey S. Raikes, a group vice president.

I'm pretty sure Marc Macdonald is there again; Marc was the first employee of Microsoft.

Intentional Programming and Simonyi

[gym shorts]

Simonyi was into Intentional Programming. In IP you express the "intent" of your system. Binding the intent to an actual implementation can be handled automatically for a particular target platform. Not sure if this stuff was just a pipe dream, or if they (MS) ever got anything to work.

http://www.aisto.com/roeder/ip/

It will never work

[jmvidal]

If pictures were more powerfull than text then I would be drawing a you a picture of this argument instead of writing it.

I challenge you to draw a picture of this argument.

Re:It will never work

[DiS[EnDeR]]

=== The Argument === Visual Representation === :(

Oh Great...

[DiS[EnDeR]]

just what the world needs, more LabView Programmers...

Re:This could be key...OFF-TOPIC?

[WheelDweller]

The guy left Microsoft with IP regarding Word Documents. I'm interjecting that some of that information would simplify the transition of desktops from Microsoft to OpenSource. How the hell is that off topic?

"Negotiate"?

[chowdmouse]

And Microsoft holds a right to be the first to negotiate with Intentional Software if the company comes up for sale.

"PR Speak to English" translation: "If they make something we want, we'll take them over and crush them."

Re:"Negotiate"?

[haapi]

Actually, "right of first refusal" is a pretty common property law concept.

OOP is great, RIGID object models are bad

[JohnDenver]

I've gotten pretty far merging relational and object models.

Personally, I find OOP can be a bit rediculous when everything is mindlessly reduced to a rigid object model as dictated by some guy's rigid methodology. (Not all are rigid)

What I've found, is that most of the time is a matter of versatile interfaces. Myself wanting the best of my procedural language and SQL, I found myself creating interfaces that implement smart tables. A smart table is an object that exposes an arbitrary number of properties, like that of a named collection. Unlike a normal named collection, a smart table allows you to implement adhoc rules (changing this field causes this), using code, stored procedures, etc. Need more than just smart properties? Fine, derive from the Smart Table base class, and add your own functions (usually stored procedures)

Re:OOP is great, RIGID object models are bad

[Tablizer]

(* Myself wanting the best of my procedural language and SQL, I found myself creating interfaces that implement smart tables. A smart table is an object that exposes an arbitrary number of properties, like that of a named collection. *)

Interesting. But, how is this different than an associative array (dictionary) of attributes/properties?

Re:OOP is great, RIGID object models are bad

[Tablizer]

(* Not sure if this is what the original author was proposing, but one difference that I see is that Associative Arrays are weakly bound. I personally prefer strongly bound methods/properties because if they break, they break at build time rather than at run time. *)

One problem with strong-typing based on fields that come from the database is that if you change the schema type, then it is out of sync with the code. Relational databases are not going away, like some OODBMS fans have hoped. Therefore, we must deal with the issue of mapping RDB field types to code (if a strong-typing-preferring shop).

The most logical place to get such information is from the table schemas, and not the code. But, this requires some sort of integration. This is one of the reasons I prefer dynamic typing: it is easier to share information from different systems and languages and databases. Pre-defined types kind of incorrectly assumes and insular world.

Compiled types can be *more* likely to break code in some circumstances. For example, using the previously mentioned CustomerID example: the CustomerID may be changed from numeric to string because of a merger where one company uses alpha ID's.

In a dynamically typed (or type-free) program, a schema change would not likely affect the program, but would probably crash a compile-time bound one because the database field type differs from what the compiled program is expecting.

Thus, strong-typing does not always add extra protection.

Re:OOP is great, RIGID object models are bad

[leandrod]

> One problem with strong-typing based on fields that come from the database is that if you change the schema type, then it is out of sync with the code.

But this is good! If a data type changes, code around it must change. The same comparisons are not anymore valid, for instance.

The way too keep code stable is to begin with a good data model. Granted, SQL makes this impossible by not supporting domains as required by the relational model: what it calls domains are ridiculous. But if we had real domains, and domain Specialization by Constraint, then they would be stable and precise, and seldom code would need a data type change.

> Relational databases are not going away

I sure hope not, once they arrive indeed. Up to now, we have only Alphora Dataphor, and that is not yet a full-blown DBMS, not to mention being proprietary and MS W32-only. Remember and repeat to yourself: SQL is not relational!

Be sure to read The Third Manifesto and its clear, logic, simple proposal for rich, precise, reusable type hierarchies thru Specialisation by Constraint.

Re:OOP is great, RIGID object models are bad

[Tablizer]

(* [you change the schema type, then it is out of sync with the code.] But this is good! If a data type changes, code around it must change. The same comparisons are not anymore valid, for instance. *)

No, that is often not the case.

Things that are more likely to change are things where non-equality comparisons are less likely.

For example, with CustomerID, you almost never use greater-than or less-than. ID's are either equal or not. In biz applications you mostly do those with money or quantities.

Neither approach is perfect at handling change, I admit, but often dynamic typing is the less of two evils IMO.

(* SQL is not relational *)

Perhaps we should make a distinction between "street relational" and "pure relational". Until/if the industry starts to back pure relational, I am not going to assume/wait for it to happen, and try to work with what we have now WRT "relational".

BTW, I am all for overhauling SQL. I have kicked around new syntax and structure for such. It tends to resemble functional programming in many ways.

Re:OOP is great, RIGID object models are bad

[leandrod]

> Things that are more likely to change are things where non-equality comparisons are less likely.

And why non-equality comparisons should be special?

> For example, with CustomerID, you almost never use greater-than or less-than.

Which comparison operator are mostly used is immaterial. The real thing is the domain itself. For example, CustomerID cannot be compared, say, to SaleID. They are different domains. Now, if you map any of this domains to a specific language data type, and you want this language to use dynamic typing, your call. But do not let your language do meaningless cross-domain comparisons.

> Perhaps we should make a distinction between "street relational" and "pure relational".

No, we should make a distinction between relational and non-relational, SQL being non-relational. But if you want, you can call it quasi-relational. But it is not relational, simply because relations are sets, while SQL tables are bags. And bags, by definition, are not sets and do not behave as such.

> Until/if the industry starts to back pure relational, I am not going to assume/wait for it to happen, and try to work with what we have now WRT "relational".

So you only will used something good if everyone does? BTW you do not have to wait, unless you want it free. Go Alphora Dataphor.

> I am all for overhauling SQL.

SQL must be thrown away, not overhauled. It is too inconsistent, illogical and idiosyncratic for overhauling.

> I have kicked around new syntax and structure for such. It tends to resemble functional programming in many ways.

If you do not want to do the right thing and go relational, at least do not wast your efforts by duplication. Go SchemeQL.

Re:OOP is great, RIGID object models are bad

[Tablizer]

(* And why non-equality comparisons should be special? *)

I am simply weighing the probability that something will or won't happen.

(* For example, CustomerID cannot be compared, say, to SaleID. *)

I don't see what this has to do with our discussion. How would compile-time type checking prevent such? (Barring making each field its own type.)

(* So you only will used something good if everyone does? BTW you do not have to wait, unless you want it free. Go Alphora Dataphor *)

Because other developers will look at me cock-eyed if I try that. Something too different won't be accepted so easily. If you want to push for a relational overhaul revolution, go ahead. I have enuf causes on my hands.

(* Go SchemeQL *)

I will look into it.

Re:OOP is great, RIGID object models are bad

[leandrod]

> How would compile-time type checking prevent such?

I am not speaking about variables, but domains; that is, data types. A SaleID and a CustomerID must be, by definition, different data types logically speaking, even if it happens that their physical implementation be the same.

> other developers will look at me cock-eyed if I try that.

Are you such a weakling that will not do anything which is not socially accepted? Who cares if your code is cleaner, faster, more correct, easier to understand?

Re:OOP is great, RIGID object models are bad

[leandrod]

> my Postcript reader barfs on it.

Well then, Google is your friend. Or you can write the authors, or use GhostScript.

Re:OOP is great, RIGID object models are bad

[Tablizer]

(* I am not speaking about variables, but domains; that is, data types. A SaleID and a CustomerID must be, by definition, different data types logically speaking *)

You don't propose defining every fricken field as an ADT-like thingy, do you?

(* Are you such a weakling that will not do anything which is not socially accepted? Who cares if your code is cleaner, faster, more correct, easier to understand? *)

I am learning that the social viewpoint is more important than the technical one. I wish it was not that way, but the world is run by salespeople, and it mirrors them. Soapboxes at the workplace have not got me anywhere. The pay and kudos goes to those who shut up and go with the flow. (Thus, I save my ranting for the web.)

"Easier to understand"? If they are completely unfamiliar with your relational overhaul, how the heck can it be easier to understand without boatloads of training?

Re:OOP is great, RIGID object models are bad

[leandrod]

> You don't propose defining every fricken field as an ADT-like thingy, do you?

I am not much into ADTs, so I cannot be very precise. Usually I find OO terminology to be much more complicated and less precise than I would like it to be. But as I understand them, yes. This is fundamental to make the whole database system more logical, easier to use, and would make for error elimination and code reuse. For more details, please read the proposal for type inheritance thru Specialisation by Constraint from Christopher J Date and Hugh Darwen, in either An Introduction to Dabase Systems or The Third Manifesto.

And why do you see a problem with this? It is a database functionality that can do no harm. If a programming language wants to map the database attributes into its own, simpler types and do cross-type operations, fine. It would loose some of the error checking of which the database language is capable, but while it used the database sublanguage to do queries and other constraints.

> "Easier to understand"? If they are completely unfamiliar with your relational overhaul, how the heck can it be easier to understand without boatloads of training?

You only think the relational concepts harder to understand because you are a procedural programmer, and are used to navigational databases. Take someone who either knows the basics of sets and logic, or who is familiar with functional programming, or simply has not exposure to programming, and relational is much simpler.

Specially, relational is simpler for the end user and application programmer because it is totally logical, both in the sense of logical level schema and in the sense of coherent, simple, according to reason. The physical details of SQL and navigational databases are left to DBAs, SysAdmins and system programmers, and all the inconsistencies of SQL are just left behind.

D 'n D - Been There, Done That

[SonOfFlubber]

Drag 'n Drop one's own programs together? Been there, done that, in 1994 no less. NeXTStep Developer.

Re:He gets to keep his work....YES suprise

[GuyZero]

What does Microsoft get?

Bill gets Charles out of his hair, that's what. The guy was probably too much trouble to keep around and it was easier to give him some (to MS) worthless IP that to keep dealing with him.

Also, he is kind of Bill & Steve's buddy from way back - Simonyi was, what, employee #4 or something?

For those looking for more on Simiyoni and Bravo

[joeflies]

I just finished reading Dealers of Lightning which has extensive writing about how Simiyoni got to Xerox and his career there.

His leaving is good for microsoft

[aoteoroa]

It sounds Simonyi has an idea that could be comlimentary to Microsoft's goals He wants to develop a new revolutionary improvement to programming and good programming tools help sell operating systems. The huge number of programs that run on the Windows is probably Microsoft's most significant advantage over Linux, and MacOS (for now anyway).

A visual method of coding data structures, sockets, buisiness rules etc could do for programming what RAD tools did for GUI development. RAD tools enabled someone with very little programming abilitity to build useful programs.

If his ideas are a real success Microsoft might try to buy out Simonyi's company and reintegrate it with the Visual Studio family in the future.

Hungarian notation

[vadim_t]

It can be very useful, when used right. I've been using it for a while, but now I'm moving away from it, excepting for UI elements. I find it useful to have mnuSave(menu) and cmdSave(button), for example. It also saves some clutter in IntelliSense, for example when I know there's a button for exiting, but I'm not sure if it's called cmdExit or cmdQuit.

Now, when writing code I almost never use it, excepting cases when I want to make something obvious, for example bDone would be a Boolean value. It makes it absolutely obvious to everybody else that it's not a counter of how many files have been processed or something of that kind.

I find going any further than that extremely messy. I remember seeing a variable with a 10 character hungarian prefix somewhere. Yuck!

Types in Names

[fm6]

I admit that it often (not always) makes sense to embed type information in a variable name. But HN has always struck me as a very clumsy way to do it. When I was trying to read Petzold, deciphering all those obscure prefixes was very distracting. Of course part of the problem was that Win16 prefixes had to describe not just the data type, but the addressing model with which you accessed it. So szSomething (zero-terminated string) usually wasn't specific enough -- it had to be something like lpszSomething (long pointer to ...). And then there are pointers to pointers, arrays of pointers, constant values... Boy, do I not miss segmented architecure!

For my part, I refuse to embed type names unless my code is complicated enough to make it hard to track all the variables or when I have to name two related variables that use different types. And when type information is necessary, I use plain English: MainForm, not fMain. Maybe not a good idea if you're writing huge bodies of C++ code with hundred of global variables. But not all of us do that.

Re:Types in Names

[daffmeister]

Amen to that.

My big objection is that it makes variables harder to read, and puts the mind's focus on the detail of the variable rather than the algorithms, which is where most errors are likely to occur.

I've always agreed with the proposal that variable names should be pronouncable.

Very interesting!

[Arakonfap]

Nice link - The ideas behind "intentional programming" sound rather interesting. Making a language for abstractions would surely ease programming by huge amounts, especially with how the abstractions sound adaptable to new events and problems.

If it ever succeeds, it will be quite interesting.

There was a tone towards the end though that was a bit scarey - it almost made it sound like the abstractions themselves could become a popular commodity. That could be a scarey day, especially with the patent and copyright laws.

Facinating idea still.

Re:Also see Go To

[ashitaka]

Which, ironically, I just yesterday finished reading the chapter on Simonyi.

Good insight into why Word works with block of text instead of a stream as WordPerfect does.

Re:He gets to keep his work....YES suprise

[glv]

And Microsoft must have gotten something in return or they have not acted in the interest of their shareholders. What they got is the mystery.

I don't think it's such a mystery; the article explains it in the very next sentence. "And Microsoft holds a right to be the first to negotiate with Intentional Software if the company comes up for sale."

Microsoft has apparently decided that Intentional Programming isn't worth pursuing; they've dropped the project. So as things stood, they weren't going to see much return on the work they paid for. But Simonyi wants to pursue it as a private venture. Great! Let him fund further work, because he's a true believer. And if it starts to look more successful than they thought, they can go buy it back.

(Besides, it doesn't say they signed over the rights to the patent; it just says that he "has left Microsoft with the right to use" the stuff. So essentially they've just given him a free license to his own patent.)

Aspect-oriented programming and Java?

[alispguru]

Could it be that the real reason Simonyi wants away from Microsoft is that he's interested in aspect-oriented programming? And the language that's getting the buzz in aspect-oriented programming is AspectJ, where J stands for Java? And promoting Java would be a career-limiting move at Microsoft for anyone these days?

Instead of the Times article, look at this one in the Washington Post which gets a little closer to this interpretation.

Re:Aspect-oriented programming and Java?

[Proudrooster]

Yes, I think AspectJ is the reason he had to leave.

Re:Aspect-oriented programming and Java?

[geekoid]

the man is worth over a billion dollars. Do you think he would be concerned with 'career limiting'?

Re:Aspect-oriented programming and Java?

[jilles]

Simonyi has invented intentional programming, Kiczalez has invented aspect oriented programming. Both paradigms address the same issue: existing paradigms are totally inadequate for expressing solutions to programming problems.

Those two joining forces is big news. Kiczalez' use of Java has been a very pragmatic choice since other languages are either to primitive (C, Pascal, Modula) or to impopular (Lisp, Prolog, ..). Java simply had the right mix of being a popular language with advanced features such as for example reflection. This combination has allowed Kiczalez to take AOP out of the laboratory (Kiczalez has a lisp background) and create a production quality compiler that people actually can use to solve real world problems.

As such AOP has been a success and Java was just a tool to accomplish it (i.e. it is not a relevant motive in Simonyi's choice of leaving MS). Kiczalez is a researcher and naturally wants to move on. Intentional programming offers him a nice chalenge. Simonyi has billions, he has the right ideas and needs an environment where these ideas can be developed further. Microsoft is not such an organization so he starts a company where he can choose how to spend his money and can select the persons he wants to work with rather than MS giving him a budget, people and a set of limitations.

The company itself

[Nygard]

Odd that no-one's posted this yet.

The company can be found at http://intentionalsoftware.com/ with some vague-but-cool-sounding stuff about changing the world.

No thank you

[Fugly]

Try to reduce key-stroke redundancy, and figure out ways to reduce errors. A friend of mine and I once considered writing a language editor which guaranteed that at any time, the program displayed in the editor window was syntactically correct.

Ok, key-stroke redundancy is a stupid thing to focus on. The real time investment in good programming has nothing to do with how fast you type the program in. You should be spending at least twice the time in analysis, planning, and documentation that you do actually entering the code. A better area to focus on would be tying code, documentation, and visualization together. I hate updating documentation after making a change to an application, I want it to just happen. Lots of recent IDE's have made nice strides in this area for a multitude of languages recently. It really has a long ways to go though.

As for not allowing code that isn't syntactically correct to be entered, forget it. Every attempt I've ever seen at this has been unbearable to work with. Practically all text entry has been done with the mouse and it's incredibly restrictive. People enter code in different ways, I might copy a piece of code from a help file or document and paste it in to my editor then modify it. I might message a friend and he might e-mail me a snippet of a program he's written for another company. I don't want to try to duplicate stuff by point and click. Now, I have seen editors that will highlight any syntax errors. That's a little annoying from time to time but it's much less restrictive. It's sort of like having a word processor underline misspelled words...

Re:No thank you

[stevey]

The real time investment in good programming has nothing to do with how fast you type the program in.

True - but at the same time I am constantly astounded at the inability fellow programmers have to type properly.

I've worked in offices full of good coders, designers, architechts, and programmers who can't type more than 5 wpm!

I know typing speed isn't a good indicator of ability, or anything close, but it seems pragmatic to learn to use the keyboard when you're in front of one for 7+ hours a day.

(Plus it's handy for sending email / IRC when you're in a hurry ;)

Re:No thank you

[Fugly]

I've worked in offices full of good coders, designers, architechts, and programmers who can't type more than 5 wpm!

I've never worked in an office where there was a single developer that couldn't type. I can't imagine how somebody could ignore such a fundamental skill in their field. In my mind, that's just unprofessional behavior. That's like a carpenter not being able to use a hammer and nail. In that case, I'm not so sure it's the software that needs fixed as much as it is the developer. That's grounds for a company to send the lot off for training or can them in my opinion.

When I decided to major in computer science, the first elective I took in school was typing. Was it fun? Not at all. Was it necessary and important? Absolutely. I could have just taught myself using shareware or whatnot but I know that I personally have a hard time learning skills that aren't challenging or interesting without an outside force motivating me (such as a class).

Also, I hope 5 wpm is an exaggeration because I was typing 25+ wpm before I learned how to touch-type.

Ever heard of "search-replace"?

[Sanity]

This is a perfect job for even the simplest search-and-replace functionality.

Re:Ever heard of "search-replace"?

[wowbagger]

First of all, have YOU ever heard of it refered to as "search and destroy"? Quite frequently such operations end up screwing things up because the SnR tool got confused.

Second, you are driving changes in files that you shouldn't have to change. As a result, you clutter up your revision control system with a bunch of crap.

Third, if you deal with any kind of QA department, they will insist upon verifying all code that you've changed - "But it was a simple search and replace" won't cut it (nor should it!). So you will have QA time being spend on verifying a bunch of things that you shouldn't have to verify.

The whole idea behind ANY programming methodology, be it OOP, Hungarian notation, extreme programming, team programming, or whatnot, is to make things easier . Anything that adds more work than it saves is a loss. I assert that the time saved by being able to tell that piFoo is a pointer to integer is much less than the time costs Hungarian notation imposes.

Re:Ever heard of "search-replace"?

[kawika]

This is a perfect job for even the simplest search-and-replace functionality.

Sure, on a one or two person project that works fine. Now imagine you're on a a big project with five multi-person teams and someone decides they made a mistake defining the type on a Hungarian-style interface definition that a lot of the teams use. Without Hungarian notation, it's probably a one-line change to a single header file.

With the Hungarian need for variable renaming, all five teams have to make global changes to all their code. If they are sane they will do a thorough test of a complete build including only that change, because the next set of diffs are going to be a mess to use for figuring out any other logical changes. There's a good chance in many big-company structures that any change causing that kind of disruption will be subject to time-consuming and gumption-sapping review, especially since it's one group causing work for other groups. And it may affect design documentation and require more work there as well.

Re:Ever heard of "search-replace"?

[dillon_rinker]

Yup. There was a D&D module that was published that contained dawizard tables. Because the guy that wrote the module wrote about mages but the editor decided to call them wizards and did a search-and-replace.

Re:Ever heard of "search-replace"?

[Lagged2Death]

Quite frequently such [search-and-replace] operations end up screwing things up because the SnR tool got confused.

You shouldn't be using fully-automatic search-and-replace in this case. You should be doing the replacements one at a time, verifying in each case that the name replacement is correct and that the new type is indeed safe in the old context. This second point is vital; it's easy to create new bugs in old code by changing, say, int to long or int to unsigned.

Second, you are driving changes in files that you shouldn't have to change. As a result, you clutter up your revision control system with a bunch of crap.

On the one hand, I can see your point here. On the other hand, VC's job is to track the changes; if you're changing varible types frequently, then your VC store is going to reflect this to some degree anyway.

Third, if you deal with any kind of QA department, they will insist upon verifying all code that you've changed - "But it was a simple search and replace" won't cut it (nor should it!). So you will have QA time being spend on verifying a bunch of things that you shouldn't have to verify.

When you change a variable's type, you are making a change to all of the code that refers to that variable. It doesn't matter if you change the variable's name or not - the code that uses it must be re-compiled and certainly should be re-verified.

I assert that the time saved by being able to tell that piFoo is a pointer to integer is much less than the time costs Hungarian notation imposes.

My experience has been otherwise, but this is something reasonable people can reasonably disagree on. One thing many HN critics overlook is that you don't have to buy in to the whole system all the time if you don't want to; you can scale it down to whatever level you find useful, and stick to that.

Re:Ever heard of "search-replace"?

[mesocyclone]

If you name your variables well, search and replace will easily change your hungarian notation without screwing things up.

And really, how often do you have to change the types of variables?

The tradeoff for the very rare case where you have to change a variable name en-mass is a program where somebody else can read it and know without cross referencing something about the typing of the variables we are looking at. Or you can go back a year later and see that one variable is a string and another an integer.

We use HN in Java, and I find reading other code that does not use it to be harder than reading our code.

It wasn't invented to make the original coding easier. It was invented to make code *maintenance* easier... and the most common problem in code maintenance is reading and understanding someone else's code, not changing a variable name.

I suspect variable naming is like editor preferences. There are strong, almost religious beliefs on the subject, and they are held more or less randomly among different people. I like hungarian notation and I like vi (and variants). Maybe you like non-hungarian and Emacs.

Re:Ever heard of "search-replace"?

[TeXMaster]

Yup. There was a D&D module that was published that contained dawizard tables. Because the guy that wrote the module wrote about mages but the editor decided to call them wizards and did a search-and-replace.

Of course a smart someone would have used "whole words only" (\<mage\>) for you RegEx fans).

Re:Ever heard of "search-replace"?

[Wildcat J]

This is a perfect job for even the simplest search-and-replace functionality.

Yeah, and the last guy that tried that does work here any int32er.

-J

Re:Ever heard of "search-replace"?

[Wildcat J]

Ahem... "search-replace" s/does/doesn't/ ;)

-J

Re:Ever heard of "search-replace"?

[egomaniac]

We use HN in Java, and I find reading other code that does not use it to be harder than reading our code.

Of course. You're used to it. Reading something you're used to is always easier than reading something you're not. We write Java sans HN, and I promise you that I would have an easier time reading our code than yours.

I do not understand the justification for using HN in Java -- I have been writing Java code for six years now, and I very much doubt that I've wasted a lot of time wondering "Hmmm, I wonder what type of variable this is...". Java doesn't have most of the complexities of C/C++ with respect to types (no confusion about whether something is a pointer or not, for instance), so what's the reason for using HN in Java? How can the benefits possibly outweigh the cost?

Re:Ever heard of "search-replace"?

[mesocyclone]

What cost?

It costs very little to use the notation. One of the ways I find it most useful is to distinguish between members of an array and the array itself (we prefix an array name with an "a").

I don't expect to convince you... like I said, it seems to be a personal preference, like editors.

Re:Ever heard of "search-replace"?

[Danny Rathjens]

Wouldn't 'aWidget' indicate a single element to those of us that speak English?
Sounds like 'a widget' to me, 8^).

Read it again AC

[victim]

Read again, anonymous coward. Microsoft has the right to negotiate first. So? That has no value. MSoft will either offer some price or not offer. If they offer too much simonyi takes the deal, but Msoft is not stupid. So Simonyi negotiates with all buyers and microsoft keeps a finger in if they are interested and buys at market price.

I don't see where Microsoft demanding the right to be stupid is any kind of compensation for donating their shareholder's patent rights. :-)

Maybe there is a formulaic structure to that negotiation that isn't in the press release? Maybe a pricing formula? We don't know that part.

Re:He wrote Word

[Wonko42]

You seem to be forgetting that he wrote the first version of Access, too, and also had a lot of involvement with the first version of Excel.

In a Functional language...

[Tom7]

How about:

app (fn i => foo.bar.yukims.glock(a, i)) [1, 2, 8, 13, 19]

(Apply to each element of the list [1, 2, 8, 13, 19] the function that calls foo.bar.yukims.glock with the pair of a and its argument.)

I agree that this kind of repetition is to be avoided, but that doesn't mean that we should be avoiding it by introducing syntactic hacks into the language. In fact, just adding higher-order code to a language (ie, having a functional language) solves this kind of problem elegantly and briefly.

Re:In a Functional language...

[Tablizer]

How about: app (fn i => foo.bar.yukims.glock(a, i)) [1, 2, 8, 13, 19] (Apply to each element of the list [1, 2, 8, 13, 19] the function that calls

The problem with this is that it flunks if you need to add 2 parameters which vary instead of just one. Your data structure becomes more complicated.

In fact, just adding higher-order code to a language (ie, having a functional language) solves this kind of problem elegantly and briefly.

A simple "local" function might handle some of these situations nicely. Pascal's local-scoped (nested) function definitions were great for this kind of thing (but I don't like their forced physical placement at the top). Too few languages allow local-scoped functions. Some use closures instead, but Pascal's approach is simpler IMO.

Re:In a Functional language...

[Grax]

The problem with this is that it flunks if you need to add 2 parameters which vary instead of just one. Your data structure becomes more complicated.

TCL Code:
foreach item {{1 1} {2 2} {8 8} {13 2} {19 27}} { foo_bar_yukims_glock [lindex $item 0] [lindex $item 1]}

I would assume a similar syntax is acceptable in some other languages

Also exists as Free Software

[descubes]

Don't dismiss Simonyi's ideas too quickly. Believe me, what he's doing is really clever.

Contrary to what many wrote here, the idea is NOT to create a visual programming tool a la Visual Basic. It is to represent programs visually, to "render" the program tree using various ad-hoc renderers. For instance, the best representation for math notations is not text. It could be something like MathML, or a graphical representation, or TeX. So the idea is that you can have several input representations, several output representations, and one common format underneath it all. You get rid of the whole idea of source code...

The good news is that there is a Free Software project with the same capabilities: Mozart. It's been there for a long time, and it's quite functional now. This might give you an idea of what can be done with this kind of tools. See in particular the Moka Java-to-Java extensible compiler, which lets you do things with Java you can't do otherwise... I think it's really the future of programming.

There Is a Better Way to Construct Software

[Louis Savain]

I think the mistake people have made is often to start out with unfounded assumptions about how it should be done - such as assuming that a "drag and drop elements, then connect them up with lines" approach is the right direction (I don't think it is - or we would all be programming with Javabeans right now).

There is nothing wrong with "drag and drop elements, then connect them up with lines". That is the way it should be done. The problem is with the way we program. Encapsulating conventional algorithmic code with things like JavaBeans and c++ classes will not get rid of the fundamental problem of software engineering: the practice of using the algorithm as the building block of software programs. For an alternative non-algorithmic approach, take a look at Project COSA.

Re:There Is a Better Way to Construct Software

[Sanity]

There is nothing wrong with "drag and drop elements, then connect them up with lines". That is the way it should be done.

And thus you demonstrate exactly the kind of unfounded assumption I was talking about. Have you considered the possiblity that a mouse might not necessarily be the best way to enter a computer program? I hope so, because you just ruled it out.

Re:There Is a Better Way to Construct Software

[Louis Savain]

And thus you demonstrate exactly the kind of unfounded assumption I was talking about.

There is nothing unfounded about it. It is a fact that dragging and dropping with a mouse is currently the most powerful way to automate complex tasks on a computer. Where have you been?

Have you considered the possiblity that a mouse might not necessarily be the best way to enter a computer program?

You are kidding me, right? The greatest innovation in computing since the keyboard is the mouse/GUI, period. Computing would not be what it is today without it. The mouse is the most important input device in countless power applications and tools, including the desktop interface. What's taking so long for it to be the primary input device in software construction? The reason is that the software programming world is still in the dark ages.

Re:There Is a Better Way to Construct Software

[aron_wallaker]

It is a fact that dragging and dropping with a mouse is currently the most powerful way to automate complex tasks on a computer

I have to say this is a bit of a stretch...I was with you right up until you used the word 'complex'. The mouse is the best way to automate simple tasks. I don't like using a keyboard to navigate a GUI or surf the web, but when I sit down to type this response I find the keyboard much more powerful than using a mouse to drag and drop characters or words. The more 'complex' a task is (IMHO) the more possible actions there are at any time, the harder it is to automate that task with a mouse.

Are there any Palm users out there that prefer Graffiti to QWERTY ? (That's not rhetorical - I'd like to know). When I want to select something from 10 options a mouse is just jim-dandy, if I want to select something from tens of thousands of options (an adult vocabulary) I just can't see doing it with a mouse.

Re:There Is a Better Way to Construct Software

[Louis Savain]

I have to say this is a bit of a stretch...I was with you right up until you used the word 'complex'. The mouse is the best way to automate simple tasks. I don't like using a keyboard to navigate a GUI or surf the web, but when I sit down to type this response I find the keyboard much more powerful than using a mouse to drag and drop characters or words.

Well, in my opinion you are mixing two types of tasks here, tasks performed by humans and tasks performed by computers. I was referring to the latter. Let's say you wanted to make a copy of the message you posted and insert it into another document. Which is simpler: retype the message in the new document or use your mouse to copy and paste the message into the new document?

In the same vein, it is a lot easier and orders of magnitude safer to drag and drop a plug-compatible component into a project than it is to write a function call. Automation is one of the cures for bad code and low productivity.

My thesis is that automating software programming will not come of age until we realize that there is something rotten at the core of conventional software engineering. This is the reason that the grand promise of OOP never came to fruition. I argue that the practice of using the algorithm as the basis of software construction is fundamentally flawed. It is the unfortunate legacy of a mindset that has existed since the days of Charles Babbage and Lady Ada of analytical engine fame. Unless we realize that this is the core of the problem, software engineering will remain in the dark ages.

Re:There Is a Better Way to Construct Software

[dvdeug]

Which is simpler: retype the message in the new document or use your mouse to copy and paste the message into the new document?

That's not a complex task, nor is your comparison fair. All major Unix text editors will let you copy and paste without a mouse. And frankly, cutting and pasting is often the wrong thing to do; #include >file< keeps your version up to date with the original. (In a non-programming context, you probably want the stockholder's report to automatically update when your accountants 'correct' the budget.)

Re:There Is a Better Way to Construct Software

[kbielefe]

Just because the mouse is a great innovation does not mean that it is the best tool for every job. Would you solve a multiplication problem using a mouse? Did you post your comments using only (or even primarily) your mouse? Would you create a research paper using only your mouse?

I think we've reached a happy medium in software development. We use the mouse when it is the most powerful tool, such as GUI construction and modeling. We use text-based methods when they are most powerful, such as algorithm implementation.

one of PARC's most notables...

[bluethundr]

For more on Chuck Simonyi's invaluable contributions to computing, and to be reminded of how what is now mundane was at one point incredible and revolutionary (thinking of Bravo, here) this book is an excellent, highly readable and entertaining rendition of those days. I'd probably enjoy a second read of it, myself....

Visual Programming language

[vespazzari]

A professor at my school wrote a language called jboxes, it has the same basic design as java- it is a actually some sort of extention to java but all the programming is done using a gui where boxes are moved around and connections added. I myself have never used it but it looks neat, he gave a class that I was in a demo shortly after he finished. It looked like it might have helped me in some of my first cs classes, although I did not have that much trouble.

Anyway the point of creating Jboxes was to help students who had trouble with OOP and writing code, Jboxes takes away the problems of syntax to help new cs students understand the structure of programming and think of the design instead of getting hung up on syntax problems.

I could not seem to find a page dedicated to jboxes on his website but he does have the executables and pdf files(for his classes) at http://clem.mscd.edu/~shultzj/190kf02/

Re:Visual Programming language

[Daniel Dvorkin]

I am so totally unsurprised that Jerry Shultz writes programming languages in his spare time. ;)

Blackmail?

[CormacJ]

'Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.'

Charles S.: I'm leaving to go my own stuff
Bill G.: Charles, you'll have to give up your rights to all the stuff you've developed over the years
Charlies S.: Did I metion that I still have a copy of those memos that the government never saw?
Bill G.: Well when you put it like that, I'll give you the rights to all your stuff. Need any cash? No? Here have some anyway. Anything else I can do? Anything at all? Coffee, Water? Sure..?

Re:Blackmail?

[9jack9]

According to Reuters Simonyi has rights to patents he developed at Microsoft and Microsoft is entitled to be first to negotiate for rights to Intentional Software's developments.

According the the Wall Street Journal the new company will be based in Bellvue, Washington, which is home to almost as much Microsoft real estate as Redmond.

By all accounts the split was friendly.

Re:Blackmail?

[MisterMo]

Hmm, perhaps this says more about the quality of the IP than about Chas' relationship with MS?

Just a thought...

strBias = "don't be so hard on hungarian notation"

[rnd()]

If Kernighan and Ritchie had suggested Hungarian notation, you'd find lots of evangelists for it on Slashdot.

If you are clueless about what it is, then read the msdn info and decide for yourself. Don't buy into Chrisd's characterization uncritically.

As for me, I don't use it often, but occasionally I find it useful especially when writing code in a language that supports automatic type conversion and a variant data type.

Interview?

[PhilHibbs]

I for one would be interested to see a Slashdot interview with him.

context

[Phil Wilkins]

Hyslop and Sutter on Hungarian

(In summary, don't.)

Re:context

[Permission Denied]

Interesting read. Even more interesting is Simonyi's original article, which is linked in from the CUJ article.

Go Slashbots!

[Theodore Logan]

'Mr. Simonyi has left Microsoft with the right to use the intellectual property he developed and patented while working there.'
He probably threathened to reveal some rather embarassing details about how Microsoft has abused it's market power if they didn't give it to him.

Yeah yeah, four legs good, two legs bad. I think you mistyped the URL, you really want to be here.

Why don't you Slashbots just shut the fuck up already? I'm not kidding, and I've got karma to burn. Everybody knows what you have to say even before the story is posted, and everybody knows you can't back up your outrageous claims.

And by the way, you spelled your nick wrong. Would you take a guy who in one sentence proposes a clearly agenda-driven and unverifiable hypothesis with zero arguments seriously if he can't even spell his own nick? Ask yourself that before posting the next time.

Re:Go Slashbots!

[Theodore Logan]

You write like a moron.

I must read like one too. What I suppose is due to my inferior command of the English language, I am uncapable of understanding the following words, all from your three-line post: suprised, afore, therom, indead, increadible, favoure. Strangely, no dictionary seems to recognize them either.

If you were talking about the content of my post, rather than the spelling of it, I can do nothing but agree here either. It is clear to me know, having reread my post alongside the one I was commenting on, that his was the more researched and thought-through. Also, it is clear that the original poster has a sense of irony that I distinctively lack.

Re:Go Slashbots!

[technix4beos]

"What I suppose is due..."

I hate to be picky, but I would consider using the word Which in place of What.

Have a nice day. ;)

Re:Go Slashbots!

[Theodore Logan]

I guess I deserved that.

Re:Go Slashbots!

[Theodore Logan]

Not that I know wtf you're talking about tho.

Drag and Drop programing.

[essiescreet]

Microsoft's is called VB, used to create VD like viruses.

Re:strBias = "don't be so hard on hungarian notati

[the eric conspiracy]

As for me, I don't use it often, but occasionally I find it useful especially when writing code in a language that supports automatic type conversion and a variant data type.

My reaction to that would be that the language is forcing work that should be automated (by strong type checking etc.) on the programmer. It seems to me that if you are using a programming environment where Hungarian Notation is useful, you should perhaps step back and consider alternative tools.

Richard Dawkins link

[Thorgal]

What is also worth remembering is the fact that Mr. Simonyi founded the chair of "Professor of Public Understanding of Science" at Oxford, which is currently held by Richard Dawkins. His book "Unweaving the Rainbow" is a direct result of all this.

Re:No

[srelan]

You obviously never had the blood sucked out of you by a lawyer. Software company lawyers, much less Microsoft, don't care if you're Mother Theresa. They'll stick it to you just to smile and watch you squirm in agony.

Not A Bug, A Feature

[Lagged2Death]

HN was invented for use with C, not C++.

But even so, in C, C++, or any weakly-typed language, changing the type of a variable can introduce subtle bugs, particularly when dealing with unfamiliar code. It's a good idea to review references to a variable when changing its type, and that's a process that meshes well with search/replace anyway.

This isn't a problem with HN; it's a benefit, since you're forced, or at least strongly encouraged, to do the right thing.

And isn't this something of a canard, anyway? How often do you have to change a variable's type? If you're doing a lot of that, something is wrong. Compare this with how often you need to find a variable's type.

Re:Not A Bug, A Feature

[Amazing Quantum Man]

It's a good idea to review references to a variable when changing its type, and that's a process that meshes well with search/replace anyway.

Except you probably don't do that. You simply do a global search and replace without looking, thereby defeating the purpose.

Re:Not A Bug, A Feature

[leviramsey]

But even so, in C, C++, or any weakly-typed language

By most standards, C++ is quite strongly typed, perhaps the most strongly typed language in wide use today.

So long Charles

[fm6]

Not mentioned in this article, he developed the Multiplan interface, which a gazillion of CPM based boxes used,

Not just CP/M. Convergent licensed Multiplan to bundle with its 80x86 workstations, which ran a proprietary OS called CTOS. I think there were others licensees of this sort.

I guessing that Simonyi, with his fascination with "notational calculus" was also responsible for Multiplan's elegant address notation. I've always found it much easier to use than the klunky "A1" notation introduced by VisiCalc. Alas the spreadsheet user community was already well established, and simply didn't want to learn macro writing all over.

the first version of Access,

I'll try not to hold that against him! Access is a nasty piece of work. It's a bad attempt at an end-user database tool that's become a painful to use database programmer's tool.

Re:No

[SecretMethod70]

Sorry, but he's missing the point that the reason most of us dislike Microsoft is BECAUSE they're unreasonable.

Drag and drop programming

[atomico]

Ah, "visual" drag-and-drop programming environments! That's a real horror, my friends. As a veteran who has suffered the immense pains of using that kind of torture, and who has happily come back to the sunny fields of C++ (text editor, then gcc), I know what I say.

By the way, the painful system I am talking about is a development tool for quite specialised telecom applications, running on top of traditional switches. Some idiot named it Intelligent Networks. The system was regarded by my fellow developers as "assembler with funny little drawings"...

Re:strBias = "don't be so hard on hungarian notati

[rnd()]

the language is forcing work that should be automated (by strong type checking etc.)

As a general rule you're correct, however in this case it's actually the other way around. Languages that support a 'variant' data type do not require type checking (strong or weak) because type conversions are handled automatically (you never have to cast anything or even worry about what type anything is. 99% of the time the compiler figures out what you meant based on the code you typed in. This leads us to the usefulness of Hungarian Notation:

Hungarian Notation allows the code to be more meaningful to the reader. This creates less work for the programmer because in languages with a 'variant' data type more work is already being done by the compiler. If you are adding an integer to a string, but the string happens to contain a number, then the compiler will automatically calculate the value that is the sum. The sum can then be concatenated to another string or added to another number, whatever you choose. Of course, the risk with this kind of thing is that you accidentally write code that means the wrong thing and the compiler doesn't complain. That's where Hungarian notation comes in: It forces you to think about what the code means when you are writing it. I think that for most people this is a Good Thing.

Well

[Lagged2Death]

Well, I, for one, certainly do that. I like my code to actually compile when I'm done editing it. If one is too lazy to check the safety of a type change like this, HN will be the least of one's problems, IMHO.

Re:Microsoft innovation?

[WheelDweller]

Microsoft Innovation, my second favorite contradiction in terms, right behind military intelligence. :) Why do people assign the phrase 'computer whiz' with Gates? They bought DOS, they just sold it in an intelligent way. The stole/annexed/'found' various technologies and kept other people from using it. Gates isn't a *computer* god, but rather a *marketting* god. Odd, though...how they keep a $40b warchest...in fact 20% of their income is from the interest on this money. Sounds like they're investing against a storm. Well, back to making that storm. :)

Remember...

[MilesParker]

...you can never put too much coolant into the reactor.

This isn't the end

[Nailer]

Although she may have left Microsoft, she'll live on in her music, what with great hits like `Let the River Run' `You Belong To Me' and `You're So Vain'. I think this will really be her legacy - in fact, I wasn't even aware of her coding skills.

Oh wait, Charles Simonyi? Er, nevermind...

You really saved my day

[hasse]

Yes. Thank you. The FREE registration was giving me a lot of problems.

There is no free lunch. Grow up.

Re:You really saved my day

[Spy Hunter]

The free registration bugs the heck out of me. I never remember the username/password I used last time, so I always have to re-register, and then the username I choose is taken, and it gets annoying. Then I found asahi.com, and I found it much easier. So I figured I'd spread the word.

As to there not being any free lunches, the registration itself is free, so that just about proves you wrong right there. Not to mention the zillions of other free things on the Internet. Maybe the free lunches won't last forever, but they're here now. And if Free Software is any indication of what the Internet can do, perhaps the free lunches won't end. Anyway, I'm hardly exploiting the NYT by depriving them of thousands of pages of bogus personal information supplied by slashdotters.

Re:strBias = "don't be so hard on hungarian notati

[2short]

if the language in question is javascript, and the environment is a client browser, what alternative tools would you suggest? javascripts lack of types sucks (since the type is inaccessible, but sometimes critical), but that's the language you've got. I find very simplified hungarian notation invaluable here when *I* have to enforce variable typing since the language does not.

Naming conventions: values + units

[Anonymous Brave Guy]

m_uAgeInYears please.

I've worked extensively with scientific developments, numerous specialist units (some of which were the same by different names), different default unit systems in different target countries, etc... In all seriousness, I think there are three simple approaches to variables that store values with units, depending on the complexity of your situation.

1. int age; // Age in years (best if you keep years as your standard unit of age everywhere)
2. int age_in_years;
3. value age; // value is an intelligent quantity+unit type

From the bottom of my heart, I can tell you that two of these approaches work tidily. The middle one doesn't scale readably to either highly compound units or calculation of non-trivial expressions.

For simple work, start with a variable age, and make its type and meaning clear with concise comments where it's declared. It's much easier if you stick with the same units everywhere as a general rule: all lengths are in mm, all times in s, whatever. Then you just need to comment exceptions, such as storing an age in years and not seconds. Note that someone reading your code will soon learn what units are being used, and then typically finds the constant _in_years an irritant. Meanwhile, any up-front benefit you derive from a "clear" name is offset by the fact that you have to either take it on trust (leading to bugs when things get out of synch) or check anyway (removing any benefit).

If you need more power, or you want robust unit checking, design yourself a smart type to do it. It's not hard, and it can save literally weeks of effort later on if you need to do any deep reorganisation to support different unit systems, etc. You can also incorporate things like checking for values within a valid range, automatic deduction of compound unit types, yada yada if you ever need them.

Naming conventions are, in principle a good thing. As with anything, though, too much is often worse than none at all.

HyperCard?

[eweu]

he focus of his new company is to "simplify programming by representing programs in ways other than in the text syntax of conventional programming languages,"

So he's leaving to work on HyperCard?

Sounds like an attempt to simulate competition....

[leereyno]

Now I don't necessarily believe this, but it seems to me that this could be construed as an attempt by the players within Microsoft to continue to operate as an effective monopoly without being a singular corporate entity.

Creating a web of inter-locking corporations has worked for various other evil organizations such as Scientology, the mafia, DeBeers, etc. Why not Microsoft?

The ties that bind them together would not even have to be in the form of stock. As long as a symbiotic relationship exists among the companies that are spun off, you can expect them to act in such a way as to benefit them all.

Lee

What's the deal with Eclipse

[Latent Heat]

OK, tell me I'm a moron if you want, but how in the heck to you build and run anything from the Eclipse environment?

I downloaded the whole thing and I downloaded the samples/examples, and I can't make heads or tails of their friggin menus -- that darn thing is worse than Word!

Shouldn't I be able to do something like Files Open (or perhaps Files Open Project), browse to a directory called "samples" or "demos", open one of the projects, build it, and tell it to run (this is an IDE, isn't it?), and it should run the friggin program. I can then browse the source code of that program and see how the do stuff -- like a GUI button or text box, and then write my own programs.

Yeah, yeah, I browsed their help, and you are supposed to drill down into menus with non-standard names (what happened to Files Open?), and then you can set a bunch of options, you can import the examples and UNZIP them, and then you can specify a whole bunch of "jar" files you are supposed to add to your project to get at the necessary Java classes to do neat stuff. The help file instructions run to pages of "click on this" and "activate this dialog" and "enter this field", and I tried following help, and I couldn't find the stuff that was supposed to be there, and as to the examples I did find, I got as far as building them, but I couldn't figure out what the heck I was supposed to specify to get anything to run.

I have used Delphi and I have used Microsoft VC++ and Code Warrior, but Eclipse has me completely stumped. Yeah, yeah, I could plow through their help and maybe in a couple of days of trying things I could get a sample program to build and run in Eclipse, but I got a whole bunch of other stuff to do.

Am I the only person out there who finds Eclipse opaque? Does someone have any helpful advice on how to get started with the thing?

HN *Solves* Variable Type Changes

[HopeOS]

Hungarian Notation saves our ass. My group maintains several million lines of code, and we change variable types all the time. By changing both the type of the variable and the prefix on its name, we effectively cause all code that referenced that variable to fail to compile. This is the desired result.

The task of progogating a change of variable type includes visiting the affected code and verifying that the change will not have unwanted consequences. It almost always does. Hungarian notation allows you to do this quickly, effectively, and in a single pass. Waiting for the regression test to come back negative is reckless and unprofessional.

We don't allow code to be checked in if it is not in HN. If it can't be visually audited for type correctness by an independent team, without the use of an IDE or some type of code browser, it's a liability and therefore has no business in our code base.


-Hope

Re:HN *Solves* Variable Type Changes

[sohp]

Please tell me where you work....

So I can be sure to never apply for a job at a place that doesn't even believe in employing fundamental pragmatic programming tools like a source browser. I suppose all the printouts are on green-bar from the chainprinter?

The computer can understand and run any obscure syntactically and logicall correct gook you throw at it, but we invented high level languages to allow humans to express concepts at a higher level than 1s and 0s. Mandating that all code be understandable without tools designed to manipulate and understand it smacks of voodoo coding.

Re:HN *Solves* Variable Type Changes

[HopeOS]

Well, I would not lose sleep over it since it does not sound like you would be considered here. That said however, to respond to your question about programming practices, the issue is not whether the code is understandable on paper, but rather whether the "fundamental pragmatic programming tools" will help you resolve problems with code such as this:

price = (float)(mult * settle_price);

The original programmer cast the result to a float to avoid a precision warning. This was the correct decision at the time since price was in fact a low-precision float. Now however, price has been changed from a float to a double, this code will continue to operate with the lower precision, and the compiler will fail to flag it with a warning. By comparison, the following code can be easily diagnosed as incorrect, by eye, without the need for an IDE.

dPrice = (float)(dMult * dSettlePrice);

Plainly, casting a double to a float is unnecessary when the resultant is a double. Of course, you would only know that the multipler and settlement prices were doubles by using HN, a spiffy IDE with a code browser, or the rest of the code, but as you can see HN is the most efficient of the three since it requires the least amount of overhead. Additionally, programmers from other projects can quickly validate this code without the need to hunt down the type declarations of mult and settle_price, or build the browse info for the project which could easily take hours.

In the end, we are responsible for writing and validating the code; IDE's and code browsers are merely tools for analyzing and debugging. You cannot relegate the whole of type safety to the compiler, as is apparent from the example above.

-Hope

Re:HN *Solves* Variable Type Changes

[sohp]

The original programmer cast the result to a float to avoid a precision warning

That should have been the red flag that was listened to. Tell me, what does ANSI C say about the result of casting a multiplication of two doubles to a float? How many bits of precision do you retain? What happens on overflow? Can this be different across platforms and O/S? 32-bit and 64-bit hardware? What happens if one or both of the operands is FLOAT_MAX?

Re:HN *Solves* Variable Type Changes

[HopeOS]

Excellent questions all.

In the original code, only the multiplier was a double. The settlement and resultant prices where both mere floats, and the loss of precision was a non-issue since the resultant could have no more significant figures than the settlment price input. In terms of code, the choices were:

price = (float)mult * settlement_price;

or

price = (float)(mult * settlement_price);

The programmer choose the latter since the precision loss would take place at the end of the calculation rather than in the middle. This was the correct decision based on my experience and subsequent testing. The promotion of the settlement price to a double came later, the suite was regression tested, and finally, the price was promoted last.

As far as "red flags" go, you are absolutely correct. The programmer had manually overridden a compiler warning. Fortunately, he also left two additional bits of information in the code: 1. the cast itself, the purpose of which is not self-evident as described above, and 2. the hungarian notation used below, which resolves the question of why the cast was made in the first place.

fPrice = (float)(dMult * fSettlePrice);

The auditing programmer can plainly see that a cast is necessary from the HN prefixes. (This company uses "f" for float which departs from classic HN; every company has its standards.)

In answer to your questions though: a double times a double is a double. A double times a float is a double (the float is promoted). Casting from a double to float results in a loss of precision in the mantissa (from approximately 15 decimal digits to 6) and a possible overflow condition in the exponent. The application and its libraries run solely on hardware that supports IEEE floating point numbers. FLOAT_MAX is not a valid value for any of the numbers specified.

Further, from a design point of view, the multiplier can at most be 1000.0, but ordinarily will be around 1.0. The need to use a double for the multiplier was caused by the need to generate the value 1.0 + 1/1024. At minimum, you need 11 digits of precision to store the value with any accuracy (conveniently, it stores exact). This particular value would be equivalent to 1.00098 in the code above which was decided to be adequate.

The settlement price comes from another system, so the value can be no more accurate than we receive it. The resultant price can have no more digits of precision than the settlement price, so truncating was considered reasonable.

Ultimately, it was decided to promote everything to doubles after bit errors creeped in with the larger values occurring in some foreign currencies. Internationalization can be taxing on legacy code.

Lastly, all these price values are theoretical, meaning that they do not represent actual sums of money for transactions. Those values are stored in fixed point format to eliminate the fractional cents issue.

So in all, I applaud your skeptical eye towards software design. The questions you asked are questions that normally come up at our design meetings.

It was implied earlier that if the compiler can read it, the code is done. This is incorrect. The code must satisfy three agents- the compiler, the next developer, and the code auditor. HN is about declaring intent. If the code violates the stated intent as written, then there is a high likelihood of an error in implementation.

// bad code
++children;
if (index < 0) foo();
if (current == target) bar();

// Greatly illucidated by HN
++bChildren;
if (uIndex < 0) Foo();
if (dCurrent == dTarget) Bar();

All three lines are wrong- boolean values should never by incremented, even if the underlying type is an integer. Comparing an unsigned integer less than zero makes no sense; a corner case has changed, and the code probably no longer works correctly. Equality comparison between two doubles is usually a bad idea. But of course, we all know that. The question is whether these problems can be gleaned immediately from the code as written, because all three cases will compile. A smart compiler might warn on the second condition, but there's no guarantee.


It's been fun.

-Hope

Re: No. I hope IBM checks out Charles Simonyi

[stephanruby]

Xerox PARC released SmallTalk-80 to IBM sometimes in the 70s.

...and interestingly enough, Charles Simonyi was also working for Xerox PARC in the 1970s.

"INTENTIONAL PROGRAMMING" A Talk With Charles Simonyi
http://www.edge.org/digerati/simonyi/simonyi_p1.ht ml

Strong typing, Weak typing

[Lagged2Death]

Perhaps I am abusing the term "weakly typed."

What I meant was, C and C++ are pretty permissive about mixing and matching various numeric types together in expressions. Sometimes the implicit conversions the compiler generates don't work the way the author of the code expects.

The problem is frequently exacerbated when C and C++ are used in environments that encourage or require liberal use of explicit casts. That throws a lot of possibly helpful type-checking out the window.

A functional approach scales very well, actually

[Anonymous Brave Guy]

The problem with this is that it flunks if you need to add 2 parameters which vary instead of just one. Your data structure becomes more complicated.

The latter does not imply the former, by any means. One of the fabulous things about functional languages is that when you create a new data structure, you can often create a few very simple functions to work with that structure in a very abstract way, and then write more powerful and specific functions using them, ad nauseam.

The app function that Tom7 mentioned would be a typical example, applying a function to everything in a list. The next "level" might be a function that combines the elements of the list using another function, so that you could sum all of the elements in the list by just calling that function and passing "+" as the parameter function, for example.

This approach translates perfectly well to arbitrarily complex data structures. Indeed, higher order functions provide an "exponentially powerful" way of writing code to manipulate such complex data structures. You could have code that traverses a binary tree in a depth-first or a breadth-first way, and completely independent code that is used to calculate the mean of a collection of values, and then glue them together to build the code to calculate the mean of all values in the tree. Of course, you could use the same breadth-first or depth-first algorithm to search the graph, and the same mean-finding code to average a list, or the grades of everyone in a hash table whose first name is "John". Now that is code reuse. :-)

Gotta love this stuff, now if only it would go mainstream so I could play with it at work...

No more m_hWnd..

[fforw]

no m_lpszFilename..

no m_pModuleState..

does that mean that microsoft code will get much more readable now?

Because Microsoft switched to Camel notation

[nsushkin]

Could it be that Simonyi left because in .NET Microsoft deprecated Hungarian notation? Maybe he was too attached to all 138 different prefixes.

The new .NET naming standard is the Camel notation. It's the same naming/casing standard that is used in Java.

Stunning achievment - ToonTalk

[Bozovision]

ToonTalk is a non-text representational programming language. You program by 'physically' manipulating things in a cartoon world in the first person. It's a full, sophisticated language with features like parallel-executing functions and the ability to output your program into Java.

At the moment it's sold as a kids toy, but it clearly represents an entirely different programming paradigm.

I think it's one of the most stunning achievements of the last 10 years in software. It's the work of one person. Go Ken go!

If you have kids, let them try it.

http://www.toontalk.com/

Hungarian notation did serve a purpose

[Mr Z]

I think Hungarian notation did serve a purpose, but nowadays it's obsoleted by modern compilers and high-level languages.

The main usefulness of Hungarian notation was in the days when much of the OS was still written in assembler. There is no type-checking in the assembler, so having a convenient way of conveying type information to the programmer, consistently, across a large organization is useful.

Consider a C program where you might have a struct foo. In one function, you might have something which is struct foo variable and elsewhere you'll have one or more variables that are pointers to struct foo. Hungarian notation lets you see at a glance whether a given variable (which you happen to know deals with a struct foo) is the structure or just a pointer to it.

If you screw up "var->field" versus "var.field" in a C program, a modern compiler gently reminds you. If you screw that up in an assembly program, nothing warns you. You just end up crashing mysteriously.

That said, I think Hungarian notation specifically is just ugly. But it's better than trying to read through C++ name-mangling!

--Joe

Career focus

[dazdaz]

Kinda interesting to read about others careers, how about a /. article on people's careers, good to get focus from others.

Hmmm... anti-antitrust?

[Hyped01]

I see two possibilities...

(1) Anyone hear of Lexmark ("Still trying to pretend we aren't really part of IBM") International? Let's say the "new" office suite this guy develops somehow "takes off"... and MS decides to drop their office suite except for the big collaborative business aspects (which, compared to Notes, doesnt exist)....

(2) Didnt this guy write Word before he worked for MS anyway? (not really a question... he did, regardless of or as supported by current belief). Perhaps that is why he has retained the rights... a good contract when he was bought out by MS in the beginning (and thus this isnt something as sinister as possibility #1...)

Dunno - it will be interesting to see how things go. But those are the only things I could think of that would explain why he got to leave with all his IP.

-Rob

BinFeeds

I'm not alone!

[Trinition]

I've been increasingly troubled that I perhaps was alone in thnking textual representation fo source code is silly. As a Java programmer, every IDE under the sun ahs a little side panel where the structure ofyour class is represented as a tree, and as you clickon elements in the tree, the file jumps to that delcaration.

Turns out, though, that it doesn't really matter that method A appears before method B in the file. Code folding is a very simple step in this direction. And all of this arguing over tabs vs. spaces, curly-braces on their own line, etc. would be obliterated if code were stored in some other, unformatted manner.

I know IBM's alphaWorks has a project that transforms Java into XML and back. Once in unformatted XML, it is easier to see if a file changed functioanlly whereas typical diff programs would higlight a curly brace being moved to its own line.

Mr. Charles Simonyi's T-Shirt says:

[Derek]

"I worked at Microsoft for 20 years and all I got was this lousy code!" :-)
-Derek

More info--what it's really about

[Prune]

The company URL is here:
http://www.intentionalsoftware.com/
I'm a UBC student, and Simonyi's partner is Kiczales, a UBC professor. This morning he sent an email to the department basically stating that he's going off to found the new company, and that a major focus will be his previous work on Aspect Oriented Programming.

Re:A functional approach scales very well, actuall

[Tablizer]

(* Of course, you could use the same breadth-first or depth-first algorithm to search the graph, and the same mean-finding code to average a list, or the grades of everyone in a hash table whose first name is "John". Now that is code reuse. *)

No, that is called "reinventing a language-specific database".

Kiczales is the other co-founder!

[King Babar]

The company can be found at http://intentionalsoftware.com/ [intentionalsoftware.com] with some vague-but-cool-sounding stuff about changing the world.

Now the interesting thing I found out there is that the *other* founder is Kiczales, a Xerox PARC person who was a prime mover in the Aspect-Oriented programming movement. So it looks like we have here is a start-up featuring really smart people whose efforts to do world-changing programming tool/language research did not get anywhere in the large companies they previously worked for. Or something like that.

The success rate for start-ups is not very high, but this is at least an interesting sort of venture, unlike so many of the dot-coms of the past few years.

Re:Kiczales is the other co-founder!

[greenrd]

So it looks like we have here is a start-up featuring really smart people whose efforts to do world-changing programming tool/language research did not get anywhere in the large companies they previously worked for.

Well, AspectJ is doing pretty well, and a new 1.1 version with badly-needed incremental compilation is in the works - it just so happens that, yes, the Xerox PARC research center was spun off as a separate company by Xerox to cut costs. But AspectJ is certainly still alive!

Re:Kiczales is the other co-founder!

[King Babar]

Well, AspectJ [aspectj.org] is doing pretty well, and a new 1.1 version with badly-needed incremental compilation is in the works - it just so happens that, yes, the Xerox PARC research center was spun off as a separate company by Xerox to cut costs. But AspectJ is certainly still alive!

Thanks for the information on this. I haven't really been keeping up with the AOP side of things much. I do remember looking at some of the original work and thinking "My God, this is great, but how will they ever make it take off?" Guess I know the answer now. :-)

Re:strBias = "don't be so hard on hungarian notati

[AJWM]

If Kernighan and Ritchie had suggested Hungarian notation, you'd find lots of evangelists for it on Slashdot.

And if Bill Gates wore a dress, he'd be Mother Teresa. GMAFB, Kernighan and Ritchie wouldn't have suggested Hungarian notation, they're not that stupid.

(Besides which, the first C compilers only distinguished identifiers in their first 8 characters (and the loader reduced that to 7). They certainly wouldn't waste the space.)

TeX, LyX, Math, Haskell

[axxackall]

Programming on languages like Haskell, ML, Mercury, Lisp and Prolog, involves a lot of math. But a language syntax is rather limitied in terms of expressiveness, comparing a poorly formatted fontless text to "vusualized" TeX articles, full of matrices, integral equations and so on.

The gap between graphical notation of math and even high-order programming languages is mostly caused by ASCII, UTF-8 and other character sets we use to represent a simple fontless text of programs. Anything more sophisticated elements like graphics, diagrams are coded, not represented.

There is a good attempt to solve the problem of file persistence of math notation in MathML. When I try MathML in Mozilla it looks great. But when I try to "code" it myself - it's not really productive process without some vsual IDE support. Same with SVG. So, we need tools for MathML and SVG formats.

MathML and SVG are not really revolutionary since Donald Knut invented TeX, another unversal language to represent such document components as fontful, graphically enriched and formatted texts. And Adobe gave us Postscript to represent diagams and pictures (of course Postscript is not only about that). But have you tried to "program" on TeX and Postcript manually, in simple text editor? Isn't it a nightmare?

Fortunately there was LyX for awhile around, and now there is also TeXmacs. Creating a document in LyX is really productive job as it is not just mimicing MS-Word, which has a low-level manner tending to edit style of characters rather than document components. LyX forces (and helps) you to think about whole document and it style from top to bottom. Isnt it a style of structured programming?

When I've been creating several math papers in LyX I was thinking - why not use it as IDE for some new programming language which syntax will be based not on flat fontless character sets, but on math-based notation?

Of course I remember Ration Rose and Together - classical UML editors. By the way, when my paper is about both math and program design, then I really need UML editing in LyX. Or I need math editing in Rose, or document formatting in Dia. Unfortunately I did not meet a tool with all 3 editing styles: math, UML and document.

Ok, something like LyX might be an editor. The syntax should be XML-based for being readable/writable by both human and machines. Let's say it should be based on a combination of Docbook, MathML and SVG, rather than on decent TeX and EPS. As for semantic, it should be something multi-paradigm, combining functional, logical and object paradigms, like in Curry, Mercury or Oz.

Programming on such "not-flat" language will be more transparent for students, better verifiable for rapid development, and closer connecting math theory and implementation practice.

That's the idea I give free to any who wants to create such IDE-based language.

foreach

[muzzy]

is this what you want?

foreach $x (1,2,8,13,19)
{ foo.bar.yukims.glock($a,$x); }

something like this would work in perl, pure functional programming languages (CL!) also have much of this stuff.

Re:IP?

[stephanruby]

He more likely arranged it long ago, when his future value to the company outweighed the potential value of his contributions. This does seem unusual (and not just for Microsoft). He had to have hammered this out long before his creations spawned a cash-cow like Word.

He came from Xerox Lab where he had been one their Star employees for ten years and he started with Microsoft as their *fourth* employee. You bet he had leverage. I'm surprised he didn't ask to be CEO.

Re:IP?

[stephanruby]

Correction: Xerox PARC, not Xerox Lab, my mistake.

Simyoni is definitely tech

[gera0ul]

He's the one who co-authored the MSN messenger protocol.

Btw, the document describing the protocol comes with the gaim source tarball, available here.

/me is too lazy to google it, go do it yourself!

--gera.

White Lightning

[dreez]

Have you ever seen White Lightning, it was a 'joystick driven programming environment' for the Commodore 64 !!

You could program using a joystick selecting statements and changing values etc, it was actually fast also !!

Grtz Dreez

So any data structure == database?

[Anonymous Brave Guy]

Of course, you could use the same breadth-first or depth-first algorithm to search the graph, and the same mean-finding code to average a list, or the grades of everyone in a hash table whose first name is "John". Now that is code reuse.

No, that is called "reinventing a language-specific database".

That depends. Can your database give the performance characteristics of a singly-linked list, a skip list, an array, a red-black tree, a hash table or any other arbitrary data structure? I very much doubt it.

In your posts here, you invariably reduce from "data structures and algorithms" to "algorithms", with the argument that everything should go in "a database". Perhaps this explains your hatred of OO; it fundamentally mixes two things you like to keep separate so you can ignore one of them. Unfortunately, while that might be adequate for your business applications domain, there is a reason that the study of data structures and choosing the appropriate one is regarded by most of us as a significant thing.

Re:So any data structure == database?

[Tablizer]

(* That depends. Can your database give the performance characteristics of a singly-linked list.... *)

I don't know. I don't obsess on benchmarks like some people do. Scaling in complexity is more important than winning static speed races in my book. Most speed problems I encounter are due to bad design, not slow machines nor slow DB engines.

I solve the problems that I see.

(* In your posts here, you invariably reduce from "data structures and algorithms" to "algorithms", with the argument that everything should go in "a database". Perhaps this explains your hatred of OO; it fundamentally mixes two things you like to keep separate so you can ignore one of them. Unfortunately, while that might be adequate for your business applications domain, there is a reason that the study of data structures and choosing the appropriate one is regarded by most of us as a significant thing. *)

Well, I only fuss from the perspective of my domain on my webpage. If embedded systems or factory floor automation or whatever need something special or different, then so be it. However, OOP is being sold as a biz app solution just as much as anything else.

I talk about the trade-offs of seperating behavior and data more here:

http://geocities.com/tablizer/whypr.htm

Re:So any data structure == database?

[Anonymous Brave Guy]

Can your database give the performance characteristics of a singly-linked list....

I don't know. I don't obsess on benchmarks like some people do. Scaling in complexity is more important than winning static speed races in my book.

That's exactly why the data structure you choose is important; each of the structures I listed before has very different performance characteristics in these terms. If you can't model the appropriate characteristics to match each in your database and have a low enough constant of proportionality to be practically useful for the application at hand (yes, the k does matter) then your database solution is no solution at all.

Well, I only fuss from the perspective of my domain on my webpage. If embedded systems or factory floor automation or whatever need something special or different, then so be it. However, OOP is being sold as a biz app solution just as much as anything else.

This has nothing to do with either OO or your business domain. We were talking, in general, about the use of high level functions in functional programming languages as an example of good code reuse. You claimed that writing such reusable high level functions to work with various data structures was just reinventing a database. I called you on it, and demonstrated that this was not so.

Re:So any data structure == database?

[Tablizer]

(* each of the structures I listed before has very different performance characteristics in these terms. If you can't model the appropriate characteristics to match each in your database and have a low enough constant of proportionality to be practically useful for the application at hand (yes, the k does matter) then your database solution is no solution at all. *)

With almost any collection/data-structure, you don't want to *tie* the application code to the *implementation* of that collection. That way you can switch implimentation with little or no change to the application code. For example, your application code should not assume that you are talking to just a linked list or offset-based arrays, because you may have to change implementation as things scale.

Thus, the implementation is not really the issue here. Nobody cares whether Oracle uses linked lists or gerbals for a given query, as long as it works and is fast.

If you extend this idea to its logical conclusion (or at least far), and assume that multiple languages may need to access the same data, then the result will probably be something like a relational query language, or at least a query language with Boolean criteria clauses and operators like standard math operators, concatenation, etc. (There might be alternatives to Boolean clauses, but nobody seems to be pushing them except real mathy geeks, which most ignore for good or bad.)

I don't know if what you propose fits these criteria (complexity scalable without protocol overhaul, implementation independance, and language neutrality). But, make sure it does before you go promoting it over say SQL.

Remember, SQL is a protocol, and not an implementation.

Smalltalk fans sometimes show examples of Smalltalk doing query-like things. It is fine, but it is tied to one language. (Although their messages are seem inconsistent, such as being overloaded improperly if you change the implementation.)

BTW, my SQL overhaul notes are here:

http://www.geocities.com/tablizer/relat2.htm

(* You claimed that writing such reusable high level functions to work with various data structures was just reinventing a database. I called you on it, and demonstrated that this was not so. *)

I must have missed your argument. I don't yet have time to review your links in detail if that is where it is contained.

BTW, I slipped on the OO reference. Sorry about that. Troll trigger-finger Habit.

Re:So any data structure == database?

[Anonymous Brave Guy]

With almost any collection/data-structure, you don't want to *tie* the application code to the *implementation* of that collection. That way you can switch implimentation with little or no change to the application code.

If you're advocating the separation of interface from implementation as much as possible, then I certainly agree. However...

Thus, the implementation is not really the issue here.

That doesn't follow at all. It may be true that...

Nobody cares whether Oracle uses linked lists or gerbals for a given query, as long as it works and is fast.

But that definition of "fast" is only useful in the business domain, where high performance is often not necessary. If you look at any other domain outside business apps -- maths/scientific calculation, games, instrument control, embedded systems, whatever -- then the overheads required to access something like Oracle every time you need to store data are several orders of magnitude beyond unacceptable. Do you actually realise how much of a performance hit would be involved if we all adopted your approach and made everything into a full-blown database? Honestly?

The implementation may not matter to the interface, but it does matter to the overall performance. "Good enough" is a reasonable target, but full-blown databases frequently aren't. That's why the rest of us use a variety of data structures, and appreciate reuseable tools to manipulate them, whether they come from higher level functions, neat uses of generics, OOP or whatever.

I don't know if what you propose fits these criteria (complexity scalable without protocol overhaul, implementation independance, and language neutrality). But, make sure it does before you go promoting it over say SQL.

Why should I care? Some of those things are useful to me -- notably independence of interface -- and those are the things that we count among the strong points of the functional approach. Remember that reusability that you told me was just reinventing a database?

Others, however, are of no value to me. The programs I work with aren't about to be rewritten in another language, and nor are most programs ever written. This just doesn't much happen in real world projects, because the costs and risks outweigh the benefits by a long way under most circumstances.

And as for scalability/complexity... Well, I'm laughing a lot, that someone who advocates the use of a database for everything should ask me whether the data structures I use can handle scalability. This week, I've been working on some data that's pretty much a graph (in the mathematical sense) and, in spite of highly optimised data structures, still occupies well in excess of 100MB of RAM just to load it in, before you start processing it. The application performs some reasonably complex mathematical transforms on the graph, which can take minutes even on a state of the art PC. We're not in the supercomputing applications league, but we're on the limits of what you can do on a desktop.

If you tried to model what we have in a database and look the data up using SQL, the overheads just to parse the number of SQL requests you'd need would take thousands of times as long as our whole app takes to run: you would turn minutes into days or weeks. This is why data structures are important, and why a database is not an adequate solution for anything beyond limited business apps. You may have hundreds of TB of data on a disk somewhere, but get back to me when you can manipulate even hundreds of MB at a speed within four or five orders of magnitude of optimised data structures...

Re:strBias = "don't be so hard on hungarian notati

[1010011010]

Variant... VB. I suppose a ugly variable names are only fitting for an ugly language.

Re:strBias = "don't be so hard on hungarian notati

[rnd()]

Doesn't Python have 'em too... It's really nothing other than treating strings, ints, long ints, and floats as Objects and having smart methods handle numerical operations.

Re:strBias = "don't be so hard on hungarian notati

[rnd()]

Kernighan and Ritchie wouldn't have suggested Hungarian notation, they're not that stupid.

I disagree. I think Kernighan and Ritchie would really like Hungarian Notation, when it is appropriate. I don't believe it's always appropriate, however there are some situations when it can make code much more readable.

Also, let's try not to get too nostalgic for the days when C compilers only distinguished identifiers in their first 8 characters...

Re:strBias = "don't be so hard on hungarian notati

[1010011010]

Ah, you're right. However, I think an editor that knows the language and can assist with variable typing is a better solution than hand-crafted name mangling.

Not a good enough reason!

[robinjo]

That has little to do with Hungarian Notation. Just add a "Chk" or "Hoopla" or whatever in front of the changed variable and the compiler will barf just as well and mark the places you need to check.

If you dont't use Hungarian Notation, you can change the variable back after checking the code. That way you will only commit the changes that really were necessary.

Re:Not a good enough reason!

[HopeOS]

The comment was in response to HN being an impediment to changing variable types. I believe the argument stands on that merit.

-Hope

Other cool stuff that Charles Simonyi has done...

[CryptoKiller]

...was to fund Richard Dawkins' professorship:
Article at www.world-of-dawkins.com.

Hmm

[greenrd]

Did you read the rest of the post?

Support

[greenrd]

He doesn't need any more money, BTW. He's already a billionaire, and he's actually investing some of his own cash into this new company.

Re:Ever heard of LabView? - try Python

[robberbarron]

FYI. LabVIEW is not an interpreted language. It has a compiler under the hood that takes your program and generates x86, PowerPC, etc.. machine code. Since the syntax check happens as your are editing, the compile is very quick and you don't notice that it's there (since it doesn't need to generate errors, etc..) The only version of LabVIEW that was interpreted was LabVIEW 1 and it was slow (hence the addition of the compiler)

Knowing the variable's type is **not the point**

[seattlesque]

I have bones to pick with some of Simonyi's other ideas, but H.N. is actually good. I'd go so far as to say that if you understand it and apply it properly, it is one of the best text-code notations possible. BUT NOT BECAUSE IT TELLS PROGRAMMERS THE VARIABLE'S TYPE; that's nearly irrelevant.

The REAL purpose--if you read Simonyi's Ph.D thesis--is to piggy-back off of the already unique names of types in order to avoid having to give variables names and let the name be provided by context! If you are writing a routine that destroys a window:

void DestroyWindow(HWND );

Wouldn't you ideally like to omit the name of the variable? Isn't it obvious what it does? Calling it "HWND TheWindowToBeDestroyed" is clutter and just makes the source look like a mess.

But the compiler forces you to give variables a name, that's the way it is. Calling it noname12314 is okay from a technical point of view, but programmers can't decode that. Fully Hungarianized names, such as:

HWND hwnd;
HWND* phwnd;
HWND rghwnd[3]; ...communicate to any Hungarian-ized programmer reading the source that these variables don't have unique names. They are essentially nameless, their meaning supplied by the context. Instead of giving them random strings (like "x") which could cause people to scratch their heads with all the possible associations ("why call it x? is it a variable we are solving for, like in an equation?") it at least carries along one fairly useful piece of information (the type).

But the type is just a side benefit. If you can't think of a name that does more good than harm, it saves you from naming. Of course Hungarian also has a way to encode useful information if you think of it: this is what the suffix is for, e.g. if you have two HWND variables you *must* discriminate somehow:

HWND hwndTopmost;
HWND hwndUnderTopmost;

(even though "hwnd" is free in the scope, they couldn't

• both

be called "hwnd"!)

It's rather depressing that even within Microsoft, nobody gets it; like any other tool, it wreaks havoc in the hands of the ignorant. (Just look at the Windows APIs themselves, they don't get it at all! No wonder Hungarian Notation has such a bad rap.)

Ideal relational model? (was: Code-free pro...)

[Tablizer]

(* Duplicates are not needed at all. *)

It may be a matter of convenience. For an analogy, While-Loops are *not needed* if you have recursion, but many just find loops more convinient than (just) recursion.

(* It is just file processing prior to import into the system. *)

What if I want to process most of it *as* a table instead of as a file(s)? Table operations are often more convinient than file fiddling IMO.

I don't necessarily want my convenience limited in an attempt to achieve some idealistic purity. Perhaps the idealistic purity has benefits that outweight such limitations, but at this point I don't see them.

WRT "Oracle clones", I meant in a general sense, not a syntactical swappability sense. The current RDBMS follow a kind of copycat approach. That is perhaps why they don't follow your suggestions. Being like each other is more important to sales than implementing the (alleged) "ideal" relational model. Nobody seems interested in the later. You are welcome to evangelize it, but I suggest you improve your presentation. (My pages need an overhaul also, BTW.)

Existing data and tools just may be stuck in a kind of proverbial QWERTY of the proverbial relational typwriters.

Re:Ideal relational model? (was: Code-free pro...)

[leandrod]

> It may be a matter of convenience.

It is not convenient to subvert a logical model. As said before, if you need ordering, do it in the host programming language, but do not subvert the logical model. Why mix them up? Why contaminate the logical model with something that can be conveniently done elsewhere?

Sorry to say this, but I suspect you are more interested in defending yourself than in learning. But in case you want to learn indeed, as an exercise you may try to demonstrate any benefits of ordering in the logical level of the database and in the corresponding data language, and why this cannot be done in host language or separte utilities.

> What if I want to process most of it *as* a table instead of as a file(s)? Table operations are often more convinient than file fiddling IMO.

OK, but do so prior to incorporate it into the database. If you want to have an associated tool that knows about files or DBFs or SQL, and that offers facilities to declare data conversions that help in the transfer to a normalised database, so be it. But if you mean to make such a data set part of the database, than you forfeit performance and simplicity, not to mention data integrity. In the long run it is much more convenient to have a correct database.

> Perhaps the idealistic purity has benefits that outweight such limitations, but at this point I don't see them.

The responsability of educating yourself falls on you alone. I already gave you bibliographic indications, you ignore them at your peril. And your customers's.

> current RDBMS

There are no current RDBMS, no matter what SQL vendors tell us. If you want to make conversation and exchange of ideas, please do not ignore information I have offered you. Just to repeat: SQL has inherent, arbitrary logic violations that make it something other, less powerful, more complex than a relational system.

Re:Ideal relational model? (was: Code-free pro...)

[Tablizer]

(* try to demonstrate any benefits of ordering in the logical level of the database and in the corresponding data language, and why this cannot be done in host language or separte utilities. *)

Very simple: If you implement it in say 10 programming languages, then you have to repeat the implementation up to 10 times. However, if the DB engine handles it, then you only have to implement it *once*. It is a matter of proper consolidation. QED.

Similarly, if you have to upgrade the sorting algorithms, for example, adding UNICODE support, then you have 10 language engines to update where it would be only one if on the DB.

(* ignore them at your peril. And your customers's. *)

You are beginning to sound like a rabid zealot. Customers don't want something that is completely different than what they are used to.

Go ahead and tell them that Oracle is full of sh*t and that you have the magic answer. You perhaps might be right, but nobody is going to listen to you.

Re:Ideal relational model? (was: Code-free pro...)

[leandrod]

> Very simple: If you implement it in say 10 programming languages, then you have to repeat the implementation up to 10 times. However, if the DB engine handles it, then you only have to implement it *once*.

Excuse me... are you hinting that you use a programming language that cannot make use of sort routines? Which is this brain-damaged language? And Unicode support, you expect that a DBMS will take care of everything and programming languages will not need to know their bytes?

I suspect you are spoiled by too much, perhaps almost exclusive but certainly prepoderant, exposition to the navigational 4GLs of the 1.980s, like xBase, Adabas and the likes of them.

One can create a data language that is computationally complete, and even SQL is so now. Alphora Dataphor D4 and all proposed Ds are also. But still there will be people who will prefer to code in their pet languages, whatever their reasons, and so ordering will always be done as algorithms after presentation of data to the application program or user. One can even have something like ORDER BY without much fuss. What cannot be assumed in ordering in attributes or tuples in the database, because this complicates the whole model and implementation.

I see you refuse to do your reading. Unless you educate yourself, I do not see how this conversation can be useful to anyone...

> tell them that Oracle is full of sh*t

No need, after some experience they learn it by themselves. But then, one who has been warning that there are other, less idiosyncratic implementations of SQL, like IBM DB2 and Berkeley PostgreSQL, certainly gains credibility. And then they start to hear when you ask for better database education, and even consider the possibility of evaluating some D.

Too Late...

[dbCooper0]

Just today I followed the link...yesterday my son decided to infect me with a Gator "attack", which beyond processing with Ad-Aware prompted me to delete mucho cookies.

In my haste, I blew away not only my /. cookie, but my NYTimes cookie. I didn't know this until I used the link to the printable version.

Darn :((