Has Anyone Tried Making Their Own IDE?
I'm looking for a new project to get bored with and later abandon and this popped in my head due to, IMO, the low number of IDE options available. Sitting here thinking about it the concept is pretty simple, it's just a GUI used to keep track of the commands you pass to the linker and compiler and a way to automate the link -> compile process. You can add in the fancy stuff like color coding the brackets and key words but that's about it. The hardest part seems to be incorporating all of the options to the various components in an ergonomic manner. What do you guys think? Is there some part of this I am missing?
I think the biggest turn off for me is an IDE that doesn't include a compiler with it. One of the reasons I haven't switched to netbeans or notepad++ yet. Also, syntax highlighting and code completion is a most have for me along with a very good log report during compile time. Compare MSVS and Code::Blocks error messages. Otherwise, auto indentation, and possibly integrating astyle into an IDE would be great. Just my two cents.
closed account (3hM2Nwbp)
I'd forsake visual studio for an IDE that has the refactoring power like Eclipse has for Java.
10 years ago I was to a software engineering conference where some well known company who was the sponsor of the conference presented their new version of C++ IDE. When asked about refactoring, they answered they do that in the next release. And 10 years later still no C++ IDE has good refactoring... :D The C++ language design makes dependable refactoring inherently complex problem:
1. C macros
2. lack of modules
3. repeated (forward) declarations of the same stuff
4. no rules to find definitions
and the hardest one:
5. no real type system, which makes refactoring equally hard and fragile as in dynamic languages
These are all things you have to think about before making a refactoring IDE. The problem is *harder* than writing a C++ compiler, well, except the lowest and easiest part of it - the bottom layer for generating code.
1. C macros
2. lack of modules
3. repeated (forward) declarations of the same stuff
4. no rules to find definitions
and the hardest one:
5. no real type system, which makes refactoring equally hard and fragile as in dynamic languages
These are all things you have to think about before making a refactoring IDE. The problem is *harder* than writing a C++ compiler, well, except the lowest and easiest part of it - the bottom layer for generating code.
Last edited on
closed account (3hM2Nwbp)
| they answered they do that in the next release |
I can just picture the programming team standing off-camera shaking their heads and waving their hands trying to get the P.R. guy to stop making promises like that. Still, I suppose that's better than pointing a microphone at a programmer for public relations.
| I think the biggest turn off for me is an IDE that doesn't include a compiler with it. One of the reasons I haven't switched to netbeans or notepad++ yet. |
That's a good thing. Tying an IDE to a specific compiler just creates completely unnecessary trouble.
As far as the compiler was concerned I had every intention of using one that was already made. All an IDE does anyway is call the compiler and linker while passing it the commands you checked off. Using another compiler with the same IDE is just a matter of feeding in those commands differently, you could probably even keep the same check box layout.
I was under the impression that the compiler already "optimizes" the code when it compiles (unless you tell it not to of course), why would the IDE bother to re-factor anything?
I was under the impression that the compiler already "optimizes" the code when it compiles (unless you tell it not to of course), why would the IDE bother to re-factor anything?
Nobody mentioned the integration with the debugger yet? That's what I'd imagine would be the most difficult part by far.
The debugger interface is hands down the most important part of an IDE. The rest can be found in just about any old text editor.
The debugger interface is hands down the most important part of an IDE. The rest can be found in just about any old text editor.
You can do away without a debugger by using printf debugging in just any language. But you can't do a complex refactoring without a help of a good refactoring from IDE and good type system.
closed account (1yR4jE8b)
I find Netbeans and Eclipse refactoring is sufficient, although it pales in comparison to their Java refactoring.
Yeah, the IDE should just write all of our code for us, in the most efficient way possible...
| why would the IDE bother to re-factor anything? |
Yeah, the IDE should just write all of our code for us, in the most efficient way possible...
| You can do away without a debugger by using printf debugging in just any language. |
This is kind of a dumb statement IMO. Sure it's true, but it's like saying "advanced sorting algorithms aren't useful because you can just use a simple bubble sort".
Having to rewrite code instead of just setting a break or watchpoint = bad.
And I don't see how you can seriously ask the question why anyone would use refactoring tools. Sure they're not very common in C++ as, as already mentioned, automatically refactoring C++ code is hard, but for languages like Java or C# it's an everyday thing.
And I don't see how you can seriously ask the question why anyone would use refactoring tools. Sure they're not very common in C++ as, as already mentioned, automatically refactoring C++ code is hard, but for languages like Java or C# it's an everyday thing.
| rapidcoder wrote: |
|---|
| But you can't do a complex refactoring without a help of a good refactoring from IDE and good type system. |
Yes you can.
It would be more difficult and stupid, sure. But it's certainly possible in any language.
Also, using printf style logging instead of a proper debugger is also more difficult and stupid (assuming the debugging is nontrivial). So I'm not sure what point you were trying to make.
printf debugging is not any more difficult than using a debugger, especially if you don't need to restart your program to add printf statements (like in most scripting languages, as well as in Java), and usually more powerful. Putting a printf / cout / log / tap in the code costs you not more than 15 seconds. Even if putting a breakpoint and watch costs you 5 seconds - it is not a huge difference. And debugger sucks if you don't know the place where the error actually happens - you have to resort to logging anyway, because debugger doesn't allow you to move back in time and see previous program state, while logging does.
What if your program miscalculates something in iteration 24532, but you see the effect not earlier than at iteration 132435? Would you step it manually using a debugger? Or just log relevant variables and find immediately in the log when things are getting bad?
Having a debugger is handy for simple cases (like why the hell doesn't it call this function?), but I can live without it. I have to fix bugs anyway.
On the other hand - have you ever tried refactoring in a dynamic language? It is doable, but it is like doing a fresh rewrite. I wouldn't call it "refactoring". So it is like wasting a week vs 10 minutes of using (semi) automated tool that understands your code and verifies that there are no type errors. So if you don't have refactoring support, you don't do refactoring in order not to break things. And if you don't do it for a enough time, your code will be mess. Just look at most PHP frameworks. Why most of them is crap?
(Not) having a debugger affects only programmer's convenience.
(Not) having refactoring and static type system affects code quality.
That is why I think refactoring is more important.
What if your program miscalculates something in iteration 24532, but you see the effect not earlier than at iteration 132435? Would you step it manually using a debugger? Or just log relevant variables and find immediately in the log when things are getting bad?
Having a debugger is handy for simple cases (like why the hell doesn't it call this function?), but I can live without it. I have to fix bugs anyway.
On the other hand - have you ever tried refactoring in a dynamic language? It is doable, but it is like doing a fresh rewrite. I wouldn't call it "refactoring". So it is like wasting a week vs 10 minutes of using (semi) automated tool that understands your code and verifies that there are no type errors. So if you don't have refactoring support, you don't do refactoring in order not to break things. And if you don't do it for a enough time, your code will be mess. Just look at most PHP frameworks. Why most of them is crap?
(Not) having a debugger affects only programmer's convenience.
(Not) having refactoring and static type system affects code quality.
That is why I think refactoring is more important.
Last edited on
Topic archived. No new replies allowed.