PlayBASIC Replacement IDE Work In Progress

[kevin]

 PlayBASIC Replacement IDE Work In Progress / Round Up

   This thread covers some of the key points during the development of the replace IDE.  Keep in mind much of what you're seeing is work in progress over the past 3 or 4 months, even so the new IDE has a wealth of new features for the PlayBASIC users to explore, while being significantly simpler also.    




PlayBASIC Round Up (July/Aug)

    Been back working in the PlayBASIC trenches since late June really.  The main focus throughout this period has been on the replacement IDE project.   What's wrong with the existing IDE ? - Well, nothing really... It's just not being actively developed anymore.   It's a familiar story, you know, language needs IDE, excited programmer takes up the challenge and sooner or later moves onto something else.  Which puts pressure on the overall PlayBASIC time line.

    After looking for replacement options it became clear the only viable alternative was to build a replacement IDE myself.  I actually started the project a while back, but ironically that was soon shelved, as that project was taken over by another 3rd party.  But sadly the light flickered out all too well.  So it's fallen back into my lap.    

    Now obviously writing something like an IDE, isn't a job that I take lightly, nor is it something that can be knocked together quickler either.  Which means the initial releases of the package may well be missing some features from PlayWRITE.  The upside is we get to build it exactly the suit the PlayBASIC + FX.  

    So far development of the tool is currently just entering the early Alpha testing stage.  Consisting nothing more than the bare essentials to handle the life cycle of the your projects code.  So you can create a project, edit, test and save it.   That's about it.

    The first thing existing users will notice and probably the biggest change thus far, would be the move away from the tabbed project interface, towards a more free range layout.  So multi source projects are no longer only accessible through the tab across the top of your project window, but each sources roam free in separate window.  All the main controls are located on a side panel also (subject to change), where you can manage the current project in focus.  Stuff like adding new sources, removing them, changing the build order, default screen modes etc etc

    Simplicity is a big focus this time around, we're really trying to weed out what's really necessary from the gloss.  In fact the current ALPHA would be lucky to have a quarter of the controls from PlayWRITE at this point, without really missing any of the main functionality either.    Which we feel is going to be lot better for new users.  

    It's not all about trimming the fat though, as the current build has a few nice new features also.  Some that come to mind, would be the vastly improved project building speed (over 20K lines per second), better search engine for the doc's browser and the ability to toggle between compilers.  Which means you can elect to build your project with PlayBASIC or PlayBASIC FX with a simple switch.  Which is very handy.  

    So when will it be available ? - Dunno, we're expecting to move from Alpha to a light Beta testing phase in the coming weeks.   So it could possibly see a public release after that.   I'm not anticipating it being 'final' for some time though.



 IDE VIDEO - 20K Line Plus Build Speed Test

   This clip is of new IDE we've been working on for the PlayBASIC programming family.  The version shown here is early _alpha_,   so while the styling will no doubt change, the core functionality is evolving daily.  Some of the features of the new IDE and the PlayBASIC compiler, are the speed of compile times as programs get larger, which is what this video is demoing.

   In this clip we create a mock up program that's over 23,000 lines of code long by including four slabs of (basically useless) test code in a project.  The code doesn't do anything interesting, what we're looking at here is the build speed from the IDE, and overall compile time .     How fast is it ? -  You'll have to watch the video :)

Music By:
http://www.ardvarc.net
   


PlayBASIC IDE Alternative V0.22d - All The Shiny Things

    The F1 HELP feature has been expanded,  it can now identify most of the basic code fragments (operators, literals, keywords ), allowing you to press F1 and get a more in tuned response.

    ...



IDE Alpha V0.26b - Auto Parameter Prompting

    This dropped in pretty easily, even though this version has some  hard coded short cuts in it, but the concept works.   What's missing is the there's no real expression level parsing in this version, so it can't resolve the parent command if the expression has bracket layers and the cursor is beyond them.  Not a big deal, just couldn't be bothered spending time on that up front as i wanted to see how well it work, and it seems to work ok.

     What you'll notice now is the IDE doesn't need to be persuaded to show a built in command/function parameters, it'll do this automatically for you.  This is bound to be a bit of culture shock for some people,  but it'll make learning much easier for others.  Now you can just load up a source and click on any  command that has parameters and it'll show you right there and then, without needing to the hit a menu or any special key combo.  Which should make learning a lot easier.        

