Slashdot Mirror
Does Relying On an IDE Make You a Bad Programmer?
itwbennett writes "Writing about his career decisions, programming language choices, and regrets, Rob Conery says that as a .NET developer he became more reliant on an IDE than he would have with PHP. Blogger, and .NET developer, Matthew Mombrea picks up the thread, coming to the defense of IDEs (Visual Studio in particular). Mombrea argues that 'being a good developer isn't about memorizing the language specific calls, it's about knowing the available ways to solve a problem and solving it using the best technique or tools as you can.' Does using an IDE make you lazy with the language? Would you be better off programming with Notepad?"
It's easier to learn the language when assisted by an IDE. Qt Creator is my favorite, followed by NetBeans.
Real programmers use butterflies.
I say this knowing next to nothing about programming. So, I might be incorrect.
It makes you a bad programmer in the same way that using an automated spell checker on your novel makes you a bad writer.
i.e. not at all.
See subject.
Its a tool. Used appropriately you're fine.
Who ever said using an IDE is bad? IDEs are powerful tools that improve developer productivity. The problem with the older generation of IDEs (especially older versions of Visual Studio) was that they focused too much on graphical UI builders that produced brittle, often subtly buggy UIs and unreadable code and encouraged the writing of spaghetti code. Remove the useless UI builders, and you are left with syntax highlighting, code completion, code folding, incremental compilation, and lots of other useful tools that increase productivity.
I remember the days when all real programmers needed was a magnetized pin and a steady hand *puffs pipe*
Tubby or not tubby. Fat is the question
Is "relying" an overstatement? Yes.
An using an IDE doesn't make a bad programmer any more than using a table saw makes a bad carpenter. It's just a tool, if it can help you be more productive, why shouldn't you use it?
Look, it's nice when you are well versed enough in a language to not have to lookup method/function names, nor their arguments. But let's face it, it's hardly the mark of an amazing programmer to have a photographic memory.
Programmers solve problems. Being able to understand the problem well enough to develop a solution for it is far more important a skill. Writing well documented code using a uniform style further boosts the quality of the output by helping make it maintainable.
An IDE is, at worst, neutral in this regard, if not beneficial for assisting in the last point.
Mod me down with all of your hatred and your journey towards the dark side will be complete!
Eh, I don't think so. IDEs are great and all that and what tools you use doesn't matter in the end; what matters is that your code does what it's supposed to do reasonably-efficiently and without any "misfeatures." These tools usually also allow you to reach your goal faster than if you were to do everything manually, and in many cases time is money -- hobbyist coding being a separate issue. The language, the tools and so on really matter only in cases where you're developing for very limited systems, like e.g. embedded systems.
That said, I never found an IDE I felt at home with and I've always just typed everything away manually in Nano in a Linux-console...
When I was in college, I started immediately with an IDE - largely with no development experience. This was a struggle because the IDE was doing things that I did not understand. Ultimately, one of the elder geeks (a properly bearded and pony-tailed Yoda) suggested that I start at the beginning and develop with a text editor and the command line. This worked. Once everything was properly understood, the IDE is useful for saving time and catching typos. But I still need to "go back to the beginning" in order to find out what I am missing sometimes.
More
Yes.
"Would you be better off programming with Notepad?"
Um, hell no. If you have to ask... Studio and other IDE's make me more productive. That's their job. If I had to fish for declarations of variables every minute and remember all the intricacies of the language, I would, well, be living in the 70's. If I couldn't use an IDE I wouldn't have time to /. QED
If only Apple has been using an IDE that looked for unreachable code...
Unstable Apps: Our Android Apps Don't Suck
IDEs are to programming as anti-lock brakes and Traction Control is to driving, as fly-by-wire is to flying, as any assistive technology is to anything else.
If they didn't exist, someone would write one because they are so useful.
When Fascism comes to America, it will call itself Anti-Fascism, and tell you to give up your guns.
All the IDEs that I have used lack good text editing features. I end up having to reach for the mouse. Fail.
So I always end up back in Vim.
Real programmers don't need the handholding of GUI tools.
Offhand, yes, you are a less effective programmer if you rely on the IDE. I've seen many "programmers" that get completely lost if the IDE doesn't autocomplete everything for them. They have no sense as to how the program as a whole hangs together. (Note the specific phrasing of "rely on the IDE". Not the same as "uses an IDE". Not using the tool is silly. Requiring the tool is the problem.)
Also, "Would you be better off programming with Notepad?" No. A decent text editor is a must. Many programmers who "don't use IDEs" actually use text editors which are actually more powerful than many IDEs.
All tools have pros and cons. In general, yes IDEs are good. Is it possible to rely too much on a tool, and not understand enough of the language? That's possible, sure. But that's not regarding IDEs specifically, that's just in general. I'm sure there are some old school CLI geeks out there that will thump their VI totems and say the only real devs use text editors, but that's just an extreme, of which there are many. Be a good dev, and use the tools that make you efficient. Don't use them as a crutch to shore up bad practices.
I will shred my adversaries. Pull their eyes out just enough to turn them towards their mewing, mutilated faces. Illyria
Up next: do you really need source control?
sic transit gloria mundi
Mombrea argues that 'being a good developer isn't about memorizing the language specific calls
As a recent C# convert, I can tell you that for me, it has become quite addicting.
Relying on a sophisticated IDE can definitely contribute to keeping someone a mediocre developer, but it doesn't do it by itself. Likewise, it's easier for someone who is a bad developer to skate by with a sophisticated IDE, because it helps them figure out the answers to problems without them always really understanding the answers.
That said, a great IDE can maximize the efficiency of a great developer, just like a fast car will make a fast driver even faster. If you choose not to treat Visual Studio like a crutch, and use the time that it saves you to continue learning more and better methodologies, you will become a better developer.
For me, Visual Studio saves me a lot of time that I would waste on trivialities. I can use that time to focus on writing good code, learning new techniques like extension methods and yield, and putting more energy on good use of source control like check in comments and branching.
Are there bad developers in my field? Absolutely. I think there are more than there would be in the Java world, because Visual Studio can make it easier to "fake it" for longer than you might with another language. This can be solved by a better recruitment process to weed out people who are just looking to hop onto a contract for 6 months before their employer realizes they are useless.
If you are in school, it's worth punching out a few small applications in Emacs or Picos or Notepad or whatever the kids are using these days ... just to prove you can. But once you have a job, and you've proven yourself a few times, you should use the best tools available to you.
If you are really worried about being a bad developer, spend an hour a day on Codewars.com.
Just exactly how would one use it inappropriately? Inquiring minds must know.
The problem I see with IDEs like VS is that the hide a lot of complexity to programmers, which is good to boost your productivity, but the fact that you don't really know what's going on inside can back-fire if you are starting as a programmer. I've always thought that it's a good thing to do low level tasks at the beginning so you can build yourself up and don't depend on a specific tool.
Open Source Network Inventory for the masses! Kuwaiba
I'm glad somebody tagged this "idioticstory" because it is. Developers use whatever tools are available. Sometimes if the tools aren't available, they write them themselves. I've used development tools of one kind or another over the last 30+ years, and there are a few I've written myself. Frankly, I think that if you don't use development tools, and don't ever think about writing your own, you're a little like the clueless user who just knows, "I click here, then I click here," without any understanding of what they're really doing or trying to accomplish.
The use of complex tools is what separates us from the rest of the animal kingdom.
Proverbs 21:19
There is nothing wrong with using and IDE, that doesn't make you a bad programmer. Relying on an IDE does make you a bad programmer. Lets face it, there is a lot of boiler plate boring crap involved in programming. Using an IDE to handle the mundane stuff makes a lot of sense. But if you can't do your job without it then you are probably not very good at your job.
Using a calculator doesn't make you bad at math. Being unable to do math without a calculator makes you bad a math.
And that's the real issue: Programmers who do not know what "makefiles" are, how dependencies are being tracked, what "compilation units" or "object files" are, they are completely lost when the linker stops with some cryptic error messages telling about some "PIC incompatible symbol" or alike.
Also, programmers relying on IDEs are prone to also rely on 3rd-party code without asking questions. When their application fails, they claim its not their fault, because the crash dump shows some library function on top.
And lastly, programmers relying on IDEs often dislike to understand concepts before using foreign code - if they are asked to "support SSL" in their application, they press some key to search for function names containing "SSL" in their name, and if the function vaguely seems to fit, they call it. They don't start by reading the generic introduction documentation part of the library they are using.
Yeah, call the above stereotypes, but I've just seen a lot of statistical correlation.
Hammering in a screw? :-)
Not if you need to actually debug it.
No, but you might be better of programming with gVim...
Relying on an IDE makes you a more productive programmer. Programmers who think they're elite because they use some primitive text editor are simply wasting time. If that's your attitude, why are you writing code on a computer at all? Why not go back to punched cards? Or cuneiform on clay tablets?
Would you be better off programming with Notepad?
If having the most limiting tool available makes you a good programmer, then I recommend using Edlin. Or perhaps punch cards?
My scripting/programming is exclusively in Matlab and similar tools so I can't weigh in here EXCEPT as a novice programmer. I tried in past to play around with android (which is java) and separately to relearn what little C/C++ I learned in my college days. As a novice, learning a new IDE is a sizable wall to climb. These tools are not documented with beginners in mind, and I was spending most of my time just trying to get hello world programs to build and link correctly when I wanted to learn the language instead. The IDE was an impediment at my level -- but maybe I was just learning the wrong way. When I was taught C++, it was 'learn C first, learn objects second, learn STL never'. The new strategy seems to be encourage use of standard library containers right away. Similarly, if I were to learn proper IDE use from the beginning (and I include visual interface layout tools under that heading) my experience would be different. I _have_ used tools which look like IDEs when preparing LaTeX documents (LaTeX is a typesetting markup language used in technical publication). Autocompletion of commands and previously defined labels (variables) is invaluable. I'm an inaccurate typist with a bad memory. Even if I weren't, I suspect computers are better at remembering those kinds of details than I am.
The answer is: No.
The Kruger Dunning explains most post on
As one poster wrote, using a spell checker when you write a novel doesn't make you a bad writer. That's true, but it doesn't make you a better speller.
An IDE doesn't make you a bad programmer, but it doesn't make you any better at retaining the language specifics (any more than a spell checker helps you become a better speller... people don't use it to "improve a weak skill" they use it "instead of developing the weak skill"... )
I've seen plenty of folks who can think, but couldn't do ANYTHING without an IDE. That's like a carpenter who uses an electric circular saw, but couldn't use a hand saw if the power was out....
This is just the emacs/vi argument dressed up.
The Kruger Dunning explains most post on
Would you be better off programming with Notepad?
Notepad is crusty and not better than anything. Notepad has a glitchy word wrap, it does not allow different color themes and it does not show line numbers, for starters.
You can throw out the IDE and use Notepad if you want, but I'll stick with my IDE and be done in a fraction of the time, with less bugs and better quality code (thanks to all the tools I use in the IDE). Less bugs because the IDE will help with cut down on cut & paste errors with code analysis. Higher quality of code because of things like auto formatting, code analysis, etc...
As many have said before, it's about solving problems, not memorizing the 100 overloads for a specific call. I know what the problem is, I know what I want to do to solve it, why not let the IDE help me do it faster?
Visit the Arcade Restoration Workshop @ http://www.arcaderestoration.com
This guy is a web monkey that spent his day playing drag and drop games in a UI editor. From his perspective, yes, the IDE made him a bad programmer. The trouble is, what he's talking about really isn't an IDE in the complete or even normal sense. An IDE is a toolbox with many tools, a saw, a hammer, a screwdriver, perhaps even a CNC machine, but ultimately writing software isn't about sitting down and George Jetsoning the CNC machine all day. If that's what you've done with your software development career that's unfortunately, but don't blame toolbox, blame the carpenter.
Two of my imaginary friends reproduced once
Perhaps if DICE had used an IDE, we could have avoided Slashdot Beta.
Perhaps a better question might be what is the best way to teach someone how to code? With or without an IDE? The first language I learned in college was C, and we wrote C inside of pico. It was a huge pain in the ass, but it made you have to know what you were doing. If I am writing C# these days, I love the auto-complete features in Visual Studio. I wonder though, if I had learned in an IDE first, would I be less likely to use a language that maybe doesn't have an IDE? When I build UI's in Visual Studio, I just use the drag and drop system. I dislike having to go and edit those generated files when I need something to be a particular way. Assuming everyone is as lazy as me, I would wager that someone that has only used an IDE is considerably less likely to try their hand at a new language if doesn't have an IDE.
Notepad is essentially what we ARE programming with using an IDE like Visual Studio. The paradigm is the same, enter with a keyboard, edit with a mouse. But you know, the last time I looked I had ten fingers, not one. And as a touch typist, taking my hands off the "home" position, is darned inefficient. Now, I'm not trying to argue that "vi" is what we should be using, but I'm way faster editing with "vi" than with either Visual Studio OR Notepad. Why is it that the IDE's have advanced development functionality in every way but one? Are all you guys hunt-and-peckers (or all the developers at Apple and Microsoft)? Even worse, with regards to editing the IDE/Notepad paradigm took a big step backwards and stayed there while the rest of the process has pushed on to better things.
The answer to this question is going to be drastically diferent for web application development in ASP.net than it would be for firmware development in C++. These guys are speaking from the web application side of the world, that context really shapes this debate.
The question these two are discussing really is: "Is it wise to become dependent on the GUI wizzards in Visual Studio to develop ASP.net applications?"
It can make your life easy, but it won't write the code for you.
It leads people to rely on building the application with the IDE instead of issuing standard Makefiles
In other words, it causes the programmer to rely on an automated build system instead of an automated build system.
Let me rephrase how I understand AC's point: It causes the programmer to rely on a proprietary automated build system instead of a free, portable automated build system. An IDE that exports to Make or another common automated build system lets people rebuild the program without having to procure and install a copy of the IDE.
IIRC an IDE it is an app that provides a text editor, build/run automation and a debugger. All to be easily accessed from some menu/shortcuts system. How can any of these components, separated or integrated, impede the intellectual development of a programmer?
Unless, of course, the programming language that the IDE implements is a retarded one..... then blame it on the language, not the text editor.
Whether or not you use an IDE ought to say very little about how good of a programmer you are.
What makes a good programmer is someone who can produce stable, maintainable code in a reasonable time frame and someone who isn't worried about getting fired in order to fight for these goals. One part of maintainability is readable code and the other part is being able to communicate what you've done through documentation, written or oral.
Over the decades I've found that it makes no difference what tools you use, or what your age or educational or cultural background is. It doesn't matter so much whether you write few or many tests. You need to be patient, stubborn, thorough, curious, a problem solver, a voracious reader, and a great communicator to be a great programmer, and you need to have been doing it for at least 10 years. But companies should not shy away from helping to give someone those 10 years, because the best programmers will still do good work early on in their careers.
If you write code that just works but is unmaintainable by anyone and you hole up to write your code and you have no ability to communicate what you have done then you are a horrible programmer and you should be fired. There is a myth among some people that these are actually great programmers. These types of programmers tend to be, but are not always, extremely well qualified in terms of their educational or other experience but they make life difficult for all the other programmers that have to maintain their fragile junk. Fortunately, this type of software is less common in the free software community because this type of programming is called out.
> Have you changed your code to make the IDE happy?
In both java and php, IDEA leverages comments to do tricky introspection. It's largely beneficial, but in some cases a small effort. Worth the tradeoff, or I wouldn't use it.
Yes. If you were a Real Programmer (TM) you'd focus your mind and flip bits on the motherboard.
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
... there's something else that might. It's the ever-increasing percentage of functionality we implement through choosing, including, configuring and glueing together existing frameworks and libraries.
But remember, when you're programming on a DG Eclipse, Speed kills.
Oh look, it's this thread again.
My biggest complaint about IDE's and why I don't use them often is that I have to program all over. My home environment is not the same at work, is not the same 'on location' is not the same 'on the road,' etc.
I program in the leanest way possible. I use the tools that will be available (or be made available) wherever. That means I use text-editors. I use 'vi' in Linux/Unix shells and I use Notepad++/Sublime on Windows. That way, where ever I am, I always have my 'tools' with me.
If I had the luxury of a more stable 'situation' for programming...meaning I knew I'd always be at the same desk, using the same IDE every time I wanted to do something, then I'd definitely learn it and use it. However, constantly switching platforms, languages, desktops, operating system makes it a bad idea to 'get used to' or 'rely on' any tool that can't be expected to exist in the next situation.
--Welcome to the Realm of the Hawke--
...you wrote the IDE yourself :)
Being a bad programmer is a state of mind, leave the tools of the trade out of it.
99% of the time if you hear someone questioning the utility of using an IDE, notepad was never in the running as a serious option to begin with. Just stop it. Don't say it's name. Notepad is a 24 year old joke stuck in the 90s feature-wise. The runners are programs like Sublime Text, BBedit, Text Wrangler, gedit, Jedit, notepad++, or even vim.
Just because someone tells you that you should drive your car less doesn't mean they are forcing you to walk everywhere you go on your feet. You can bike. You can ride your motorcycle. You can ride the bus. You can ride an electric bycycle. You can rollerblade. You can ride in someone else's car. You can ride the train. You can fly in a plane.
Anyone mentioning Notepad seriously in their comments on this article has no knowledge of what a proper text editor is and have an apathy to find out so they can actually contibute meaningfully to the conversation.
Use the right tool for the right job.
IDE == application and UI programming. Usually lots of business logic or use cases.
text editor == optimization or network programming. Usually non-UI graphics, socket stuff, bit banging.
oh and lastly (flamesuit ON)....
vi == everything else.
If you can get the job done and get a paycheck what difference does it make?
love is just extroverted narcissism
It's actually easier and quicker for me to use than an IDE. I usually use Bash as my shell and Kate as my text editor (Kate is similar to Notepad++ in functionality which is what I used before my switch to GNU/Linux). when I compile projects I either use a simple Makefile or CMake depending on the size of the project. I've done OS detection and resolution with Makefiles before.
while
Visual Stuidio?
Get free satoshi (Bitcoin) and Dogecoins
Much too modern... http://www-03.ibm.com/ibm/hist...
Have a Day!
I can tell you from experience from the development side of things that having a good IDE and proficient knowledge of it's features can greatly improve productivity of a team. You still need to know how to compile at a low level and what the various link and compiler options are and you should know how to use a native debugger but if you want to be productive and not worry about the minutia of details then use one. An IDE doesn't make you a better programmer but it does make you more productive and you can focus on learning those nuances and skills within the chosen programming language more easily, allowing you to gain more proficiency.
The whole "you don't need an IDE" may be true but it's like hunting bears without a rifle. Sure, you can hunt bears without a rifle but if you have one it's much easier and you get less bloody.
Harrison's Postulate - "For every action there is an equal and opposite criticism"
Code completion is great. Trying to remember the exact syntax of internal libraries is one thing, but trying to remember how all the functions are overloaded when dealing with custom libraries is even worse.
Err... did it have an "int" here and a "char *", or was that a String... damn.
I'm surprised that so many of the comments for IDEs are restricted to things like autocomplete. IDEs do far more than that. Things like smart refactoring (beyond GREP/Replace), code searches and navigation (find references, go up and down the object hierarchy, find impls), and debugging (attach to remote process, breakpoints, etc).
This is a perfect article for the 80's. You know, when computers had less computing power, less space, well less of everything. Yeah, in those days you could know a whole API of some library. Hell, you could know everything about programming the IBM PC (or any of its compatible clones). Secondly, you didn't have to write that much code because you couldn't write that much code. Remember, computers paled in comparison to today's machines. Your application fitted on a floppy. It does not require a DVD to install. Sure, in those days, you had no excuse if you couldn't cut it with vi (or your favorite text editor of choice).
IT'S 2014 FOR CHRIST'S SAKE! With the tremendous computing power we have today software has grown leaps and bounds. There are many APIs to know, and some APIs are large (like they have mini-APIs hiding inside). The programs we write are very large in size because they are feature rich. Maybe we aren't writing each line of code, but we construct programs module by module and they end up becoming very large because today's users take for granted a minimal set of features that would be considered Star Trek advanced back in the 80's. IDEs are not a crutch for dealing with millions and millions and millions of lines of code, it is a necessity. I'd really like to know how anyone could manage today's software with vi. Yeah, it could be done if you didn't value your time and had nothing better to do in life.
I look forward to tomorrow's article titled "Does relying on the web for reference material make you a bad programmer?"
I can't wait for next week's "Does relying on industrial equipment make you a bad skyscraper builder?" And here are some comment's from next week's article:
"My daddy used a hammer and a saw. Why can't today's construction workers do the same thing when building the Burj Khalifa?"
"Yeah, I second that. They build the pyramids with sand, water, and good ol' elbow grease. Technology makes us weak and unskilled."
"Guys, it took a long, long time to build the pyramids. It takes less than a decade to build a modern skyscraper. This is not exactly an apt comparison"
"Shut up, idiot! No true construction worker needs heavy machinery. You must be gay."
I started writing code on a VT102 with a line editor (edt)... I progressed to 'vi' on a vt320... That was paradise... Until I switched to an IDE and have never looked back...
Xterm and vi FTW!
just use VI and solve the problem
"I don't pitch OpenSUSE Linux to my friends, i let Microsoft do it for me
Obviously, of course vi(m) is almost acceptable too ...
or teco, but only if you need to write assembly code (or lisp)
all other IDEs are of course for sisis....
I agree with that an IDE should be used as a productivity enhancer. But only after you have understood what it means to compile and how it all fits together.
Personally I use Emacs for most C/C++ development and Eclipse for Java (with emacs key-bindings)
However I have seen occasions where the support given by an IDE makes an organization get away with a rather smelly code base. Where the IDE becomes more of artificial life support then a true productivity enhancer. This is what I see as the greatest risk of an IDE, that you can get away with bad code for far longer then if you did not use an IDE. Which will cause you to hit the inevitable complexity wall much later and with more severe consequences.
While when using non or less helpful IDEs (like emacs or vi) you have to structure you code much better to keep it maintainable and understandable. You will hit the complexity wall sooner, which will make it more natural to refactor and rework code that has become too complex at a point where it is not very costly to do so. In my opinion you will get more intimate with your code and build system, which gives you a better understanding of what really is going on.
Personally I would not trust a programmer that can not use a text editor and a command line to build at least simple applications.
Yeah. Plus someday you'll be stuck trying to debug something remotely and all you'll have available is vi. Where's your IDE God now?
Problem with remote debugging is that it depends on the IDE or at least parts of it being on the server, and having the firewall open. Installing the IDE on the server wasn't possible. Whether you could or not, it was Not Allowed because of administrative dictates. And the firewall could only be opened if you could specify the exact ports, and they couldn't be on the list of forbidden ports (which included the standard DCOM ports and the IPSEC VPN ports, opening those allowed too much through beyond just remote debugging).
TBH all that was why I preferred working on the Unix side of things. SSH was allowed, and once I had an SSH terminal window I could do pretty much anything I needed. Going into the Windows development environment was like walking into a briar patch: always snagging yourself on things that had nothing to do with the job at hand but couldn't be ignored.
If the IDE is helping you catch typos and quickly dig out references like method names, that's one thing.
If the IDE is providing so much scaffolding for your project, "wizards" and such, that you don't actually understand what's going on, that's another thing.
(I've seen both.)
Using it to help you do a task you cannot do without it.
I.E. when the IDE fails to help you can you still do the job?
I'd liken it to a surgery robot. I as a non-medically trained person should not assume this will let me perform surgeries.
But it may help a skilled surgeon quite well but he can take over if the robot crashes where as I cannot.
Sadly I see most using the IDE as a normal person trying to code like a developer.....
Personally I use a combination of Vim+Nerdtree+tagbar for C/C++/Python and eclipse when forced to deal with Java. I'm also a believer that Java nearly requires the IDE purely because it's grown into a bloated mess that can barely be managed without one.
But real languages and such.... nah just use Vim and properly open the documentation for whatever class you are using instead of typing SomeClass(DOT) and waiting for the IDE to tell you what's there.
When doing C++ coding for instance you cannot just be happy "knowing" what functions are available... You need to know return codes, what headers those are found in, are they typed or enums, etc. Then all the quirks like if this function is thread safe, signal safe, block/wait free, etc.
If you are just blowing through using the IDE without knowing all those things I'd say it's hurting you more than helping. Cannot tell you how many bugs I've fixed where I was just being a tard and expecting some function to do A when clearly in the documentation is some text saying not to pass a B into it... and surely enough I've passed B.
I'd bet that moving to Vim for C/C++ development did more for my actual programming chops than any "shortcuts" eclipse provided. That an learning command line git after years of cvs/svn. That too really helped.
It means you're a bad developer because you're using .net to make webpages. You should always use the right tool for the job.
Last time I tried to use Visual Studio, the startup time was taking longer than it did to install, so I dumped it in favor of anything else.
Almost all "smart" IDEs do this. In addition to that, in PHP you're actually making both the IDE and the piss-poor-excuse-of-a-reflection-engine that PHP has happy :)
Over the past few years, I have been modernizing the literal development of a lot of the software where I work. A lot of the developers came straight out of college to interact with a lot of older, anti-IDE developers. Additionally, I have been strongly pushing (but not so singlehandedly) using recent, open source/standard build tools rather than ones written inhouse.
Naturally, they decided that that must be the best thing for them because real programmers do not use IDEs. Fortunately, this was not my first job, so I came here and refused to switch to vi or emacs, and I have constantly pressed developers (particularly younger ones) to use IDEs to be more productive as well as to spot errors sooner.
With a lot of our software being written in Java (the rest being C++), we have a hodgepodge number of developers sporting Eclipse, but the recent majority has been IntelliJ. The quality of code has gone up significantly amongst the people that have adopted IDEs, and this has been pushing the bar up for the rest that do not as code reviewers are starting to spot the issues that their IDE warns them about, which they otherwise had no idea about. In the case of Java, there is a lot of abuse of generics by people not aware of how to use them, but IDEs catch issues earlier than the compilation step for beginners--and those that simply don't get it.
Personally, it's my opinion that not using an IDE makes you a bad developer excluding a few exceptional cases (e.g., areas where IDEs are not allowed, which is a good reason to know how to use tools like vi at--at least--a basic level). And, unfortunately, time only keeps proving me right with very few exceptions.
in XCode the extensive LLVM warnings can reveal a lot of issues that pertain to incorrect usage of the computer language, not just the APIs.
"There is more worth loving than we have strength to love." - Brian Jay Stanley
To admit that you've an IDE helping you is too hard for rockstar programmers.
Shame that I cam in so late because I think I have the definitive answer.
First of all, if writing the code for a GUI, then a WYSIWYG IDE is a must. Something like Delphi.
Second, for everything else using an IDE does not make you a bad programmer. Relying on an IDE does.
That makes no sense.
You're basically saying:
Toolbox: application and UI programming
Screwdriver: optimization and network programming...
An IDE is just a bunch of tools grouped together., including a text editor.
probably too late to jump into the discussion but I work with several developers who shun the use of IDEs, they're all 'VIM or die' mentality. The funny thing is their code is full of problems, from undeclared objects to undefined variables - all over the place. Much of the code is completely untestable and I'm constantly cleaning things up because my IDE picks up the stuff they missed because they are all gungho hacker devs. Bad developers exist regardless of what they write code with. I like my IDE personally, integrated debugging tools, code hint/completion and built in stuff like LINT make it easier for me to get actual work done.
I have been using visual studio professionally since version 1.5 on windows 3.1, ie: 20yrs. I do not write (serious) .net programs and never have, VS is not the only IDE I am familiar with, but it is my favourite with "eclipse" a close second.
You sound like someone who tried it once, found it was different to the QT you love and gave up. If you want a job coding you would be wise to explore it a bit deeper than you have. Not suggesting you give up QT but in my (considerable) experience you often don't get a choice of IDE when you take up a programming job. For example: The large code base I currently manage and help maintain is cross-platform C/C++ which aside from running on win32/64 and windows itanium, is also expected to build and run on various flavours of linux, sun, hp, and aix. I'm not going to change all my build scripts just so the new guy can build a private development version with QT, nor will I pay for a commercial QT license when the department already has an MSDN subscription that comes with the defacto industry standard IDE for windows.
And did you exchange a walk on part in the war for a lead role in a cage? - Pink Floyd.
Hammering a screw with an IDE means job security in government work.
Actually, a hammer does make you a bad carpenter. It's the least skillful and least effective method for joining pieces of wood together.
Don't complain about syntax, grammar, or spelling. There is no.hell like input on android.
Real Programmers don't need an IDE to get their jobs done-- they are perfectly happy with a keypunch, a Fortran IV compiler, and a beer.
Argue anything you want but the one who earn the most obviously do the better thing vs the one who do the worst regardless.
Huh? That's retarded. Many of the greatest works of mankind were not remunerated.
Someone had to do it.
If you're a bad programmer, your code with an IDE will be bad. If you're a good programmer, it won't. Stop blaming the tools.
I'm trying to teach myself to set people on fire with my mind... Is it hot in here?
Its OK to use an IDE to help you, but its not OK to need one in order to do your job.
Lack of fundamental software development skills and knowledge of the underlying environment is the true issue. Perhaps I'm a bit crusty, but I think that all new programmers should spend the first 2 years of their careers coding from the command line.. a shell of their choice (bash/ksh/etc), vim or emacs, a build tool (ant/make), using scripts to start, stop, and deploy your own services, knowing how to configure and actually use a remote debugger instead of splattering code with unnecessary print statements, learning how to trigger stack traces and interpret them, merging code by hand, etc. After this "apprenticeship", they would graduate on to "journeyman" status and allowed to use an IDE if they want to, but they would always have the strong foundation to fall back on in times of need. More importantly they could train new generations of programmers.
My department has standardized .NET as our platform of choice. Before this standardization, we had used a variety of technologies, including perl, which didn't require an IDE to use.
Later, we hired a bunch of .NET programmers, and most of them are totally reliant on an IDE. We showed them how to maintain our perl programs using vim as the interface. Most of them didn't get it. It reminded me of how we talk to non-techie types, where once we start using techie words, their eyes gloss over and they can't comprehend it. These .NET programmers had that same reaction. They didn't feel comfortable working in that environment and made excuses like, "that is old technology" and "nobody uses it anymore". But, there are advantages to using perl (less memory, fast text parsing, etc.) that .NET doesn't have, so we continue to use it.
Refactoring changed the IDE equation. Now, using a tool that understands that code is code, not text is needed to support Refactoring. Given that, you might as well throw in auto completion (Intellsense) for objects, classes, namespaces, etc. Part of the value of the Java, C++ and .Net ecosystems is great tools. And, my hats of to IntelliJ, which brings some IDE tools to Ruby and Python and even JavaScript. Worth the license fees to me.
One can become too dependent on anything. But there's no reason to use a better tool. I'm developing in .Net land now, and VS + Resharper makes me more productive without question. It presents me the information I need in context, quickly and effectively. Nothing wrong with that.
From personal use/observation - they are helpful to get you up and running on a new language or one you have not had much exposure. They catch errors, help with syntax and api calls. But after a certain point they start to become more of a crutch.. almost training wheels. On reason for taking the training wheels off is to prove you actually can ride the bike. The same might be said of an IDE - after some period of time (months? years?) are you able to code without it? Do you really know what it is you are doing? Is the IDE holding back your own creativity?
Every each case is different, there is no black and white on this but I do think it may be worth stepping away from an IDE from time to time just to make sure you've not become over reliant.
You will pry my syntax-highlighting from my cold, dead hands.
The most important characteristic of code is readability by future maintainers (after running). Maintenance of existing code is typically about 2/3 of the long-term cost of software such that emphasizing the writing stage is the wrong target.
If IDE's generate verbose (bloated wind-bag) code, then it's counter to maintenance because it generally slows readability.
Code bloat should be reduced, not automated.
For example, good code will do something like this:
However, many IDE's make it too easy to create this instead (and/or don't recognize the shorter version):
Plus, the service object "path" often changes over time, and if we hard-wire the full path, we have more to change, which may also risk more errors.
Table-ized A.I.
The problem is that with Windows everything runs over those ports. If you open those ports you don't just allow remote debugging, you allow everything that's multiplexed onto those ports: access to file shares, remote registry access, the works. And that stuff isn't supposed to cross the boundary between the office desktop network and the data center. If it were all separated out with every service running on it's own port we'd be golden, but with all those services multiplexed onto the same few ports it's an all-or-nothing choice and "all" isn't acceptable.
Program via the toggle switches on the front panel or go home. Paper tape is for wusses. (IMSIA 8080)
Not production. The servers exist in a data center that's separate from the office network the developers work on (it's not even in the same state). The Windows networking ports are blocked because most of the services that use them aren't supposed to cross the boundary between the office network and the data center. The development and test servers aren't supposed to have the build tools on them, to make sure that when we create a build it's not going to accidentally depend on something that won't be present after the development stage. On the Unix side it's never been a problem, it's easy to install the libraries and debugger and editor without installing the header files or Makefiles or lexx/yacc and the like. On the Windows side the IDEs are so monolithic that the admins can't (or won't) figure out how to install just specific bits of them and have it work (installing just bits is easy, but getting the right bits to satisfy all the dependencies without pulling in the bits that we don't want is another matter entirely) and so they're forbidden entirely. It's an utter mess, and I'd be more sympathetic to the idea that it's the process and organization rather than the tooling except for the fact that we can and do do exactly what we want with tooling that's not based around an IDE so it obviously is readily doable.
The same argument has probably been made back when engineers were switching from punch cards to text editors. All of it has happened before, and all of it will happen again. To me, it's not what you use, it's what you do with it. I work in an environment where most people use vi or emacs to program in C++. I can code circles around them in Eclipse, even though it's not "cool", with less effort, and better code in the end (thanks to refactoring features and code tooltips). I do use vi as well, for smaller, simpler changelists. But for something a couple hundred lines or more - forget about it.
Does driving your car make you less able to walk?
Does turning on the tap make you less able to dig a well?
What do you want? Do you want us to only write 1's and 0's to prove how "pure" and "clever" we are!
Of course IDE's are better. They are designed to make us more productive. Yes, some people are very happy with vi or emacs. Good luck to them.
But IDE makes better programmers because they can focus on the problem they are trying to solve rather than truing to remember the exact syntax and semantics of how to do it.
If /. were still true to itself there'd be an argument between vi zealots, emacs fanatics, and ed enthusiasts, with one lone guy crying out about EDT.
And many of the worst pieces of code in the world have made their authors rich.
I use kate. The syntax highlighting lets me see at a glance when I've made a mistake, there's some useful tools, but it's still lightweight enough to stay out of the way. When I've used IDEs it feels like they're getting in the way throwing unnecessary distracting stuff at me and second guessing everything I type.
This space intentionally left blank
I've recently tried both Visual Studio and Eclipse for C. I have to say they are both where Pascal IDEs used to be in the 1990s, though Eclipse is a few years ahead.
However all that is just a part of the environment you develop in. It's more than the editor and compiler. It's also the operating system (in a wider sense) you are developing and deploying in.
It makes a difference whether you have a well structured system in front of you, where you can reach your goal by a series of orthogonal steps, or you have some knocked together system which barely works and is missing essential tools.
If I had a nickle for every slashdot post with the title "Using an IDE makes you a faster/slower/dumber/smarter/sexier/thinner/holier/racist/terrorist programmer", I'd be a richer man
Fast Federal Court and I.T.C. updates
I get the impression we've discussed this particular question at least twice before on /. but I'm too lazy to search.
Like every tool, an IDE per se does not make you anything. It doesn't make you better if you're crap and it doesn't make you worse if you're good.
Overreliance however, does make you worse. If you are a good programmer, you can work with or without an IDE and depending on your style and habbits, it might or might not make you a bit faster or productive or reduce errors or whatever. Basically, it comes down to personal preferences - whatever works for you.
However, if you cannot program without using an IDE, then you are a crappy programmer. If you use a tool, that's one thing. If you require a tool (that's not required by the task per se) then your skills are lacking.
Assorted stuff I do sometimes: Lemuria.org
from a /bin folder
Wouldn't that be a \bin folder?
... that all the work other programmers do in the IDE, I do by hand whilst my mind solves the next problem.
So far I haven't encountered an IDE that lets me habituate these tasks as easily as my plain old text editor does. That means no IDE so far lets me parallelize my efforts in the same way as my text editor. Though I would be the first to admit that habituation is also - but not exclusively - a question of how long one tries.
It's not that IDEs are bad, it's that in my experience they're in the way of my being effective. In part, it's because they rely on the use of a gesture device so heavily - anything that lets me use the keyboard tends to be better for me. Insert obligatory personal/anecdotal evidence warning here.
I think there is an argument to be made that IDEs with fairly complex UIs will resist habituation, and many IDEs fall into that trap. Whether or not that's true should be examined carefully rather than debated aimlessly, though - and even if it's found to be true, then an entirely different question would be whether better habituation *generally* leads people to parallelize tasks, as I described above.
I am quite experienced in developing software (daily job for over a decade) and I wrote millions of lines of code. I don't use an IDE because I don't like to depend on much software while developing. It also helps to be portable (which is quite important!) and helps to hop to other workstations without headaches. And lastly an IDE does not have the power of a decent text editor (which is quite obvious, because such a decent text editor has been optimized for many years to support programmers and it can never compete with this massive crowd of people steadily improving things).
BUT...
Fortunately, most people respect my choices because I am one of the more important developers in our company, but I can see that many companies actually force tools upon developers, which is quite bad in my opinion. Tools are always to be selected for a specific problem. Programming happens in the brain. Tools are just supporting the output. Consequently it does not depend on what tools you use to decide if you are a good developer (I admit, it can be a hint) but on the way you approach problems.
I think part of that is because for many of the programmers who aren't very good, that is mostly what it is. Like those programmers you find that can only do Java, because that's what they were taught in university. They didn't actually learn how to solve problems, they memorized Java syntax and grammar and can now, poorly, apply it to attempting to solve problems.
Also you seem to see some programmers who think it is at least part of what makes it mysterious, difficult, or "hardcore" or whatever. You see them on Slashdot hating on IDEs as various kinds of crutches and saying that only by programming in a good text editor do you REALLY understand what you are doing. They seem to worry that if what they do is accessible, then anyone can do ti and they'll be worthless.
Of course as you point out that isn't what good programming is about. It is about problem solving, a very particular kind of problem solving at that. However there are plenty of programmers who aren't very good, and for a number of them I think memorization is how they try to convince themselves they are useful.
Being a good programmer is as much about using the right solution for a problem as it is using the right language or system for a solution. .Net isn't the right tool for every job, neither is PHP.
The most common type of code I get an IDE to generate (for Java) is hashcode and equals. I could write it myself, but it is very important that they are done correctly, and an IDE will do it quicker than I could anyway.
Programming in a text editor is like carpentry without power tools. Sure you can do it but why lower your productivity.
You should use the proper tools available for the appropriate job.
"Does using a word processor make you lazy with the language? Would you be better off programming with punch cards?"
Modern copyright is theft of culture from everyone and it retards the progress of the useful arts and sciences.
I copy the debugging symbols file to the web site directory, open up the equivalent source in Visual Studio, select the server it's running on and Attach to the process. Not exactly difficult and I didn't start the program from the IDE.
No.
Craftsman use tools.
Coder's Stone: The programming language quick ref for iPad
Really, the IDE Fx (replace x with 1 to 12) key is not a build tool. You can have the ide call your build tool, but you need to have a proper build tool. Be it make, imake, ant, maven, .sh script, .bat script, just have a properly maintained and documented build process for gods sake.
It is silly to think about somebody that programs in these days using Notepad. It is possible in theory but, come on! A programmer should not struggle to do her work. I think it was Joel (on Software) that mentioned some very important rules about programming: 1. A programmer should always be able to step into her code. 2. A programmer should always be able to inspect the state of the program (variables/registers/memory/...) However, it is very questionable to rely on a particular IDE/tool To a serious extent it is even questionable to rely on a particular language. Being a programmer is about developing programs. About algorithms. The ability to develop algorithms that address one problem or another is the trademark of a professional programmer (and sometimes it is hard to get). I have seen in my professional live wonderful IDE-s raising and even dying (take Delphi for example). I have seen the advent of plenty of new programming languages. And, while understanding that there is a time and a place for everything (yes, I did program using Notepad at some point in my live and yes, I do use Visual Studio/Eclipse/XCode today) one thing never changes: I always develop algorithms.
Using an IDE doesn't hurt you as a programmer. Relying upon one when coming up to speed with a new language may not hurt you either. Continually relying upon one surely hurts. Using one as a productivity enhancement while being able to program without it should be the goal.
Eschewing useful tools out of fear of being a “bad” programmer makes you a bad programmer.
It doesn’t matter how deep your knowledge of the language or environment is. A well configured IDE will allow you to complete your job more quickly. It makes research navigating around a codebase much more straight forward. There’s no reason to do textual searches in a simple text editor when an IDE can parse the language and show you actual references to a symbol, not just things that happen to be named similarly.
All of the “uber” programmers I’ve known who avoid IDE’s are universally less effective than even mediocre programmers who use tools to make their jobs easier. The type of programmer who avoids tools out of the belief that doing it “by hand” is better generally waste more time tweaking their environment, going on architecture astronaut treks, and generally doing everything they can that isn’t actually writing code that gets the job at hand done.
Car analogy: You can change a tire with a wrench, and maybe a long piece of pipe to use for leverage. Or you can use a pneumatic impact driver and get the job done quicker, with less damage to the bolts, and put back together tighter (less chance of bolts loosening, tires rolling down the road without you). Any mechanic who tried to hold themselves up as a hero for doing it the hard way would be laughed out of the shop (and probably out of a job).
Be a Software Simian. Not using tools just makes you a dumb code monkey.
Nowadays I only write scripts (PHP, Perl, Python, Bash, sh) and I debug with print, error_log, echo and exit/quit().
XKCD:Xeric Knowledge Comically Dispen
An IDE doesn't make one a bad programmer. However, it does provide enough of a crutch to fool bad programmers into thinking they're good programmers.
Chelloveck
I give up on debugging. From now on, SIGSEGV is a feature.
In what you earn from doing what you do?
That is the business man approach. "Your value, your contribution to society, the quality of what you do is determined entirely by your ability to make money from what you do".
No.
Skill at an art is not the same as skill at marketing that art. And it's different yet from skill at making a profit from marketing something that someone else did.
Skill at business isn't the same as skill at _blank_
Skill at marketing isn't the same as skill at _blank_
When did Einstein's paper on the photoelectic effect, or his paper on random walk of atoms (sorry, the name eludes me this morning) become "skill"? He got his Nobel for some other paper he wrote, where all he did was point out that the three basic assumptions of physics that people used were contradictory, and what happened when you only assumed two and let the third go by the wayside.
Well, in fairness, pointing out that common assumptions are contradictory probably is Nobel worthy. I'm sure Godel got a Nobel for doing that to math and logic, right?
(actually, I don't know if Godel got a Nobel for his incompleteness work.)
---
Side note: How do you get angle brackets in this text? I had to change those to "_blank_" because I could not use angle brackets around the word "blank".
EDIT: Brownian motion. Brownian motion. I can't actually find an "edit post" button.
Notepad, though? Seriously? At least you might be able to run Brief, if you can find an old copy, the best programmer's editor ever.
Meanwhile, excuse me, I need to go vi that file here at work.
mark
Simple: file shares on machines in the data center may not be accessible to users on machines in the office network and vice versa. Personally I consider that a sensible thing, people are going to use weak passwords and vulnerabilities are going to exist (and they're particularly rampant in the Windows services multiplexed over the NetBIOS and related ports) and the best defense is to simply not have those services accessible where access to them isn't needed. If anything, you'll find me arguing that this just highlights the desirability of environments and platforms that have less of an all-or-nothing approach to services and tools so that we don't have the problem in the first place.
I used to whine to friends that didn't care they were using more cycles than needed to get a problem done. They would just make the minimum user requirements to include a faster computer. Yes, with enough power pigs can fly.
IDEs have their place, but so does vi and assembler (it has been ages since I really wrote a program in binary, but yes, I have done that too).
So in conclusion, I think it takes more vigilance on the part of the programmer to write good code using IDEs. But so does OO languages, and interpreted and pseudo-interpreted languages to keep the program workable, maintainable, tight, and reduce code and data bloat.
... "When you pry the source from my cold dead hands."
That would've been my thought, but if you open up the NetBIOS ports through the VPN it still allows access to services that access to is forbidden so they'd have to block those ports over the VPN and we're right back where we started. And I gave up arguing the point with them because I could still get my work done and I had higher-priority things on my to-do list to spend my time on.
If you need an IDE to be able to do anything at all, yes you are a bad programmer.
Sure, it makes you more productive and helps with testing and building, but it also hides the details that you really do need to know.
If you can write good code without auto-complete and refactoring tools and test them manually and manually build the software, you are good to go.
IDE's are all too often used as crutches by people who treat programming as a black box.
I was taught in my Theory of Programming Languages class that the effectiveness of available IDEs for a language was one measure of a language's useability and I wholeheartedly agree.
I can't actually find an "edit post" button.
There isn't one. I've never been 100% sure whether this is deliberate and intended to promote careful checking before pressing submit, or if it's just because something in the code has been broken since forever.
You can know how to use a terminal on a headless server, write your C code in VIM or EMACS, and compile your code with GCC, and be totally content and remove any overhead, but as long as you understand these tools I don't see any harm in using a program that links your libraries and throws you right onto the starting line with the click of a button. You can only write the same 20 lines of code and manually set paths so often before you're writing your own templates and doing the same thing the IDE would do for you anyway. It's typically natural to start programming in an IDE, but those who rely on it, rather than choose to use it, and never eventually venture down to the command line to build their program from scratch are only seeing half of the picture and will never fully grasp the basic concepts of what they're doing.
+1
Anyone who uses PHP can be safely ignored.
Whether you code in notepad, vi, or whatever in text, or use an IDE, that has absolutely nothing to do with being a good or bad programmer. Having been a programmer for over 20 years, IMHO what makes bad programmers is "object oriented languages". First, I'm sorry C# is not a language, anymore than VB.NET, JavaScript, or PHP is. They are methods of scripting using major parts of other peoples code. When complete, the script can in some cases be converted to binary and used sort of like a real language module, but NO C# is not a language. the fact that Microsoft chose to use "C" in the name is a fraudulent attempt at best to give stature to a scripting tool that falls very short of the mark. Scripting languages are a way to make programming "more accessible" to the masses, but they are not a good way to build applications. C# and VB.NET are SO heavily separated form the "programming" that a new word should be defined (just like all the terminology that was altered to match up with the "hipster" object oriented stuff. Won't see robots programmed with Object oriented code (at least not important ones) nor nuclear reactors, space craft, airplanes, or even cars. WAY too bloated and slow to be of use for anything other than transaction processing. Don't know why someone would dis IDE's and not see how sloppy and frankly unskilled coders today actually are. Borland had IDEs for "C", so did IBM and even Microsoft (though Programmer sWorkbench was more of hammer than a scalpel. There were IDEs for Pascal before that was cool as well. Trouble was people who wanted to be programmers wouldn't or couldn't work with pointers, arrays, structures, and other complex aspects of programming. That is what game us Visual Basic in the early 1990s. Arguably the first wide spread object oriented language (albiet one that didn't do much useful). then of course C++ (essentially extra headers and classes to "C") riding ":C"s popularity as well. I could live with C++, as you could still do "real programming" with it. C++ compiled down to reasonable size, yet still provided hardware interaction. All the "new scripting tools" like C# and VB.NET are is fancied up ASP. SO PLEASE don't go making fun of how others "code" before you understand why most of the "coders" today really aren't coders at all but actually scriptwriters, copying other peoples work (good or bad).
"Any sufficiently advanced technology is indistinguishable from magic." - Arthur C. Clarke
I don't think if IDE can make you a bad programmer but otherwise it can helps you to be a better programmer. I think IDE is just a tool to help you finish your task. IDE tells your mistake, help you to write better code, in short words IDE save your time and let you focus on problem you have to finish. I agree with "being a good developer isn't about memorizing the language specific calls, it's about knowing the available ways to solve a problem and solving it using the best technique or tools as you can." Can you imagine if there's no IDE at all? Think about present situation not in the past where there were not many programming languages.
You guys are getting off track.
If you can't debug without an IDE, you should not be programming.
All those young whipper snappers running around with shoe boxes full of punched cards! Lazy bastards! Just toggle it in like a real programmer!!!!
Sure enough, the cow costume was hanging up next to the superhero outfit and sailors uniform. (S,Spud)
Emacs is complicated enough that it makes you a better programmer just to use it.
-- Did you try Tao3D? http://tao3d.sourceforge.net
I am new to programming and I'm using Bluefish running on Linux. It's a great way to learn using an IDE, that's for sure!
But you didn't mention whether it was a great way to learn programming.
That's what all the excitement is about. I often have to point out to the inexperienced that when they come for advice, I don't care what their IDE setup is, because the IDE won't be there when the app runs in production.
Relying on IDE alone will give you problems when your IDE lets you down. An IDE is still a piece of software with bugs and feature gaps. If you can't fall back to a non-IDE dev process then you are too reliant on a single tool and not a prepared programmer. That said, modern IDEs have so many productivity aids that you would be extremely unwise not to use one as your 'primary' tool.
The answer is different for different IDEs. Some are made to be stupidly easy, for beginners. Some are made to fill in gaps in professional systems. Most are just stopgaps.
As said here, an IDE can help both beginners and professionals. But they can hurt people trying to get from the former to the latter.
To work for both, IDEs need this:
Help the programmer to make modules quickly, as generating with templates.
The generation should be driven by setups such as dictionary definitions.
Allow the programmer to modify the modules as necessary, using the method they prefer.
Help the programmer to find the defined symbols and structures and cross check for errors.
Be able to repeat the generation many times over the life of the app, without loosing the mods.
Be able to link in modules generated in other ways, as in external source, DLLs or APIs.
Use modules in more than one language.
Use different databases and file types in the same app.
Generate fully linked native code, as well as other scripts.
Allow the programmer to write new template scrips to generate specialized modules, and derive them from existing templates.
Have robust third-party add-ons available to expand capabilities.
Have a Debugger that can show you what is happening from source level down to assembler and Hex level.
I use the Clarion rapid application development system. It is not perfect, but it at least makes a start at all of these.
It keeps the application information in specialized databases for the app modules and the dictionary.
It has an embed editor that shows you the source but enters your new code into the app database, so it is included on the next make. Or the next edit.
But it also has a text editor for looking at the generated (or external) source.
The proprietary Clarion language has native types for tables, queues and dynamically assigned strings.
But it also has compilers for small modules in C/C++, Modula-2 and Assembler.
And it re-generates changed modules on every make before the compile and link. Fast.