This revision introduced 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.
PlayBasic IDE V0.32f - Field Assistance
So today we're looking at the IDE's latest auto completion feature, that being to assist the user with User defined type fields. What this means is the IDE can now prompt you of the available fields within a User defined type upon hitting the "." character. This version is pretty limited though, as here I'm just trying to pull all the threads together in order to get the frame work up and running, even if it's only localized. You see, in this version parser can only see types/declarations on the same source file and it can't resolve the scope.
One tricky thing about this is making sure the IDE doesn't allow the user to write code that doesn't make sense, so currently the IDE uses the same rules as the compiler, that being the your TYPE must be declared, before you create a variable from it, a variable is dimensioned before it's used.
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 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.
This is round up some of keys development points of the ongoing IDE replacement project. You can participate in this discussion via becoming a member on our forums.
Round up from ALPHA 0.20 to 0.28b
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
PlayBasic IDE Alternative V0.22d - All The Shiny Things
The F1 HELP feature was expanded during this revision, 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.
Project Status: This edition is considered tentatively stable. You're still advised to use caution (Ie. back up your source codes first) when using it with your projects.
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.
The beta is available on the UW maintenance board.
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
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.