IDE Alpha V0.27a - Parameter Indexing in Parameter prompts

    Had a few days off the IDE to focus on other tidbits, some PB stuff some external stuff.  Obviously when working on PB stuff, I'm using the new IDE more and more.  While it might still be alpha,  but much of the big 'fall over' issues seems to have been tweaked up now, making writing code much easier.  Anyway i digress,  so during last update the auto parameter prompting was added.  The first addition sees the parser looking at first parent keyword in the expression and just assuming that's the command/function you within.   Which works, providing there's not a mix of function calls as parameters.    

    So this would work

   ShadeBox  0,0,800,600,c1,c2,c3,c4

    but this wouldn't

   ShadeBox  0,0,800,600,Rgb(255,0,0),c2, |c3,c4

    if you positioned the cursor in front of the C3 parameter (like above), the old routine would ID the RGB() function as parent function, when you're clearly editing the parameters of ShadeBox and not RGB.

   So what the IDE has to do is parse this expression looking for the real parent command/function and give the parameter Index back to the rendering engine, which is what today's edition is able to do.   What it can't do yet, is show this new information visually by highlighting the Parameter you're within.  But that's the plan.. Should be doable.



IDE Alpha V0.27c

     Alpha V0.27c rounds out the auto parameter tip feature with the inclusion of the parameter indexing within the expression.  Which just means that it can work out where you are within the command/functions parameters and show it to you. There's a bit of an issue with the tips clipping width from time to time, but that's cosmetic.    

     Most of the changes this time around have been fleshing out some of the existing functionality.  Stuff like the IDE now keeps track of the document changes so that CLOSE PROJECT can prompt upon closing.  If the document hasn't changed it shouldn't prompt you.  Dunno how reliable that actually is at this point though.   Apart from that, there's the usual round of bugs and tweaks.

     The main thing about this release though, would be the shift from one of caution, to something that's pretty stable.    In fact i'm yet to have any saving issues (code mangling) and very few crashes while editing.  That's not to suggest it's 100%, I highly doubt it, more that your less and less likely to hit issues now.
   


IDE V0.28b Moves Into Public Beta
   
     Revision 0.28b continues the clean up process with and bugs and tweaks, the main change is how rendering is handled.  In this version, redraw is handled separate from the action.   You can set the refresh rate through the SETTINGS dialog, using the Interval setting near the bottom.  The setting is the number of ticks between refresh pulses.  The redraw process doesn't have anything to do with the input process.  The default redraw setting is  about 40 ticks (from memory), which makes for a potential of (1000/40) =25 redraws per  second.   You can set it lower or higher.  The smaller the value the higher the number of potential redraws,  but it's limited at around 16 ticks (62 fps)  

     What this does is it decouples the rendering from the input process, so speed of the redraw doesn't get in the way of the things like dragging the viewport when scrolling and the user can't flood the redraw with requests.

     Anyway, this doesn't mean the end of the ALPHA testing, the process will be generally geared toward Alpha testing, with beta releases at key points.  



