Slashdot Mirror
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.'"
I always prefered Reverse Polish myself.
Let's hope he isn't allowed to take Clippy the animated paper clip with him. die Clippy die.
OddManIn: A Game of guns and game theory.
Quick, get him to work on OpenOffice!
I'm determined to reclaim my karma. Now, if I can only find a groundbreaking article and something witty to say....
And the Smart Rats are fleeing the ship. I wonder what he knows that we don't know.
"Live Free or Die." Don't like it? Then keep out of the USA
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.
"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)
Even Hungarian Notation is a big improvement over having no naming conventions at all.
The only thing that we learn from history is that nobody learns anything from history.
Registration-free link courtesy of asahi.com/english/nyt
main(c,r){for(r=32;r;) printf(++c>31?c=!r--,"\n":c<r?" ":~c&r?" `":" #");}
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.
Does this mean that we're going to be seeing more programs with annoying paper clips?
HallmarkOrnaments.Com
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.
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).
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.
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.
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.
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 ?
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?
The masses are the crack whores of religion.
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.
Table-ized A.I.
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.
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).
You must be too young to have ever seen a flowchart.
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.
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.
Beware the wood elf!!!
If it weren't for Charles Simonyi, I wouldn't be proud to be Hungarian at parties...
:P
Wait... I never actually get invited to parties... damn... day dreaming again...
---
Programming is like sex... Make one mistake and support it the rest of your life.
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.
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.
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)?
Blog Prophyts - Right On, Man
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.
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.
I'm out of my mind right now, but feel free to leave a message.....
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.
.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?
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
But I hate it when my programs get stuck in the vacuum cleaner.
Has he heard about COLORFORTH ?
Trolling using another account since 2005.
Yes, mod him the fuck down because he's reasonable!
<Amanda`> I just went out to the parking lot in my bathrobe to exchange warez CDs.
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.
Slashdot - News for Herds. Stuff that Splatters.
Comment removed based on user account deletion
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.
I'm an American. I love this country and the freedoms that we used to have.
'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...
"As God is my witness, I thought turkeys could fly." A. Carlson
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.
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.
Under capitalism man exploits man. Under communism it's the other way around.
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.
See PARC's history and search for "Bravo", or read the summary below:
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.
/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).
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
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.
--
E_NOSIG
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.
Cretin - a powerful and flexible CD reencoder
...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.
Slashdot - News for Herds. Stuff that Splatters.
"simplify programming by representing programs in ways other than in the text syntax of conventional programming languages,"
Oh... you mean like Magic ?
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.
ceci n'est pas un sig.
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.
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.
Price, Quality, Time. Pick none. What, you thought you had a choice?
Here's one.
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.
Slashdot - News for Herds. Stuff that Splatters.
'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....
There's nothing Intelligent about Intelligent Design.
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.
Slashdot - News for Herds. Stuff that Splatters.
Wow, I get to be the first person to post something actually informative.
/ /w ww.research.microsoft.com/ip/g /digerati/simonyi/simonyi_p1.ht mlw .aisto.com/roeder/active/ifip96.pdf
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:
http://www.edge.or
http://www.omniscium.com/nerdy/ip/
http://ww
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
Hugarian notation is EVIL, and here's why.
....
....
...
....
/* ????? */
...
...." but otherwise the notation creates more problems than it is worth.
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
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.
www.eFax.com are spammers
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.
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)
"Communism is like having one [local] phone company " - Lenny Bruce
Drag 'n Drop one's own programs together? Been there, done that, in 1994 no less. NeXTStep Developer.
I just finished reading Dealers of Lightning which has extensive writing about how Simiyoni got to Xerox and his career there.
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.
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.
Of course. Today it's called work for hire .
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.
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.
If you don't want to repeat the past, stop living in it.
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?
"For a successful technology, honesty must take precedence over public relations for nature cannot be fooled." -Feynman
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.
To a Lisp hacker, XML is S-expressions in drag.
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.
"Genius may have its limitations, but stupidity is not thus handicapped." --Elbert Hubbard (1856-1915)
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...
This is a perfect job for even the simplest search-and-replace functionality.
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.
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.
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.
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.
-- Did you try Tao3D? http://tao3d.sourceforge.net
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.
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..?
What they don't know can't hurt you.
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.
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.
Amazing magic tricks
I for one would be interested to see a Slashdot interview with him.
Hyslop and Sutter on Hungarian
(In summary, don't.)
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.
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.
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.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.
Fascism starts when the efficiency of the government becomes more important than the rights of the people.
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.
Amazing magic tricks
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.
Under capitalism man exploits man. Under communism it's the other way around.
Nope, GPL covers copyright. Patents fall under completely different rules. The GPL (or similar license) would be totally ineffectual in the patent arena.
Under capitalism man exploits man. Under communism it's the other way around.
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.
Under capitalism man exploits man. Under communism it's the other way around.
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...
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.
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.
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.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
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
Muslim community leaders warn of backlash from tomorrow morning's terrorist attack.
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
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...
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
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.
Looking for an Information Security student project suggestion?
Try http://dotcrimeManifesto.com/
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/
(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
WebMaster:
BinFeeds
XXX Thumbnailed Image Newsgroups but
I am so totally unsurprised that Jerry Shultz writes programming languages in his spare time. ;)
The correlation between ignorance of statistics and using "correlation is not causation" as an argument is close to 1.
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.
"I worked at Microsoft for 20 years and all I got was this lousy code!" :-)
-Derek
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.
"Politicians and diapers must be changed often, and for the same reason."
(* 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".
Table-ized A.I.
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.
Babar
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.)
-- Alastair
I guess I deserved that.
"If you think education is expensive, try ignorance" - Derek Bok
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.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.
Variant... VB. I suppose a ugly variable names are only fitting for an ugly language.
Napster-to-go says "Fill and refill your compatible MP3 player", which is a lie. It's not MP3. It's WMA with DRM.
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.
Amazing magic tricks
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...
Amazing magic tricks
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.
Napster-to-go says "Fill and refill your compatible MP3 player", which is a lie. It's not MP3. It's WMA with DRM.
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.
Female Prison Rape in NY
Female Prison Rape in NY
(* 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.
Table-ized A.I.