TPF/GI I like having all of the information about Data Levels and Variables one click away.

TPF/GI - I like the ability to view data in hex and decimal formats; the ability to create panels is great;the ability to set checkpoints is a GIFT

TPF/IDE - it's wonderful to have an editor that has the same functionality and shortcut keys as most regular composition applications; complie options alow needed flexibility in testing as well

I use both TPF/GI and TPF/IDE. TPF/GI is very easy to use, all of the data that i want to see is easy to get to by just double clicking. TPF/IDE makes finding errors easy by being able to jump to the error. The color coding also makes my code easier to read.

TPFGI is a very useful tool. When tracing, a click on just about any field or variable name shows the contents immediately.

TPF/GI I really like the testing flexability that it gives. Being able to restore with a click of a button. Being able to trace and see so many things happening at once can help solve problems so quickly. Thanks.

I am using TPF/GI, GI/TERM, Source View and TPF/IDE. It help me investigate customer problems and problems on the codes that I have written. I can create test scenarios without affecting the test system used by the customer, and I can recreate the scenarios as many times as I can.

I like TPF/GI, TPF/IDE and Source View. With TPF/GI, it is so easy to set up trace options and to trace. There are toolbars available for use. In my company, it is either you trace using VISTA or using TPF/GI. I use TPF/GI because it is easier to use. Source View helps me a lot to trace and track down a problem. Even if I am tracing multi-ECB, it is very easy.

------------------------------------------------------------------Use TPF/GI everyday, I can't live without it. -----------------------------------------------------------------

I like TPF/GI for its user friendliness and precision without which working on CLI is almost impossible in some cases( like checking how many levels are attac or detaced etc)....am excited when i came to know about the features it is em

TPF/GI is an excellent tool for debugging problems that are on the TPF system. Everything is there at a click of the mouse. You can watch the variables change as you step through the code.
GI/Term is a tool that you can have two sessions up side by side and compare the results.
TPF/IDE is great to have because it is just like working in a Word Processing Application.

SourceView in TPF/GI - When tracing a C or CPP program much easier with Source View than the assembler code by itself.

I especially like the way I can open up multiple windows while tracing and watch the data in those windows update as each instruction processes. Not to mention I can quickly alter the data in the ecb on the fly and quickly see how the processing is changed as a result. Make my job much easier.

TPF/GI MAKES TESTING AND DEBUGGING 10 TIMES EASIER THAN REGULAR TRACING IN VISTA. ALSO TPF/GI PROVIDES ME THE ABILITY TO TEST TAPES AND TAPE CHANGES WITH OUT HAVE TO WAIT FOR TEST SYSTEM RESOURCES.

TPF/GI is the product I use most, to debug programs down to the machine code, which helps solve software problems.

TPFGI is a great product that has made program trace so much easier. I especially like how it shows me what values are stored in my C variables when I am in trace. It's also easy to use.

TPFIDE is also great product. I like the color coding so I could see the macros, comments, etc, and distinguish between these things very easily. When compiler errors come back, I like that I can click on it and go directly to where the error is flaggged.

TPF/IDE is a one-stop-shop for multi-platform editing and compiling, accessing listings, and interfacing with the software library in a seamless fashion. I can customize this product so that it works best for my needs.

I use two of your products: TPF/IDE and TPF/GI.
I find TPF/IDE to be very 'user friendly' with its Word-like interface for editing programs. The feature that allows me to access the system library to retrieve source programs directly is very useful.
TPF/GI has made me much more productive, as its graphical interface saves me considerable test time.

TPF/GI - It's great because once you get the hang of it you have a way to see variables and specific data elements as you trace. Very helpful with troubleshooting/debugging problems.

TPF/GI - Makes Testing (Life) lot easier and very user friendly and efficient .Debugging the code has become lot simpler after TPF/GI.


TPF/IDE - Ideal for coding and compiling ,very easy to work with even for the starters , doesn't require much training , rather no training .

both the above product have made my work much easier and as a result I am more productive and less stressed .Assignments and Testing are less time consuming and hence end result is a well tested product in with minimum post production problems .

TPFGI - I quality test prior to release of production products for my team. We use CTFSS in conjuction with TPFGI to receive real time link traffic which gives us a very powerful desktop tool. Occasionally we need to manipulate test cases along with this feature so we use the block and data altering features which is quite nice. We also hand create data records from the on-line system and use the file open to replace blocks during excution.

Testing with TPF/GI makes trying different scenarios a snap. It's so easy to change a data field or jump to a specific instruction with just the click of a mouse. I can test different options without changing code and recompiling first.