PlayBASIC IDE Beta V0.30a

     Revision V0.30a introduces Bookmarks, context based right click menus (Default/Selection and #include mode),  as well as some bugs and highlighting tweaks.


Right Click Menus

     This beta introduces a few changes, mostly around the right click pop up menu stuff, where previously it didn't matter what context the cursor was within, you'd always get the same pop up menu.   Now there's 3 basic contexts.   There's Selection menu, which are options to do with a selection chunk,  #include menu, which allows you to load an include into your project to view it and the default menu, which is just basic options.  

     Much of the work in this revision has been focus on the include file loading, which has required a bit of restructure in places to make the process sit nicely.   The process works much like PlayWrite i guess, you move your cursor over the file name in of the #include statement .. Ie   #Include "Maps"  you'd left click the maps literal, then right click to get context driven help.  This will pop up a list of available options, which in this version consists of one option, that being Load Include..  If you select the load option, the IDE will try to work out where this file is and load it into the project manager.  The source isn't considered part of your project though, so if you compile or save your project any manually opened  sources will be left out.    In future editions it'll allow you to modify and save the modified include as you save your project, or perhaps though a menu option.


Bookmarks

          This works much the same as PlayWRITE with one key difference.  While i'm trying to keep it fairly similar, i'm not a fan how book marks aren't project based.  So in this version you have the same 10 bookmarks, where each bookmark can be on any source at any row.  So if you goto a bookmark on a different source, it swaps to that window and scrolls to that position  This allows you to jump between key parts of the code while developing.  Adding the functionality was simple, the annoying bit is rendering this information back to the user.   In this version it just shows a crude text overlay on the line number.   It'd be nice to have some type of icon, but i can't be bothered looking for one at the moment.  


 
V0.30b - Find Declarations

     Start adding this yesterday, so far it's allows you to click on a user defined function/psub and it'll take you to the declaration.  The implementation is pretty simple at this point so it's only able to find local declarations, but the idea is that will be expanded to be project wide.




IDE Alpha V0.30c

     Alpha V0.30c -  This introduces the Find Declaration functionality to editing environment.  For those that aren't sure it's a right click menu option that will try and take you to the declaration of user defined variables/globals/locals/constants/arrays or functions within the project sources.    This version of the search operation is fairly basic, it can find most declarations such as 'Dim stuff as integer', but it has no really knowledge of scope, so it's likely to make mistakes if the same variables/arrays names appear in different scopes.    


  IDE Alpha V0.31c - Live Function Parsing

      So today it's looking likely we've got another brand new feature for the IDE which is Live User Defined Function parsing.   This is something I've been struggling with for a while now, the main concern has always been the exponential growth of complexity as the source gets bigger.  The deeper the view of the source, the more work required for the IDE keep up with what you're doing.  Ideally, it'd be best have keyword level identification of every token in the source, but that really doesn't seem viable.   So moving on from that, we end up with live parsing.    

      In this version you get a quick peek at the live parser implemented into source view.  What it allows the IDE to do, is build a list of user defined Function names within the source.  These are then used in the syntax highlighting.  They're currently coloured blue so you  can see whats the user function and whats the built in function.    

      Here we have a quick example of what i'm talking about.  

     

PlayBASIC IDE Beta V0.32b

    This revision rounds out Live User Function Parsing functionality to editing environment.    Live parse feature monitors each source for user function & psub declarations, keeping track of function keywords while you edit.   The Live parsing is interleaved through the IDE, so it's sharing resources where possible.    Changes to the function names won't be shown immediately though, they'll generally get refreshed every 1/4 -> 1/2 of a second.  The delay between refreshes will get longer the larger a source fragment is.   It's set up to handle sources of 5000 lines long in around a parsing time of 1 second delay.   Which seems fine to me.    The parsing is also project wide in this version as well as supporting linkdll blocks.  

     Auto Parameter Help On User Defined Functions

     So the live parsing means that user defined functions can be highlighted, so you can see instantly what's a built in function and what's user defined.  As much of  help that is, the obvious next step is to expand parameter assistance on user defined functions.  Which can now be found in this edition.  Which means that when you enter the parameter section of the user defined function, it'll give you the parameter hints live from the source while you edit it.      

     

IDE Alpha V0.32f - User Defined Type Field Assistance

 

IDE Alpha V0.33b - Auto Field Completion Support Expands

      So since meeting the first milestone over the weekend, i've been pressing on to expand it's view of the source, starting with supporting declarations within function/EndFunction statements and typed arrays.    The only tricky bit was working out a way to slot the EndFunction declarations into how it works.  Since the declaration matching requires a declaration prior to usage, which is not possible for returns (think about it), but there's a way around that.

      Anyway, in this vid we knock up a little program that demo's some of the IDE's latest additions.  

IDE Alpha V0.34d - Auto Completion / Data Type Suggestions

Work on the auto completion features keeps ticking away, here we're quickly looking at PlayBASIC IDE Alpha V0.34D. In this version, we've added the AS / NEW data type suggestions. So if you type AS followed by a SPACE it'll prompt you with a list of the available data types, ranging from the primitive types to user defined types. The IDE is scope aware for user defined types, so it'll give you those options available at this location within the source.