Multiple inheritance often makes it extremely difficult to tell where my code is coming from.
When you don't use inheritance, you often get to refer to another module by name. E.g.
`my_dependency.fetch_data(123523)`
With multiple inheritance, however, that other module has become your own "self"!
Suddenly you're stuck with:
`self.fetch_data(123523)`.
And if you want to find the source of `fetch_data()`, you basically have to grep / look through all seven of your base classes.
If you're lucky, the definition you were looking for calls `self.flush()`, where `flush` isn't defined on this class. It's actually intended to be defined on another base class, which is imported by the multiple-inherited subclass.
So, you effectively have a "DSL" whose "statements" consist of your choice of base classes. It's impossible to determine what's a legal "program" in this "DSL" until you run the thing and get method-missing errors.
Why should I have to learn a hundred cryptic keyboard shortcuts to get what I consider normal functionality? I have in the past used Perl's command line debugger. Why would I want to do that when I have a far more efficient graphical debugger in Eclipse?
I work with bioninformaticians, and many of them are too lazy to have ever set up an IDE. Most of them won't have had autocomplete until Kate included it. Barely any of them uses a step through debugger. Its like a revelation when they ask me for help and I show them it on my machine.
You appear to be advocating a new:
[ ] cloud-hosted [ ] locally installable [ ] web-based [ ] browser-based [ ] language-agnostic
[ ] language-specific IDE. Your IDE will not succeed. Here is why it will not succeed.
You appear to believe that:
[ ] Syntax highlighting is what makes programming difficult
[ ] Garbage collection is free
[ ] Computers have infinite memory
[ ] Nobody really needs:
[ ] a REPL [ ] debugger support [ ] a local filesystem
[ ] to interact with code not written in your IDE's preferred language
[ ] The entire world speaks 7-bit ASCII
[ ] Scaling up to large software projects will be easy
[ ] Convincing programmers to adopt a new IDE will be easy
[ ] Convincing programmers to adopt a language-specific IDE will be easy
[ ] Programmers love learning new keybindings
[ ] There is only one operating system and it is
[ ] OS X [ ] Windows [ ] Linux [ ] iOS [ ] Android [ ] the DOM
Unfortunately, your IDE (has/lacks):
[ ] vi keybindings
[ ] emacs keybindings
[ ] Syntax highlighting
[ ] User-configurable indentation
[ ] Macros
[ ] Written in JavaScript [ ] Written not in JavaScript
[ ] Written in a scripting language you made up
[ ] which is a Lisp
[ ] A windowing system
[ ] Version control
[ ] Only using git [ ] only using github.com [ ] not using git
[ ] using an RCS of your own devising
[ ] Its own platform-independent look-and-feel
[ ] that was designed by a programmer
[ ] based on yesterday's design fads
[ ] applied inconsistently
[ ] A look and feel specific to one operating system
[ ] that was last widely used in 1989
[ ] and was known to cause seizures
The following philosophical objections apply:
[ ] Programmers should not need to understand CSS to change their font
[ ] The most significant program written using your IDE is itself
[ ] The most significant program written using your IDE isn't even itself
[ ] Graphical programming presumes programmers can draw pictures better
than they can type words
[ ] The implementation is closed-source
[ ] covered by patents [ ] not owned by you
[ ] The DOM is not an application framework
[ ] The name of your IDE makes it impossible to find on Google
[ ] Your IDE assumes JavaScript can be made infinitely fast
[ ] You seem to think static analysis is worthless
Your implementation has the following flaws:
[ ] JavaScript is not faster than C, C++, or Java
[ ] The DOM is not a windowing framework
[ ] It crashes on any file larger than 32k
[ ] You provide no way for users to run the program they are editing
[ ] You require the user to check in code before it can be run
[ ] The IDE crashes if you look at it funny
[ ] You don't seem to understand basic optimization techniques
[ ] You think a single string is an acceptable data type for a text editor
Additionally, your marketing has the following problems:
[ ] Unsupported claims of increased productivity
[ ] Unsupported claims of greater "ease of use"
[ ] Obviously faked screenshots
[ ] No one really believes that your IDE is faster than:
[ ] vi [ ] emacs [ ] Eclipse [ ] Visual Studio [ ] IntelliJ [ ] Notepad
[ ] Rejection of orthodox user interface design without justification
[ ] Rejection of usability principles without justification
[ ] Rejection of established platform conventions without justification
[ ] Rejection of basic user interaction without justification
Taking the wider ecosystem into account, I would like to note that:
[ ] Your example workflow would be one key command in: _______________________
[ ] We already have an IDE in the browser
[ ] We already have an IDE that can be scripted using
[ ] Python [ ] JavaScript [ ] A Lisp [ ] Lua
[ ] You have reinvented vi but worse
[ ] You have reinvented emacs but worse
[ ] You have reinvented TextMate but worse
[ ] You have reinvented Eclipse but worse
[ ] You have reinvented Notepad but worse
[ ] You have reinvented Notebad better, but that's still no justification
[ ] You have reinvented ed but non-ironically
In conclusion, this is what I think of you:
[ ] You have some interesting ideas, but this won't fly.
[ ] This is a bad IDE, and you should feel bad for creating it.
[ ] Programming in this IDE is an adequate punishment for inventing it.
Strictly speaking, this issue is not caused by multiple inheritance but just by inheriting from a lot of classes. It also happens with huge Java class hierarchies, for instance.
When you don't use inheritance, you often get to refer to another module by name. E.g.
`my_dependency.fetch_data(123523)`
With multiple inheritance, however, that other module has become your own "self"!
Suddenly you're stuck with:
`self.fetch_data(123523)`.
And if you want to find the source of `fetch_data()`, you basically have to grep / look through all seven of your base classes.
If you're lucky, the definition you were looking for calls `self.flush()`, where `flush` isn't defined on this class. It's actually intended to be defined on another base class, which is imported by the multiple-inherited subclass.
So, you effectively have a "DSL" whose "statements" consist of your choice of base classes. It's impossible to determine what's a legal "program" in this "DSL" until you run the thing and get method-missing errors.