I used to use CMSTPF to test my programs and DBDEF's. Now I use TPF/GI. TPF/GI is very easy to load segments and to test with. I have only dabbled with TPF/IDE, but I like what I have seen so far. If I pull up a PDDDS to look at and to compile, the different parts are color coded. This makes it easier to debug and fix. I like being able to make changes directly to the ECB, or other areas, to

I am a regular user of TPF/GI and Source View, usually in combination. They are great aids in problem resolution. I also use them during program development.

TPF/GI - I use this product daily. I am in a QA position so it gives me great flexibility in doing quick troubleshooting efforts. The ability of SourceView and the viewing of core and other resources as they change allows me to get to the root of a problem quickly. I use the trace capabilities to determine program flow and file retrieval information. I think the ability to have the multiple windows open at all times is a great tool for viewing the entire TPF environment while working. We are going to also be using IBM Toolkit Debugger in the future and TPF/GI is leagues ahead of that product. Keep more coming.

The products that I like and I'm always using to code/debug/test my programs are TPF/GI and and TPFIDE. First, TPFIDE for me is the best platform for me to code my programs especially using C/CPP, since I get to see all the characters in 1 line of my code w/o shifting from left to right (I'm comparing it against VM file where it's restricted to view only up to 72 columns). Plus, when I compile my program, it would show me all the errors (if it has errors of course), and by just a click it would point where the errors are (w/o me having to get the separate listing and look for the error myself). Next is the TPF/GI. The nicest thing about TPF/GI is that I get to trace my programs step by step looking at the exact code that I have. I also get to see the values w/ just a click for the fields in my code that it's very useful w/o looking at the core and check for the displacement myself. It's a very useful tool when unit testing my codes.

TPF/GI has saved a lot of time in testing my TPF software. It's displays and ability to change things

I have been using TPF/GI for about 5 years now and it is a great tool because of the ability to step-by-step trace in source view. I also love the DF database display feature.

TPFGI... is an excellant product and has evolved over the years to become a very valuable tool. GUI is easy to use nice interfaces..allows easy data manipualtion..and check pointing..Along with Sourceview it assitants in testing and identifing system problems easily...by examining source code on a line by line execution...Source view handles a variety of coding langauges ... Without TPFGUI my job would be 10 times more difficult and far less productive.

TPF/GI - this is a very helpful tool when tracing down problems. You have a chance to look at your code while you trace. I love how you can look at ALL db recprds, all levels makes tracing and problem solving very easy.
Source View - Is perfect way to jump the the problem area you are looking at with out step tracing each instruction. Can see all the results with just a click of some buttons. Perfect and fast to research!

TPF/GI is the product I find most useful in my current position. Testing my code could not POSSIBLY be easier. I especially enjoy the feature that allows me to display the contents of a field just by moving my mouse pointer over that field. Having the variables display in a separate window is great also. Having the flexibility to alter the contents of a field by typing the new value in the field is wonderful as well. Thanks for providing TPF/GI!

I currently use TPF/GI, TPF/IDE, GI/TERM, SOURCE VIEW on a daily routine. I use these tools because they allow me the ability to accomplish my job's tasks in a timely business manner. I would within the APPL Dev SLC and in the Maintence SLC as well. Being that I am able meet my deadlines by using your tools in correcting problems in a more timely manner, my reviews are improved. When my tasks are within the Maintence SLC - problem resolution is much quicker without a need for an indepth background in the offending application.

CMSTPF - I enjoyed CMSTPF testing tool. The tracing tool I became very familiar with. Without having to set up for different tools, you could find out which segments were involved in a particular process.

tpf/gi - I am beginning to enjoy as I learn more of the tools to use. Maybe there is a tool to explain some of the particular types of tools to use from the tpf/gi screen but I have not found it yet. I usually have to ask someone more experienced with tpf/gi in order to find what I actually could use to get more results.

Probably the feature of TPF/GI that I like the most is the source view facility whereby I can trace my code and see the

I use TPF/GI on a daily basis for testing. When TPF/GI was first offered to us around 7 or years ago, I didn't think much of it because I was use to getting better and better tools. After about a year, I went to work for another TPF shop that did not offer TPF/GI as a test tool. Then, I knew that I definitely worked much much faster when I had the TPF/GI tool. I fortunately came back to the TPF shop that has it and am thrilled to use it everyday.

I use Source View almost daily to test software updates and as a tool in debugging software problems. It has become my first choice in preforming both of these tasks. I allows me to see exactly what is happening in the software and to take whatever path I want. This often saves many manhours when looking for problem or when trying to set up the exact situation to duplicate a problem.

