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.'"
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.
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.
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.
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).
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!!!
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.
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.....
Has he heard about COLORFORTH ?
Trolling using another account since 2005.
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.
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.
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.
See PARC's history and search for "Bravo", or read the summary below:
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?
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
- adam
Drag 'n Drop one's own programs together? Been there, done that, in 1994 no less. NeXTStep Developer.
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)
Hyslop and Sutter on Hungarian
(In summary, don't.)
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
The Raven
That's what the Open Source Java community is trying to do. .class files if we want.
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
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.
Arrogance is Confidence which lacks integrity. -- me
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."