Luckily, Martin is a big fan of Twitter, so everytime he completes some task for the release, he tweets about it. So to get the latest and instant status updates feel free to follow the Intype tweets.

By the way, there are some cool screenshots from this morning on our Twitter, so go ahead and check them out. I really love it and can’t wait for the release. Can you? :)

So what’s new with the web? Well, almost everything. The website will get a brand new, fresh redesign, a new structure as well as a complete new backend system, written from scratch in Ruby on Rails.

New structure

The structure of the website will change a bit, to better fit the need for information for a new user, as well as for the daily user of Intype:

• Homepage - a compilation of all the important stuff going on
• Blog
• Screencasts - after the 0.3.5 release there will be more and more of the magic moving pictures of Intype features
• Releases - perhaps the most important section. This will be the place for all stable and unstable releases and their release notes.
• Manual - here you will find a complete documentation of Intype and its features. This is where you send your friends asking about how things work in Intype and say “RTFM” :)
• Community - a light alternative to current Intype forums. This is the area where the community will meet, share ideas, feature requests or report bugs
• About - the team, history, the filosophy of Intype and stuff like that

New looks

A few pictures are more than a thousand words, so here’s how the whole thing will look like.

Note that these images are not tuned to perfection yet (text constrast, font sizes, etc.) and are being constantly improved in monthly iterations as the site is being build up (I hate Martin for this).

Homepage

Blog

Manual

• Built-in bundles vs. user bundles
• Bundle editor
• Grammars and injections
• Parser

Built-in bundles vs. user bundles

As you may know, Intype has two bundle repositories: built-in one stored in /bundles and user one stored in /user/bundles. Built-in bundles are those you will get with the installation. Every installation package is overwriting the built-in repository so you’ll loose any changes if you won’t back it up before re/installing. The same will happen when bundle updater is implemented once our new site gains the feature. To protect your changes, Intype is also looking into user bundles repository. There is a simple rule that items in user repository have greater priority than in built-in one.

This results that you can override any built-in bundle or item without touching them. And this is where the changes were done. Previously, we have used path comparing to know which item is overriding which, but this was OK for times without fully functional bundle editor. Now every item is obliged to have it’s unique ID number. If there are two items with same ID: one in built-in folder, and one in user folder, then the user one wins and is installed. However, thanks to the bundle editor, you won’t have to care.

Bundle editor

As the new override rules were implemented, we started working on the bundle editor. The main advantage of the bundle editor now is that it’s using Intype’s native editing component not only allows syntax highlighting, but also using all the navigation commands, and snippets as well (yes you can use snippets when editing snippet or anything else in bundle editor).

Next important thing is that the bundle editor also allows editing of the source files of the items, which might be handy when there are errors on Jasmine level, or when the developers will decide that they’ll do fancy editors for the next release.

Grammars and injections

Fixing stuff and updating grammars was next big step. Due to caching, we’re going to introduce to speed up the loading process, we had to split the grammar compiler to smaller steps to be able to recompile grammars from a binary file (the cache). We’ve also changed how grammars are now handled to support our perhaps biggest feature for parsing: injections.

Until now, if you wanted to create for example HTML grammar that supports eRuby (Rails views templating), you had to go to HTML grammar and change it to allow transitions to Ruby. Injections allows you to create a grammar that has HTML in it’s base, but injects transitions (<% ... %>) to Ruby code. All without touching either HTML or Ruby grammar. We will describe the details in the documentation we’re also working on at the new site.

Although this feature will be experimental for few weeks, we have more plans with it. One of those is to enable injections of keywords. For example, if you’d like to have highlighted methods from Prototype JavaScript library, you don’t have to change the core JavaScript grammar, but create a new grammar, include the JavaScript and then just type keywords to be injected. The same goes for injecting JS with jQuery, Ruby with Rails, PHP with CakePHP, and even XML with XHTML.

Parser

Actually the feature we’re celebrating now the most, is that we finally have new and beautiful parser management. This piece is intended to manage parsing threads with pretty smart prioritization and smart reparsing policy. Among this, Intype gained readiness for your multi-core processors as well as possibility to use all the cool features in the dialogs like search dialog (highlighting in regular expressions and format strings) and bundle editor (highlighting of Jasmine source and snippets).

Our pipeline