TPF/GI : only tool that I know to trace TPF C++.
It improve development time.
Thanks

I love TPF/GI. Having been in TPF for 25+ yrs. and worked with the likes of step by step and cms tpf, this product is a quantum leap for TPF application coding. I also think IDE is also a quantum leap over xedit under cms.

I use TPF/IDE & TPF/GI for all my coding and testing. I love the GUI interfaces, the color coding & the ease of use. These products allow me to be more much productive and speed up or eliminate the menial or redundant things needed to test in other environments.

I like TPFGI because of the way core blocks, file records and TPFDF files are displayed. I also like the way the you can look at the program flow via the nested enter/back display on the output viewer. The T-REX options are neat, but I have yet to find a need for them.

TPF/GUI - I love this product because it provides every imaginable tool that programmers need to test, trace and debug with. And these tools provide displays with a single click! Sure makes my job easier.

I have been using TPF/GI since 1999. It has made my job requirements so much managable. Graphical interface is always the best way to go as it's so user friendly. To be able to click and see what I am looking for is priceless. The feature I like most in TPF/GI is I don't need to type in any commands. Lately, my employer added a new application, TPF/IDE. With this, I am able to compile any of my programming codes with a click of a single button. Before this, I had to type in different compile commands for different programming language such as C, C++, Assembly Language, Sabretalk and etc. The main feature that I like about TPF/IDE is the color coded scheme when coding in C or C++. All the keywords are clearly highlighted and there will be lesser mistakes.
Today, these products have become part of my daily life. Keep up the good work!!

TPF/GI - I love the fact that I can trace a destructive problem and not impact other users of the test system. It's also easier to see all the important information (e.g. data levels, registers, etc.) with simple clicks rather than several entries.

The products I like the most are TPF/GI and Source View. Without these products, tracing and debugging TPF application programs written in C or Sabre Talk in an efficient manner would be next to impossible. The ability to watch and edit expressions and variables is invaluable. The trace store facility allows me to track down problems quickly and easily. TPG/GI and Source View are great products!

TPF/GI, TPF IDE, GI Term, CTFS
Makes TPF Development a breeze.

TPF/IDE - Easy to use and the color coding scheme helps and makes the coding very easy. The online help feature is an additional plus.

GI/TERM - Very handy tool to debug and test C,C++ programs. It has made the testing and debugging very easy.

I use and like very much TPF/GI, TPF/IDE and Source View. These products enhance the developer's productivity and make the information technology development tasks much more interesting and fun.

I have been using TPF/GI, GI/TERM and TPF/IDE for the last 3 years. In my opinion, without any of this product, my productivity won't be this high. TPF/GI has cut my testing time to half because I'm able to see my codes during testing. By using point and click, and not typing all the specific commands to see any result is a big plus. Able to monitor my result as I step thru my trace is another big plus.

CMSTPF
It was blessing to programmers like me who started working on TPF soon after their college and are used to the software development IDEs. CMSTPF cut down our testing and debugging time considerably.
TPF/GI
It has the same advantage as CMSTPF, just greater features. How cool is double clicking a core address and boom there is the core display. Even Miscrosoft IDE doesn't have this feature.
TPF/IDE
I was one of the first programmers to start using TPF/GI (Formerly named HEDIT in Worldspan). It's a great tool, much better compared to XEDIT. The feature I like the most about is the help attached to it. You select an instruction, hit function key, there you have all information about that instructions. No more searching for IBM book manager.
I consider TPF/IDE is one product, which has great potential to improve hoping TPF, is here to stay.

I am extremely happy with the above 3 products I used for TPF development.

I love TPF/GI because it is so easy to use and it gives me the ability to see what my program is doing without having to remember a lot of criptic commands. The ability to click on an address and see what is there greatly decreases the time and effort required to debug code.

TPF/Gi is a wonderful tool. I really like the way it can be used to stop anywhere in the process and easily display needed fields. It is a great way to test different situations by altering the data without updating the program code.

TPF/GI - I love the ability to have my own test system that isn't affected by other developers and that I don't affect.
TPF/IDE - A great source editor and compile submission tool.
GI/TERM - It's nice to be able to access a test system/production session without having to go through the process of logging onto VM and then executing VISTA.
CTFS - A great tool to allow access to communication links through a TPF/GI or CMSTPF session.
Source View - The only way to step through a C/C++ segment and be able to view variables that I've seen.

I love TPF/GI because it makes tracing easier! You can see the registers and all the other workareas you need to see while doing a step by step trace! And you can see the instruction in the program! It makes the lives of us Assembler programmers easier!

