Just post any new features you would like to see in your dream editor.
Any weird,amazing, impossible-sounding ideas are welcome.
Dont be afraid of souding foolish. Remember all great ideas sound foolish before they are implemented!
Posted on 2001-08-01 07:03:11 by MovingFulcrum
My dream editor has a lot of code complet.
Api, Api constants and also a code comlete
on structure items as this: mov ofn.
The '.' triggers the code comlete list by checking
what ofn is and then gives me a list of all items
in the struct. Would really save me a lot of time
because I dont have to check the helpfile.
Posted on 2001-08-01 07:34:24 by KetilO
I'm with KetilO, I think code completion would really help with all the structures and API methods in windows. Most the time the editor is just waiting for the user to press a key - this time should be used to help the user with their task. Another example would be if I type 'MyPROC PROC ' then the editor would search down to find a 'MyPROC ENDP' and if it doesn't find it then it would create that line. If I edit the PROC name then the editor should change the matching ENDP to match the changes. There are many examples of this type of 'help' from an editor.

Speaking of languages: doing this feature in a general way requires a language to describe different types of input and the ways in which they should be predicted.
Posted on 2001-08-01 09:32:09 by bitRAKE
in my opinion the MS IDEs are fantastic (even the horrible VBA things).

the best IDE would have the pull down menus that appear, in order to help you use Structs and stuff, and the "syntax highlighting"
Posted on 2001-08-01 15:05:36 by SubHuman
An editor where you could set "performance" points. Like breakpoints, but they will count clock cycles, cache misses, branch misprediction, etc. For example, you set a pair performance points between the code you want to test, you set the type of data you want to measure, you specify how many values you want, etc.
Then you run the prog, and the IDE display the results.
Posted on 2001-08-01 15:27:11 by Dr. Manhattan
Thats sounding a bit more like a test bench... :)

Myselft.. Function/Macro/Segment recognition... such that i can easily jump back and forth between proc's and data segments as well!

Posted on 2001-08-01 15:52:54 by NaN
My dream Editor...hmm
all I'd need to tell my dream editor is the end resuult of my program and it would create the fastest smallest 100% bug free code...IN ASSMBLY of course

thank you
Posted on 2001-08-02 06:48:53 by MArtial_Code
I am with MArtial_Code in this one, I want an IDE that can do what I think, always get it right, thought completion so it completes the program by itself if I get bored with it, does perfect code optimisations and produces the correct minimum size EXE. It wil be optimised HEX of course.

Does this sound like a MAC users choice ?

Meanwhile I will continue to use mine, it only does what I tell it to but I can live with that at the moment. :tongue:


Posted on 2001-08-02 06:57:33 by hutch--
Afternoon, all.

The best editor I've used was a trial edition of 'Optima++' back in '94.

It used a brilliant help file which you could look up info for a function, then drag 'n drop the function you choose into your code. After that, it opened another help file inwhich you selected new or previously defined variables/arguments/etc. Then it generated the appropriate code for you. This was a great attribute to create the basic outline of your proggy.:)

Posted on 2001-08-02 07:05:58 by Scronty
... oh, there's already is a thread for this topic ...

Here's a slew of wishes:

I program in ASM when I want to precisely control the CPU. So an Ideal Editor would show me what's going on by assembling the instructions as I'm typing, then display the address (offset from some arbitrary reference of course), machine code and u-ops (for P2+ cpu's) in columns to the left. From there, one has enough information to optimize the pre-fetcher and branch target address by swapping lines of code and inserting well placed nops.

That this can be done while writing the program virtually eliminates the need to recursively profile and adjust the source code in later steps. (aka. do it right the first time)

In a similar vein, FPU instructions could be appended with a symbolic stack that shows the instruction latency. For example: (the ;;'s are added by the editor)

; X1 = X*vX
; Y1 = Y*vY
ASSUME esi:PTR struct_with_x_y_vx_vy_members
fld .X ;; X
fmul .vX ;; X*vX(3)
fld .Y ;; Y X*vX(2)
fmul .vY ;; Y*vY(3) X*vX(1)
fxch ;; X*vX(1) Y*vY(3)
fstp .X1 ;; Y*vY(2) !! 1 <-- mul not finished
fstp .Y1 ;; !! 1 <-- mul not finished !! 1 <-- previous fstp stall

Used with the above display of adresses and u-ops one could blend in integer instructions for a loop with the FPU code, resulting in the elimination of the loop overhead (because the iterate, compare, jump instructions can be performed 'between' FPU instructions.

Expanding the idea, FPU operations get pretty lengthy and simply building symbol names based on the instructions will generate very long names. So a method of specifying an intermediate name would need to be implemented as well.

Getting even more idealistic: Macro expansion ! Perhaps a small + in the left margin would expand the macro and show the code actually generated without having to laboriously assemble and check the listing file over and over again. This should include what the .IF and INVOKE statements do as well.

Since we're in Win32 land, how about loosening the calling sequence for API's ? It's frustrating having to 'research' the help system just to open a file. For example:


Would get rearranged to:


Of course this isn't always possible. 'Something' has to tell smart_invoke that OFFSET szFileName is a filename and not a security attribute pointer.

Another helpful tool would be local variables that are referenced to esp and allocated on the fly. This would be useful for 1 time JIT initialization code, or local variables in a leaf-node.


is_initialized dd 0 ; one time init flag
PROLOGUE_OFF ; disable auto ebp stuff

my_proc PROC STDCALL param:DWORD

test esp, needs_initialized ; initialized ? ( esp never == 0 )
jz initialize ; jump if yes, otherwise fall through

mov eax, param ; assembler 'knows' that this is
ret 4 ; stdcall, we clean up the stack


dec is_intialized ; set this now

CREATE_LOCAL rect:RECT( 10, 20, 100, 200 )
; generates:
> push 200
> push 100
> push 20
> push 10
> rect TEXTEQU <(RECT PTR )>

; do initialization work with rect

> add esp, 10h ; clean up the stack
> rect TEXTEQU <rect> ; prevent code below from seeing rect

jmp do_work ; jump back to main body

my_proc ENDP

Naturally some internal tracking of all the locals needs to be done, otherwise esp references will become hopelessly jumbled. Depending on how far one wants to take it, this might require live code tracing.

While this brain storm continues,

Two key macro record + key assign, maybe alt-, key-assign, record actions, then alt= to finish.

Multiple clip boards.

TextSwap command, ie. Swap all "esi" with "ebx"

Register use tracking would nice. ie. "take me back to the previous use of this register"

Lastly: If anyone is seriously doing any work on these fronts and has a plan to capitalize on it, let me know, I need the work.

Posted on 2001-08-02 10:13:51 by Andy
Ok guys,
I see amazing ideas already. But please keep them coming:alright:

BTW, the weirdest idea of all till now by MArtial_Code -

My dream Editor...hmm
all I'd need to tell my dream editor is the end resuult of my program and it would create the fastest smallest 100% bug free code...IN ASSMBLY of course

See if someone can come up with something better than this :grin:
Posted on 2001-08-02 14:06:57 by MovingFulcrum
What do I need in a good editor? Let me think... first of all, integration
with MSDN, so I can place cursor on <whatever> keyword, press
F1, and make it invoke MSDN. Shouldn't be too hard to code.

Syntax coloring, of course. But implemented in a scriptable way,
I guess... so that multiple languages can be hilited. Probably chosing
syntax scheme to use based on file extension. (EditPlus does this).
The coloring could (in the beginning) be implemented as a keyword
and color combination list, but preferably "something scripted". This
would have to be done in a fast way, though.

API/function QuickHelp and auto-complete - but in an unobtrusive way.
VS uses tooltips, but these can get in the way. I'd prefer a single
line, perhaps the status bar, to show the function parameters.

Structure autocomplete can also be useful, but it should only pop
up if you want it to! Keypress, probably. For the people who use it
a lot, having an option to always pop up might be a good idea.

Preferably not too tight ties to any language. And a lot of scripting
so I can extend the editor myself. All that U/V pipe and profiling stuff
is (imho) better suited for a specialized app... after all, you're not going
to do intensive optimization on 90% of your code, and I want a good
all-purpose editor.

Macro expansion isn't too important for me, either. I tend to write
macros once, sometimes do lots of hard work debugging them, using
disassemblers or source listing. From then on, I hardly need to look
at the expanded macro - after all, that's why I use macros :).

Andy, if you need "smart invoke", why not just create a set of macros
for the APIs you need most? More reliable than an editor guessing
at your intentions :).

I guess that's it for now.
Posted on 2001-08-02 19:48:19 by f0dder
One-click operation to save the current text file, try to
assemble it, and go directly to the first text line (if any)
containing an error. I know this would take some doing.

Text search, and search-and-replace, both forward and
backward, case-sensitive or not. Maybe also with pattern-matching, which is quite tricky to code.

A dropdown list of recently-used text files. Point-and-click to switch from the currently open file to any of those.

All editing functions have names, whereby
the user can assign them to any key he is used to, by
writing an INI file (or a section in TOOLS.INI).

Some editing functions (search, save-as, etc.) take a text
argument. We can put the cursor or mouse on a word, hit
one key to highlight the word, then hit a hotkey which
invokes the editing function _and_ passes that word as
an argument. Recently-used text arguments (e.g. for
search) are kept for subsequent reuse, or editing and reuse.

Great idea, this "wish list" thread.
Posted on 2001-08-02 21:33:19 by Larry
Oh yes, I also want the editor to NOT have a toolbar. Menus and
good keyboard shortcuts are so much better -- why waste screen
space on fancy graphics in a programmers editor? ;)
Posted on 2001-08-02 21:40:54 by f0dder

Right with you on the no toolbar concept. Moving a hand to the mouse and back gets irritating after a while.

Granted, the features I described are very ASM specific. An ideal editor would have to know enough to enable the features or not.

Macros can be used for smart invoke, I've done a few, they're a chore to be sure. The algorithm has to fail if it's not 100% certain of the intent, otherwise it 'is' guessing and we can't have that.

Macro expansion would be a luxury, guess it depends on how complicated and how deep you make them. I think the expansion would very useful 6 months later when your on a bug hunt through dark and scary code.

Personally, I find profiling and re-writting to be a chore. Would be very nice to have enough information inside the editor to write an optimized version at the first go around. Would come in most handy for FPU code, which I do a lot of.

Posted on 2001-08-03 03:16:01 by Andy
Being a webdesigner, i believe your needs of an editor are different from the others. I beleive that you must be lost all day in those WYSIWYG tools like Dreamweaver etc, but sometimes you too need to write to write some Java,html, VB code in a raw editor. If you would write about your favorite editor, it would be very helpful.

Are the needs of an editor for game programmers different from the others? I think even your ideas can be very precious.

To everyone,
Your dream editor doesnt need to be asm specific, if u can give ideas about editing in other languages like, VB,java, etc, it would be very helpful.

So bye for now and keep your posts coming. I just love them.
Posted on 2001-08-03 05:05:13 by MovingFulcrum
Anybody know that Indians from south of India have superior skills
in the information technology and software development which is
well known all over the globe.
Posted on 2001-08-30 05:29:14 by forge
How far south of India are these Indians?

Do they live in boats, or just tread water?
Posted on 2001-08-30 07:45:57 by Ernie
Ernie, roflmao!

I like Indian Buddism, and believe that it is that philosophy that has lead to them thinking about programming differently. My girlfriend is Buddist.

I won't say much more as it would veer into a religious discussion. :)
Posted on 2001-08-30 08:01:20 by bitRAKE
I too am a game programmer, and the most helpful thing would be a side bar that you could program to display values of data or registers as you progress though the program...

for example:

data1 dd 25
data2 dd 09543

Now when I get to this line the sidebar displays:
data1: 25
data2: 9543

mov eax, data1

data1: 25
data2: 9543
eax: 25

add eax, data2

data1: 25
data2: 9543
eax: 9568

mov data1, eax

data1: 9568
data2: 9543
eax: 9568


So what ends up happening is it's almost as if the program is compiled in real time and displays the data in real time as you progress though the lines of code. It's almost like debugging your code before compiling.

If you notice a variable isn't what you want it to be, you can save yourself an illegal operation :)
Posted on 2001-08-30 15:59:38 by Kenny