As we’re getting close to the release, we have also gave the higher priority to documentation and new site projects, that are required to be launched (at least) with beta (0.5). We’re all kept busy with finalizing and polishing the stuff as the internal testing phase should start in couple of weeks. Next week, Ivan will tell you more about what the new site project is being about and reveal the new design. So here’s the short list of tasks in our pipeline:

• Martin: Finalize bundles management, finalize project files management, recover the search features, help with new site, work on documentation in parallel
• Juraj: Finalize the parser management, implement file change watcher, get back to JavaScript support (for next release)
• Ivan: New site

• Status bar is combining the status area (caret position and current status of application) and a toolbar band. Yes there’s an all-mighty rebar, but its default visual appearance on Vista does not differ between static text and buttons.
• Sidebar has never been defined as a standard component, except for a docked tool window which is simply ugly.
• Tabs require better visual feedback on drag & drop; custom stuff such as Open last session or an icon for opening a new file.

It might seem simple if you consider Intype in a context of one version of Windows and a single pre-defined theme, but many users have their own favourite Windows version and their own favourite themes installed and that’s where a poor developer is going cuckoo.

So we stopped fighting and hacking the Windows themes, got rid of what we subjectively consider ugly and made it our way. We made a lot of work to deal with various colour schemes your theme might use. We simplified all the controls on the main window by using just a single UI pattern for the tab, status bar button and the sidebar window header.

OK, enough words, take a peek at following screenshot and let us know what do you think.

This new feature provides the ability to:

• Open a new file by dragging some text in Intype and dropping it on the tab-bar.
• Open a new file by dragging some text from any other application and dropping it on the Intypes tab-bar.
• Drag and drop selected text from Intype to any other application.

The ability to drag and drop a selection within a document itself is not implemented yet, but is planned for the upcoming release. You can take a look at how it works in a short screencast:

• Text Drag and Drop

We also plan to submit more screencasts as the features get stable. So stay tuned and see you in a week.

Paired characters is a feature that completes right character if you type left one. For example if you type left bracket, it will add right one. Feature also supports smart overtyping, that will just skip the right character if you entered it yourself. Thanks to the bundle management, you are of course able to configure them yourself within the bundle editor. Configuration is scope-based, so you can allow angle brackets in HTML, but not in PHP, etc. And of course, if you select something and hit the left bracket, the selection will be wrapped with the pair.

Tab triggering scheme has been updated to better cover various lengths of triggers. We also plan to add an optional word-boundary checks that will allow you to limit the tab trigger just for a complete word.

Another update has been done for the conflict selector. The conflict selector is shown when you hit a shortcut (or tab trigger) that is mapped to multiple commands (for example a doctype tab trigger in HTML). Old one has been using the standard menu component, where the new one will use a filtered list and will show the default shortcuts, the tab triggers, as well as where does the command come from.

As we plan to move to beta shortly after 0.3.5, we have also finished our licensing library, which will be tested until we reach the final stage. The beta license will be available for everyone and for testing purposes will be valid for 3 months (not a final word), after which you will get a new one.

Now we are working on attaching the undo, and some of editing quirks to have available most of what we need to test.

Spans allows us to split the document into an virtual fully automated tree. The feature allows us to unify all the required automation we’ve all wanted in a layered manner. With current model of stacked behaviors we were not able to layer the automation effectively (i.e. having paired character automation within a snippet).

This new functionality also affects the undo/redo which is now able to contain the information about serialization and restore it. So you can return back to snippets edited in past through undo.

The advanced highlighting system allows us to also highlight active spans within current context which enormously affects overal usability of the automation. This video shows multiple snippets within multi-insertion using spans.

New in the current development. We’re finally finishing last tasks for the first internal testing launch of 0.3.5. As whole UI backend has been replaced with our UI framework, we expect a little longer testing phase.

Why so slow?

Intype is being developed during the nights and mornings because of our daily jobs. This lack and irregularity of the time is taking its price, we all as users are paying. Our reason for need of daily jobs is to have income from different source, so we can keep Intype free of charge during its development process. Many users are comparing Intype’s development cycle to other products being on some regular basis. But we simply cannot compete on this level, therefore we have to find other areas where we can prove to have better product.

Areas where we can be better are for us stability, memory efficiency, consistency and user interface which need a lot of time to be designed, thought through, tested and implemented. But the result is being constantly praised along the users community. That’s what is keeping us going, even if such development is taking too much energy and health price. Actually surgery I’ve underwent four weeks ago is one of those. But don’t worry, I’m much better, because of opportunity to do what I enjoy the most: Intype.