I find SOURCEVIEW and TPFGI to be invaluable tools in creating and testing application programs using TPF C and TPF C++. Due to the size of most of our DLM's trying to test C code in VISTA is pretty much a fruitless endeavor.
I also use TPF/IDE for development of C and C++ programs. The 'PC-like' environment is a huge improvement over the VM environment.

The thing that I really liked about TPF/GI is my ability to work with TPF Transactions coming from other systems. The best example I can remember is this: I was working on a problem for one of our customers that was coming from their website. I was able to access their test website and enter the information needed to start the transaction. This transaction then went to their mainframe system and then came our TPF Test System via a Host-to-Host Link. In doing so, the transaction is given a random LNIATA from a pool of LNIATAs and as such it's hard to tell which one to use in GI for trapping the entry. I finally determined which one was most likely to be used and using the CMS/TPF console from TPF/GI, I changed to that LNIATA once the entry had been trapped in our TPF Test System. I was then able to determine the exact cause of the problem and resolve quicker using TPF/GI and SourceView Tracing rather than using our traditional TPF Tracing product. And the great thing was that I could emulate the LNIATA of the trapped entry in our Test System from TPF/GI. If it wasn't for that capability, the time it would have taken me to resolve this issue would have been twice what it actually took me.

I'd also like to say something about TPF/IDE. I had become a convert to IDE versus our tradition VM-Based environment when I found that from IDE, I could access both my local and network drives as well as my disks in VM. This allowed me to not only access our Library on MVS, but I now had an option of saving copies of files on my VM Disks, my local PC drives or my network drives. This made it much easier to organize programming changes by project or by functional package on my local and network drives rather than having them all lumped on one or two VM disks.

TPF/IDE - it's a lot easier to edit programs for TPF in windows based applications.

TPF/GI - helps a lot in tracing and debugging.

GI/TERM - this is cool. You could have multiple sessions.

TPF/IDE - I like the ability to make directories to contain projects which can include any files, programs. This allows me to delete the entire project when the project is complete. Another feature I like is the ability to move files from the mainframe to the PC so I am not limited to mainframe space requirements.

I love testing with TPF/GI, it is the best testing tool I have ever used. It makes me MUCH more productive. Thanks

TPF/GI - Few years ago when this product came out, I jumped on, happy that TPF has something that came close to a 21st century application!! Thank you!

Point and Click. Everything at your finger tips. Files, DF records,user/system information, tapes, globals, I could not begin to express how useful this product is. I started with non-gui testing products, and if anybody takes away TPF/GI it would mean TO CUT MY RIGHT HAND.

TPF/IDE - Color coded when you write code. Cut, Paste, Submit to library, specially Compile right there, and see the error list at the sametime; then just click on the error to take you to the line where the error occurred. What more than that I need!!!? Maybe there is something else better out there, but right now thank you for my TPF/IDE.

tpf/gi
It's reliable.

What more could you want? If it's reliable, it means I never have problems with it. It is always available. It always works as it's suppose to. It is fast, convenient, and user friendly.

I use TPF/GI on a daily bases in all my program debuging ....................................................................................

TPF/GI is awsome. Using the GUI interface to do testing and problem research makes things much easier than Step-by-Step thru Active. Being able to have multiple windows open and watch how things interact while tracing makes me much more efficient. This is even more enhanced when using the SourceView tool within TPF/GI.

Another tool I heavily use is GI/Term. I really prefer to not use Active which ties up my VM Id. Using GI/Term I can have access to the TPF systems up wwhile still doing things within VM. Another thing I like about it is being able to have up to 3 sessions up into a single TPF system at the same time and then to also have sessions up against multiple TPF systems at the same time.

Needless to say I try to take advantage of my 22

TPF/GI Point and click source tracing and debugging makes problem solution easy.

TPF/GI - I like this because it is very good and fast to simulate and tracing any problem in the system.

TPFIDE - I like this because we can open and change in the same time many programs and docs from different sources and you can have opened the same program on the other window.

TPF/IDE is very helpful in compiling C/C++, Assembler and Sabre segments. I find it very useful that the comments and commands appear in different colors. TPF/IDE is helpful when making updates to C headers. It makes it easy to compile the current verison and the modified version and compare them to make sure the changes are correct.

I use TPF/GI from time to time. TPF/GI is a great tool. You can store the environment. You can rerun the test case over and over.

