PwnIDE Blog 

PwnIDE is now named Inventor IDE and version Alpha 3 is now out after the most significant changes between releases yet.

This release is very buggy and hogs RAM to no end. However, the language data is complete, the parser is much more resilient and faster, and the design is better suited than ever for multi-language support when that comes about. Also, the UI no longer looks like dozens of lava lamps exploded on the screen. It’s moving toward looking somewhat professional.

The bugs are getting sorted out and the RAM use has already gone down a bit, but won’t be down to reasonable levels until Alpha 5 or later. Alpha 4 is also a big one, getting built-in assembling working, but probably with a much shorter timeline than Alpha 3. Big things are coming in near future versions.

Code Cortex now has a new website (which will be getting more content over the next month or so).  All future PwnIDE releases will happen there.

Also of note is that the Code Cortex Screensaver has now been released.  It’s fixed at 20 frames per second, and modern CPUs should easily be able to handle it (since an older CPU I was testing on was easily able to run it at more than 20 frames per second after I optimized it).  The source code for it is released as a sample project with PwnIDE, and on Google Code Hosting.  The video tutorial and the heavily debated speed comparison will be coming; I’ve just been side-tracked with a lot of other things.  I’ve implemented and compared versions in assembly, C/C++ (both VisualC++ and GCC), and Java.  The results are quite surprising, but you’ll have to wait a bit longer to see them in the videos.

I recently released what I’m calling PwnIDE 0.2.2b, with many bugs fixed from version 0.2.2.  The reason that it’s not 0.2.3 is that I’ve got 2 particular requirements for 0.2.3, namely proper support for external libraries (e.g. the Windows API) and a new language data format (which shouldn’t change any functionality until 0.2.4).

To support external libraries by parsing include files for those libraries, there also needs to be support for code elements without doc comments.  To support code elements without doc comments, all datatypes need to be identified before variables can be identified properly.  That means the code parser needs to change significantly from it’s current single-pass approach to a multi-pass approach.  Ironically, this should make initially parsing the code significantly faster, solving the long load time problem.  (The reason for that has to do with the observer pattern notifying everything whenever anything is parsed in the single-pass approach.)  This also gives me an excuse to organize the language handling code much better than the current all-in-one-file approach (see MASM.java).  Overall, things should be much better… after a lot of work.

Over the past 4 to 5 months, I have had an HP (Hewlett-Packard) laptop.  It worked fairly normally for a couple of weeks.

Then, the wireless card started not working some of the time.  Then within a few days, it rarely if ever worked.  Many people on the HP support forums seemed to have the same problem.  Apparently there was a problem with the laptop motherboards in the summer, because of which major devices (e.g. the screen) would just fail.  HP then fixed the motherboards… for all devices except the wireless card.

So, I got a USB wireless adapter.  It wasn’t perfect, and didn’t get the greatest reception, but it sufficed until two days ago.  Just two days ago, my laptop wouldn’t boot.  I don’t mean that it got to the Windows loading screen and told me there was a problem.  I don’t mean that it got the the BIOS loading screen and told me that it couldn’t find the OS.  I mean that the screen stays off, not even on and black, but completely off.  The lights on the keyboard light up, the DVD drive does its power on self test, and then after about 20 seconds, it resets and does the same thing again.  Then yesterday, it would stay on for about 1 second.  Today, it won’t turn on at all.

A friend of mine had the same issue with his laptop not booting, but with a brand new HP laptop.  He sent in his laptop to get fixed, and they told him that nothing was wrong with it, then sent it to the wrong person.  In all, it took over a month to get his laptop back, and when he finally got it back, although it would boot, HP had installed Vista, and didn’t give him the registration key for it.

Now I’m going to have to send mine away to get fixed, and so I may lose much of my work on the screen saver.  I got the neurons with a pulsating glow.  Hopefully I can recreate that once I get my laptop back.

The Code Cortex screen saver is coming along better than expected, and if all goes as planned, it should be ready in time for January.  It currently renders 87,000 semi-transparent spheres in the form of the Code Cortex cube of neurons comfortably at 20 frames/second (more than a screen saver really needs) and the rendering is done completely on the CPU.  It needs a processor that supports SSE3, and I’m running it on one of the two cores of my 1.6GHz CPU (I could have it use multiple threads, but it doesn’t need it right now).

It looks mildly cool right now, but hopefully it will look phenomenal and tax the CPU to the max (possibly both cores) once it’s done, and then the comparison with the C and C++ versions will be well worth while.

After a few all-nighters and a bit of banging my head against the wall, PwnIDE Alpha has finally been released.  It’s taken a lot of time and a lot of work, but the results are worth it.