These reasons of course disables us to give estimations, because we can almost never predict what will happen and what effect it will have on overall productivity. Sometimes it’s better idea to solve multiple problems, sometimes it’s boost in daily job, sometimes it’s other stuff. However, we constantly move forward to our primary target: to deliver 1.0 as soon as possible to be possibly able to cut off our daily jobs and spent all our time on working on most advanced features planned up to 1.9.

Releases

Currently, releases are split to two groups: stable and unstable. We decided to use these names due to their standards, but internally these groups refer to how features are completed. Actually the most recent release is much stable, consistent and feature rich than the most recent stable release. Though, some new features are unfinished. We actually are about to switch to new scheme:

• Stable: Release with finished and consistent features; run through internal and community testing.
• Cutting-Edge: Releases hot from our kitchen mostly unstable (in terms of actual stability), unfinished features and tested only internally.

Currently there are cutting-edge releases available just for few of our loyal friends, being released sometimes more than on a weekly basis. Those releases are sometimes almost not functional, giving only few areas to be tested (recently Yarden helped us to find bugs in the Hebrew text using the cutting-edge release built only for him)

The new scheme will help us spread the releases in much better way hopefully resulting in effect of more regular releases for early adopters and impatient.

Delopment Notes

However, everything has its “however”. There are times when we take a risk and leave our daily jobs for month or two to be able to boost the development of most hard parts. One of such “times” is currently pending; we both (developers) are currently taking a risk and going on full-steam. There are three team-wide priorities:

• To provide Ivan and Thomas Bell with relatively stable release to prepare the screencast focusing on working with text, files, and drag & drop features.
• To finish CP1 in relatively record time. (I’m not telling when; see above)
• To redesign and rebuild the website.

But now seriously. After a very long time (oh my, is it a year already?) our blog is back online. So what’s new with Intype? The long awaiting release of Intype 0.3.5 (codename Newcastle) is still cooking, and it will take some more time for Martin and Juraj to put all the rest of the ingredients and spices in the pot and serve the meal. In the mean time, for those who do not follow our forums, I will try to summarize the work the guys have done so far on 0.3.5 and some stuff that is planned to be included in the final release.

Search updates

Due to many updates in the core, we’ve also focused on updating the Search functionality:

• Quick find — Firefox-like Find strip will replace standard Find dialog. The Replace function will still use the current dialog.
• Advanced regular expression editor — Thanks to updates in UI framework and many updates made for scripting, we are now able to use Intype’s own editing component (Janed) with all it’s features in dialogs. A standard search dialog will use Janed for editing. In case you use either regular expressions or escapes mode, you will see the syntax highlighting with possibility to use embedded JavaScript commands, or snippets; or even add your own.
• Search targets — In addition to two classic search targets: document and selections, the new search will support also searching in Project files (or any arbitrary folder).

UI framework

Major amount of Newcastle’s development time of has been spent on the new widget/UI framework and related updates. In the older releases we were using third-party SmartWin framework which caused many troubles with stability and extensibility issues. Our new framework called AFW has been created to support our ideas and dreams of UI for the editor.

• Improved stability and responses — AFW gave Intype new level of stability and speed that we were not able to achieve with the previous framework.
• JavaScript ready — Since AFW has been built on our future requirements, we’ve also implemented ability to use it with JavaScript. API for creating your own UI’s or interacting with existing Intype UI is being planned for future releases.
• Multi-platform ready — AFW is an abstraction layer that has been used for creating it’s Windows implementation. Any other future platform implementations will not require any deep changes in the core.
• Windows XP/Vista themes support — AFW also has an abstraction for renderers that can vary between various versions of Windows. Currently we have support for XP and Vista theme renderers. Thsese renderers will be made optional (so you can still enjoy the original UI look & feel)

Bundle Editor

The current implementation of the Bundle editor is vague and does not come close to reflecting the future. One important reason for creating our own UI framework wes the new Bundle editor that is going to be introduced with Newcastle.

• Snippet and grammar editors with syntax-highlighting — The Bundle editor will now have our own editing component that will enable many helper commands and snippets to be used when creating your own bundles.
• Logging errors and error-safe UI — Since the Bundle editor is essential, there’s is also a large amount of requirements to be implemented: error-safe UI and debugging tools.
• Default editor for any type of bundle item — In case of really nasty error in a bundle item, the new Bundle editor will give you possibility to directly edit the the item’s Jasmine source file.