I use the TPF/GI and GI/TERM the most. The TPF/GI lets me change databases, load programs, trace, and blow up the system to find problems without comprimising the customers test system. The GI/TERM product allows me to quickly switch between several test systems and check differences in code and data.

I like the ability to quickly and easily access GI/Terms Log File as well as search within the file.

The best part of TPFGI is the ability to have lines or links attached to it. You can actually send out your messages and trap them comming back in. This is a neet feature for us in AccessPLUS! - Thanks

I use TPF/IDE. I like the ease with which I can compile and test my C++ programs compared with our change management tool. I really like the find all option and being able to set flags while I am editing the source code. I am an MVS programmer and I am happy to have a user friendly tool that connects me to the mainframe so seamlessly.

I have used most of these products (TPF/GI, TPF/IDE, GI/TERM). It is really a wonderful tool and saves a lot of development and testing time.

I like TPF/IDE for it's easy compile capabilities. This is so much easier than what I had been used to. TPF/GI is the best though. Being able to click on addresses and see records and core blocks is awesome! I'll miss it when my company goes to CC/CQ/TK.

TPF/IDE for several features:
1. Graphical User Interface development for TPF applications
2. PC based
3. Syntax highlighting and coloring
4. Transparent file editing on a host
5. Transparent program assembly and compile on a host
6. Works with existing EXECs and library systems

My life has never been easier than since I started using your TPF/GI and TPF/IDE products. The flexibility and versatility of compiling, loading and tracing segments with these tools is fantastic - things I could never do with the outdated VISTA method (at least not without a manual by my side and twice the time allowance). Now I am able to sourceview a segment, watch specific variables, retrace my steps, alter values as I go if needed and check out a hypothetical fix in my code - all with the additional assistance of color coding and output logging. Seriously, there are just too many aspects to list. It's an invaluable combination of tools.

I particularily like TPF/GI. I was coding in TPF way before we had even CMS/TPF. TPF/GI had increased productivity exponentially. It had also significantly reduced the time to fix realtime problems.

I use TPF/GI, GI/TERM, TPF/IDE, CTFS, T-REX, Source View. I like those products because they give me the feeling I'm developing more windows based software rather than knowing I'm developing on a mainframe. They allow me to quickly deploy software and aid from design, development, intergrated test, customer test and post phases. Through college I worked with IDE to develop code mostly on Linux and probably would not have lasted too long on TPF without these products. Thank you very much!

There are several products I really am glad that we have. One of them is the GITerm. Being able to connect to the test systems without tieing up my VM4 has been incredibly helpful. Also, I use TPFGI all the time. The user interface is easy to customize and it's been a very useful tool for me throughout developement and debugging.

brings testing out of the stone age..with nice visual displays.

TPF/GI
Easy to Set up trace, add Source View files, and run programs.

Run several message files in a row; start and stop logging and recording.

Run EXECs on the host and get the output.
Use dialog boxes to gather and display data. Learn about ScriptDialogs.

I use TPF/IDE, TPF/GUI and Source View and I Really like 2 of the 3 listed. The Source View and GUI are great test tools, but IDE I find a bit cumbersome. I have become so comfortable with Panvelet that I think I just have not given myself enough time using it to get comfortable... but I'm still trying! Keep up the good work.

I simply could NOT do my job without GI/TERM. FANTASTIC TOOL!

There are numerous things I like about TPF/GI. The thing I like the most about it is being able to test effectively with C segments. Being able to see the variables at a glace as well as being able to look as the assemble code behind the C code has been invaluable for debugging. Worldspan's Rapid Reprice product was written almost entirely in C and it would not be near as far along today if not for the ease of tracing in TPF/GI for C segments.

TPFGI - great test tool - our users would keel over dead if there was no TPFGI

TPFGI ? I love the graphicial interface to CMSTPF I like it much better than entering CMSTPF commands. It has great tracing capabilities especially for C program debugging. I really like is the ability to generate an ECB which makes testing that much easier.

TPFIDE ? I like this because it?s makes it so easy to move files from your PC to the host or vice versa without having to worry about the FTP command and formats.

TPF/GI is an outstanding tool. It allows me to stop and alter data to trouble shoot error without have to hard code the situation. You can easlier monitor data levels, variables and ECB workarea at the same time to determine exactly what is happening. Sourceview is an outstanding tool within the package that allow me to alter program paths, which save several hours of trouble shooting.

I use TPF/GI, TPF/IDE, and GI/Term. With all of the products I like them over the green mainframe screen because of the windows appearance. These applications make me more effecient at my job because of all the basic windows functionality. TPF/GI gives a graphical interface making it easy to click on things to view, whereas on the mainframe green screen you would have to type a lot of entries. With TPF/IDE it makes it nice to work with files on your workstation and txfr them to the mainframe. All the usual windows functionality helps also. GI/TERM, I haven't used a lot, but I like the windows interface and being able to just double click on the system that I want to connect to and it is done.