I will be creating a small part of a larger set of video tutorials for PwnIDE over the next few weeks.  Stay tuned; they will make clear the useful features of PwnIDE and how best to use them.  Plus you’ll get a cool screensaver out of it.
There are many parts of it that still do not work for the simple reason that they haven’t been written yet, so I won’t yet accept bug reports.  However, I will accept feature requests, with the disclaimer that I have thought through a very large portion of what will be in PwnIDE Beta and even 1.0, and many things are not as they will be.  I’ve also released a draft paper on the motivations, design, status, and future plans for PwnIDE.  It’s not a full design document, but does give some insight into its operation.

This is a big milestone in a very long road for Code Cortex.  I’m looking forward to the next big steps.  They’ll be pretty awesome if they work out.

Deletion of things like functions now works in version 0.1.15, which you can get on the downloads page. 

Due to priorities from the course I’m using as an excuse to work on PwnIDE, I must drop the “Find Usages” feature from the initial alpha release, and I’m leaving “Go To Definition” as it is (only supporting symbols with headers), so that leaves just shift up/down of headers, and copy/paste of headers before alpha.  For the course, I’ll also need to put in a menu option to run NaturalDocs, and SVN update/commit, but I might not release those features until they’re less buggy and more useful.

Also, the draft paper is ready, but it won’t get reviewed until November 28th, and I’d like a bit of review by others before I post it.

So after much painful trial-and-error combined with months of Google-searching in an attempt to handle certain KeyEvents in a “global” way, I’ve FINALLY found a way to do it.  This sort of handling is needed in Java in order for operations like undo, redo, and save to work regardless of what component has keyboard focus.  As painful as it was to find the solution to this, the solution itself is remarkably simple:

KeyboardFocusManager focusManager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
focusManager.addKeyEventDispatcher(new KeyEventDispatcher(){
	public boolean dispatchKeyEvent(KeyEvent e) {
		return handleCommonShortcuts(e);
	}
});

handleCommonShortcuts(e) is a function I wrote to check if the KeyEvent is for something like undo, redo, or save, and if so, do it and return true, else return false.  I wish that this had been a bit easier to find, but I’m glad that it works now, and without having to add a KeyListener to every single one of the 100’s of components that might be present in an PwnIDE window at any given time. 

Now I can get back to implementing the remaining header operations before alpha, since they are dependent on such a handler.

In other news, I’ve written the draft copy of a paper on PwnIDE alpha, and after it is reviewed by fellow students, I will post a copy of the final version.

PwnIDE is still not alpha and it’s past the end of October! Don’t fret, though, it’s coming. I have a draft paper due about it on November 7th, so I must focus on the paper for the next few days, but the most important remaining features before alpha shouldn’t be too hard. Those features are (in order of importance):

1. Delete headers (e.g. functions, structures, variables, etc.)
2. Move headers up/down
3. Copy/paste headers
4. Find usages (I may put this off)
5. Go-to-definition (partly done now, so I may put off the full implementation of it)

The first 3 are fairly similar, so only doing one of them should be difficult, and hopefully not too difficult if I’ve designed things well enough. With the automatic UI updating and scope updating, (go observer pattern!), removing a header should be as simple as “aFunction.getParent().getContent().remove(aFunction)”, but I have to sort out some issues with Swing’s KeyListener first.

As always, the current latest version (0.1.13) is on the downloads page.

Context-sensitive auto-complete now works for some contexts.  Contexts that it doesn’t handle yet will just give you an apology message, since I’m leaving it at that for the Alpha.  It’s also not as flashy as I’m hoping to have it for the Beta, but it’s plenty sufficient for the Alpha.

I’m going to have to take a small break from PwnIDE to work on PwnOS if I’m planning to use PwnOS for my Operating Systems class project, ’cause PwnOS needs a lot more work to get anything up and running.  However, the first draft of the paper on PwnIDE is due at the end of October, so it’ll still be in my mind.  The remaining functionality for PwnIDE Alpha is mostly fixing loose ends, whereas the remaining functionality for PwnOS is a lot.  I’ll make it all work somehow.

Most of the error detection now works!  This means that built-in assembling should be relatively easy, but that feature is being left for the beta version or later, since it’s not as essential.  Error fixing and other suggestions by the editor are also for later, but error detection is pretty handy on its own.

I’m also currently taking a course for which I’ve chosen my project to be getting PwnIDE to alpha so that I have a solid deadline on it.  The only really fancy feature to get done before alpha is context-sensitive autocomplete.  Everything else is stuff that I’ve roughly figured out how to do, including several loose ends of features that I’ve counted as complete.  For the course, however, one requirement is that I use 3 open source libraries, which pretty much forces me to get some SVN support working.  SVN support won’t be in the alpha though, since it could be very difficult.

Stay tuned also for http://www.codecortex.com/.  As PwnIDE expands into a multi-person project, some operations will be done under the name Code Cortex.  Related future projects will also be done under that name.