Drag & drop

Drag & Drop has been discussed and request a lot of times at the forums. Since, we were able to embed this functionality directly into the UI framework, we now have a whole bunch of new dragging features.

• Dragging the tabs
• Dropping files from other applications
• Dragging files between project pane and tabs
• Dragging files into the editor
• Dragging selected text to tabs and project pane

Paired Characters

A new advanced editing behavior is pending for the Newcastle release: the paired characters. Along with scope-based configuration, we will also implement:

• Paired characters autocompletition — Automatically inserts the right paired charcter when you insert the left one. Backspace (backward delete) then removes both characters, Delete (forward delete) removes the right one.
• Wrapping in paired characters — Enables you to wrap each selection range into the paired characters.
• Paired characters highlighting — Placing cursor near the paired character will highlight the other one.

Editing

Along with other updates, the editing features are being updated. We are currently working on a development preview screencast to show you how these works. Until then, you can take a peek at what’s cooking:

• Virtual caret — Enables you to place the caret at any visible position in the document.
• Improved rectangle selections — Thanks to virtual caret feature, we were able to change the behavior of rectangle selections, which now can be respectively dragged from any visible position in the document. There is also a possiblity to create multiple rectangles.
• Backward rectangle selections — Most simply explained: creating a rectangle selection aligned to line end. The screencast should do the rest.
• Indent guides rendering — the new renderer is now rendering indentation guides — vertical lines to give an overview of how the code is structured.
• Different theme for different grammars — Successful Appearance preferences has been made even more useful. You are now able to specify a theme for each type of document.
• Unicode RTL rendering upgrades — Intype has always been built as a Unicode-ready editor. Thanks to the AFW, we are now able to deliver better caret navigation and rendering for the RTL and LTR/RTL mixed text.
• Unicode font fallback — even if you are using English, there is always need to have at least one more backup font to render characters that are not available in your main font. Typically the ToDo bundle suffers from not being able to display those pretty symbols for completed and incompleted tasks. This also provides a huge advantage for people from the Eastern locales. They are now able to use standard Courier for code and their local font for special characters.

JavaScript

• SpiderMonkey JavaScript engine — I’m not sure if this has been stressed enough: we are going to use Firefox SpiderMonkey JavaScript engine to deliver the high level JavaScript functionality.
• Backend scripting support for editing (MVC style) — Of course, for scripting, you’ll need to be able to access all the functionality available to internal commands. It took us a while, but the editing infrastructure has been made to give you MVC-like API for working with documents and editors.
• There’s a lot of support and backend APIs planned for each essential part of the Intype, most of them are going to be implemented until 0.4, so we can enter beta 0.5 with fully featured scripting.

Files

• Improved working with Recent files and Session — There has been a lot complaints about the current inability to customize session and the “reopening” of recent files. In Newcastle, you will be able to set this up.
• Project manager file operations — Everyone (including me) is waiting for ability to work with files in the project manager. Creating new files, copying, pasting, deleting and much more is being built into the Newcastle.

Release planning

As have written on the forums, our releases have been now planned up to version 1.5. Here is the list of all major releases until 1.0 with their focus and codename:

For the alpha stage, there are two releases planned:

• Alpha 0.3.5 (Newcastle) — focused on the new UI framework and preparing for scripting. It will be split into three phases where first two will be called Community previews (CP1 and CP2) and will be available for download only at forums. The third one will be final and stable
• Alpha 0.4 (Brighton) — Finalizing the basic JavaScript APIs • Theme editor.

For the beta stage, there are two releases planned:

• Beta 0.5 (Blackpool) — Focused on updating working with files (like loading from FTP on the background) • CURL API’s to work with remote files • Searching in files • Auto-update functionality.
• Beta 0.6 (Sheffield) — Search and project JavaScript APIs • File templates • Help system for bundles.

For the final stage there are two releases planned:

• RC 0.9 (Merthyr) — Project scaffold templates • Code folding • UI JavaScript API
• Final 1.0 (Swansea) — Final release

I understand that some of the major features are cryptic now, but we’re going to bring some light in future posts.

Beside the main development, we are now working on:

• development preview screencast to show you what has been done on Newcastle
• preparing posts with insider info on the features being cooked for Newcastle
• preparing a preview of our new website

So stay tuned, folks.