TPF/IDE and TPF/GI

I have been in the TPF business frro over 20 years now, I had a chance to work in several other platforms with all the GUI software they use. I was dreaming to have such GUI features in the TPF mainframe area. Since my dream came true, my life became way easier with these two development tools. My productivity has be improved dramatically. Now I don't have to worry about memorizing all these long weird command and entries, retyping over and over to get it right, the risk to change any of the records since I live in my own development world. Did I mention tracing!!! I can't believe that I can sit and watch my application flow and see any peace of information in few clicks. All I can say, Thanks to IBM and all folks who contributed in building such great tools.

CMSTPF - Its your own local copy of database..Problems??Dumps??..No worries..play with it and get it tested..Great tool for initial testing phase.
TPF/GI - Assembler? C? click->patch->test..forgot tape command formats?no probs..Cool Graphical interface ..
GI/TERM - Connect to multiple host (vpars)systems..jus few clicks..you can log,capture test results..run the scripts..change the preferences..makes your life easier.

TPFGI - GUI interface. Everything is just point and click. One good feature is the create ECB with which we can directly activate a program to test. Best testing environment I have ever worked on.

Source View - Ability to run to an instruction and the ability to branch to and instruction are very helpful during unit testing. Ability to display the contents of the variables and so easily be able to alter them.

TPFGI is a versatile and useful debugging too that I have used since I started TPF years ago. Step by step trace of the old British Airway debugger is a distant 2nd. TPFGI's capabilities to allow esay data manipulation, easy step trace, trace route, data level display with color identifications help immensely with TPF debugging. Many a times, I would open a data level to see the color changed on a particular displacement when the content of the data changed to verify that the instruction is doing what it is supposed to and more importantly doing it to the correct field.

TPF/GI is the best thing that could happen to a TPF programmer... Visualizing every bit of data to suit programmer needs... Simulation & Problem Solving just boils down to Ctl-C/V... Dynamic Program Flows - Amazing...

TPF/IDE - For maybe a .Net expert it would just be yet another IDE, but for a TPF programmer to have one is a blessing...

I have used TPF/GI, TPF/IDE, and Source View. I like TPF/GI because it has Graphic interface and is a very good debugging tool. I like TPF/IDE because editing a program is very easy. Scroll down is a very good feature. I like Source View because tracing a program while testing becomes very easy because it looks at the source code rather than the machine code.

I use TPFIDE over VM4 any time I can. The color coding and font customization have saved me many many headaches and typos. The copy/paste, find/replace, comments/case toggle are great features that VM4 has a hard time competing with. I can also handle large files that XEDIT cannot.

TPF/GI is great for testing C/C++ and viewing variables on the fly. The mouse-over variable display is the best invention since sliced bread.

GI/Term is great because it frees up my VM4 session to be able to submit programs and run other execs that would otherwise keep me from coding while I'm waiting for the execs to process.

TPF/GI: I like using GI for all my testing. With all the information it provide me during my test, it save me at least 80% of the test time. I also like that fact that I can check point my work and then restore it anytime, i want. So of the test case I need to set up is time consuming, sometime it can take up to 45min to set up the case. With checkpoint, I can

TPF/GI is an awesome test tool! the new T-REX features make system effeciency enhancements easy to quantify and justify. They also assist us QA-types with problem investigation and solution. I use SourceView exclusively with initial testing of code revisions because of it's ability to pinpoint problems and show me variable values. TPF/IDE is a must-have tool for all C-programmers.

I like TPF/GI because during trace I can easily see the value of all of my variables.

About TPF/GI it is a very good tool, I like the option to allow tracing through the source code of the programs and the click option to access core and file addresses.
About GI/TERM I really like the printer option that makes life easier to track in/out edifact messages for the on-line system.
TPF/IDE I like the different colors option for macros, comments and commands, it makes things easier to code or to realize typos.

TPF/GI, TPF/IDE, GI/TERM, SOURCE VIEW, CTFS, etc). GI refresh allows for repeating same testing scenario in same test environment

TPF/GI is an excellent product. In my area we run many jobs that require input and output tapes. It is quite east in TPF/GI to mount tapes and run jobs.
I also like how easy it is to do macro traces and to source view programs. I especially like being able to see the value of an expression by simply clicking on it.

Hello,
I use TPF/IDE, TPF/GI, and GI/Term.
I had experience using Microsoft Visual Studio, before I started programming on TPF. The use of TPF/IDE made the transition to TPF coding very simple. It would have taken me much longer to become proficient editing code with Xedit.
The TPF/GI point and click style interface speeds debugging process and eliminates the need to memorize commands for tracing.
GI/Term is convenient for accessing multiple test systems to make comparative entries.

TPF/GI is the best program testing and debugging tool I have ever used in my 21 years of programming. It incorporates all of the good qualities of CMSTPF and the other test tools I have used in the past as well as having many additional options that go far beyond what the other test tools had. It saves me so much time during development by making it very easy to manipulate data on the fly to create the exact scenario that needs to be tested. When used for debugging it allows me to get to the problem quickly and easily. As someone who had spent many years waiting for program listings to print in order to instruction trace segments, the Source View option has saved many hours and increased productivity immensely.

TPF/GI has a lot of handy options. As a TPFDF systems programmer, I'm not familiar with all the applications but am called sometimes to help with a problem. I use the 'trace flow' to log the path their entry takes when I'm initially investigating a problem for someone.

I like that I can look at the Database to see what file records have been accessed and even which ones have been released back to the system.

Source View is also very useful.

I have just begun working with our team installing Toolkit, ClearCase/ClearQuest. I will be learning how Source View will allow programmers to view code - as well as the debugger and other functions of Toolkit. As our development environment moves from the

The two reasons I like the TPF/GI tracing tool are because of its convenience, and the amount of time I save during debugging. With TPF/GI, I can load up and view as many programs as I want for tracing, and the programs can be written by different programming languages. Also, I can simply use the Graphic Interface's point and click system to set break points, view variables, or to perform any of the core or file updates during the tracing. With all of these features, I can cut down a hugh amount of time between program and break point set ups. Since my work involves a lot of problem solving tasks which require fast turn around time, TPF/GI can truely provide me the speed and convenience to make my job easier.

TPF/GI - I have only been actively using it since Jun04, but I'm hooked! I can easily load programs, walk through the lines of code, stopping as needed to view or change data; if I think a bad branch is involved, with one click I can re-route the execution to see if that is the answer. This test tool makes it much faster and easier to find a problem and correct it. I've been using Vista for about 20 years and was reluctant to change; within a week I was using TPF/GI almost exclusively. It has made my job a whole lot easier!

I like TPF/IDE because it allows me to be able to use one tool to view files on all of the different platforms that we have. I also like TPF/IDE because it provides a way to easily move files from one platform to another.

I like GI/Term because I can access multiple systems at the same time.

TPF/GI - The TRACE FLOW tool makes it easy to understand a brand new package in no time. The nice GUI source code trace makes it so easy to identify problems or re-create any scenarios. Input scripts and output capture are also tools to make programmer's life much easier. To be able to manupilate blocks or get files is also something I like a lot.
TPF/IDE - The color coded editor and matching [] and () ctl-key is very useful in my coding. I also use a lot of copy and paste for big files.

I use GI/TERM daily. What I like the most is the ability to work with multiple sessions while still having access to TPF at the same time. It makes troubleshooting much easier.

I primarily use the TPF/IDE and TPF/GI products, which are both excellent. When I first began using C/C++ to develop projects on TPF, IDE and GI made C/C++ a lot easier to learn and debug. I use Visual Studio quite a bit when developing for a Windows application and I always enjoy going back to TPF/GI, just for ease of use. Thanks for a great product!

TPF/GI: The TPF Graphical Iterface has made my life easier, since most of the time spent in programing includes testing the code, TPF/GI has helped me to patch, debug & fix problem faster than before where every need has to sent to the system with Z commands. Now I remember very less Z commands after using TPF/GI.

TPFIDE: To be simple TPFIDE has added color to my work environment. No more BLACK screens, :)

Thanks a lot to the TPF software development team & Worldspan Ofcourse!

Regards,
Mohan Krishnan P
mohana.krishnan@worldspan.com

I use TPF/GI nearly every day. I've never had a class in it's use and often think of something I would like it to do. Everytime I have thought of a desired use I have just poked around until I find that the desired use is already there. Not only does it have the flexibility that I need, it is also user friendly enough that I have seldom needed help to find what I'm looking for.

I have experienced using TPF/GI when working with a programmer on developement issues that need to be tested where it didnot effect Online. GI/Term is great I can run scripts and create different test enviornments and retrieve my previous pricing entries,and the wait time to access is way less than regular VM4 sessions. TPF/IDE is like using a Word document which is easily edited and can print partial or all data to designated printer instead of mainframe.

I have been a QA programmer in TPF for over 15 years, so I am constantly trying to recreate and fix problems. CMSTPF was a huge step forward in problem-solving. It's tracing abilities for single-ECB functions have helped me solve many problems that would have been very difficult in a typical lab environment. Obviously, TPF/GI has those same valuable tracing tools, but with the added bonus of a friendly Windows interface.

SourceView is great because I can be looking at the specific line of code being executed and still see what is happening to all my work blocks, ecb area, etc.

I use TPF/GI and TPF/IDE. What I like most is the GUI interface. Point and click makes work easier and faster. I also increase productivity since I don't have to type in commands and the color coding help to locate code faster and more efficient.

GI/TERM - I like the ability to create multiple sessions, using the 'new custom host' prompt. Running scripts, inputting message substitutions and logging output are all very user friendly in GI/TERM. Having the end of line key is a real time saver.

TPF/IDE - very simple to use. Color code system make code easier to read/understand. Easy to customize.

TPF/GI - much better tool than step-by-step trace... can look at anything at the click of a button rather than having to look up entries only to look at displays that are hard to read, ass with step-by-step trace.

I like TPF/IDE because it allows for immediate syntax checking, color coding for errors, popup help on macros, etc. The ability to compile and view the listings, source, and console messages in separate windows is much more convenient than using VM split screens. The ability to have it automatically behave differently based on language type (i.e. different syntax, etc.) is also very easy to use and very convenient.

TPFGUI is my favourite. It has made life a whole lot simpler witht the graphical interface to trace programs. I do not know how I managed without it before starting to use it.

I like TPF/GI because it frees up my VM sessions to look at listings/dumps/code etc.

I like TPF/IDE as an editor as it is much more friendly than VM tools.

I use TPF/GI on a daily basis to trace system problems. The GUI based product makes my job much easier because everything is available with the click of a button and I no longer have to use Step-By-Step entries to view data. I also use TPF/IDE to update segments and compile C programs. The color coded key words enable me to find compile problems quickly. Both of these products are great!

I love to code and compile my CPP programs in TPF/IDE. The error reporting, finding the location of errors are great but the matching of the brackets is the best feature. It make editing very easy. When I am ready I load the programs to TPF/GI with only a few steps. It is very nice. When I trace the progams after loading I can pick which programs I want to test and speed to the instruction I want to look at with ease. The sorce view program are very helpful by seeing both the program comand and the instruction by instruction as they are processed. I can say I love to test.

GI/TERM is very useful to log into multiple places at one time and seeing the virtual printer data is very easy to view and to cut and paste into another document.

I like TPFGI because it allows me to debug programs easily. With it I can follow program paths and see what variable values are at any time.

I have always like CMSTPF because of how easy it is to see at a glance how I got to a particular point (e.g., set trace options to stop at UIO, then enter

TPF/GI and TPF/IDE are both really user-friendly. In TPF/GI, the ability to display an address pointer, registers and debug using the source-view saves a lot of time for the developer. In TPF/IDE, being able to compile and link programs, specially C++ programs, and display of compile errors makes development easier.

My favorite product is TPF/GI. It makes tracing programs so much easier. When investigating a problem, it aids in quickly finding where a data field within a record is being updated.

Source View allows me to step through and see my source code while I test my TPF application programs. This allows me to concentrate on the logic of my program and not be concerned with the machine code generated by the compiler.

TPF/GI is a wondeful product for testing. The ability to create and alter core block while tracing a piece of code is a simple as clicking a mouse button and typing what you want in the block. this allows me to be able to run the same piece of code with different conditions without restarting the process every time. the database files help me in my job to recognize what file addresses have been released and what addresses are being lost in the system. It is a very intuitive product that makes me more productive at my job.

The combination of TPF/GI, Source View, and TPF/IDE makes developing and debugging software SO much easier than other tools used in the past. Being able to watch each line execute, and alter data on the fly, make testing a breeze.

TPF/GI - I like it because it's so easy to trace the programs in GUI enviornment rather than in VISTA. You don't have to remember any entries to modify any core or file data. You just display and alter whatever you want. Without TPF/GI, I can't even imagine tracing a C/C++ source file. Also with your own personal enviornment, you can check point databases and restore em whenever you want. You can play with your database in anyway without harming test enviornment for anybody else. And ofcourse, capability of changing date and time of test system gives you much more leverage while testing.

The ability for the TPF/IDE to change colors for different types commands.
The TPF/GI is very good in tracing to allow fast developmental time.