📅 News and updates: December 7, 2015 – August 11, 2016

[Reinmar]

(Ported from https://github.com/ckeditor/ckeditor5/wiki/News-and-Updates)

August 11, 2016

CKEditor 5 v0.2.0 was released. This is the second developer preview of the new CKEditor 5. This iteration included over 170 tickets closed and was focused mainly on some architecture changes and project cleanup.

Read more in the CKEditor 5 v0.2.0 release blog post.

Check the basic CKEditor 5 sample on the GitHub.io page.

July 14, 2016

CKEditor 5 v0.1.0 was officially released. This is the first developer preview of the new CKEditor 5, and the first demo-able version.

Read more in the CKEditor 5 v0.1.0 release blog post.

Check the basic CKEditor 5 sample on the GitHub.io page.

July 8, 2016

During the last two weeks we've closed all remaining tickets in 0.1.0 and we're preparing for the first release:

On the final straight we've worked on most important stability issues, some API improvements and a couple new features:

• In the engine:
  • A new version of history and undo has landed (with a series of related issues – 1, 2, 3, 4, 5, 6 and 7). Yep, it was a big refactoring, which resulted in a first stable undo/redo feature.
  • TreeWalker for the view has been introduced.
  • Selection has been split into Selection and LiveSelection what allowed to fix delete's feature integration with undo.
• In the UI library:
  • A new utility to extend templates was implemented. We also took a chance to improve the code by decoupling the View and Template classes.
  • The existing UI components were refactored to apply the MVVM pattern more consistently. This allowed to close a few more issues at once.
• In the core:
  • We created a first bundler for CKEditor. It integrates Rollup.js – an ES6 modules bundler that produces highly optimal results. Integration with other bundlers, such as Webpack will be created later.
  • We created a tool to execute certain tasks on all CKEditor repositories. This will help significantly with repetitive tasks such as releasing, updating repeated files (e.g. code style fixes).

Since 0.1.0 is coming to an end, we also worked on defining the next iterations. You can read more about the proposed release model.

June 22, 2016

During the last month we focused on bringing the first real editor instance to life. We made a lot of refactoring and significant architecture changes on our way there, since we are constantly focused on keeping the technical debt at the lowest possible level.

The effort paid off and we were able to present a working CKEditor 5 to the entire CKSource team on the 10 year anniversary meetup held in Warsaw.

Here is the project status up to date:

• A functional and complete core, engine and UI.
• First editor implementation – the classic editor.
• Following features are available: typing, delete, enter, paragraph, bold and italic, headings and undo.
• First theme – lark.
• The project has 100% code coverage, complete API docs and a set of development tools.

We also defined the first milestone – 0.1.0, the first demo-able version. Having all the code finished, we are now focusing on closing the most important issues (mostly bugs). We hope to finish this in about two weeks.

CKEditor 5 Hackathon

In the meantime, we also held the first (internal) CKEditor 5 hackathon – a 2-day event during which we wanted to test the capabilities of the new engine. The results were amazing – we have been able to code proof-of-concepts of features like selective undo, editable table of contents (different view into the same model), Markdown editor, or suggestion mode.

More details, demos and source code on CKEditor 5 hackathon repository on GitHub.

May 16, 2016

For the last two weeks part of the team was involved in maintenance tasks, while the other part was working hard on closing the selection rendering and conversion. However, we are a few steps closer to the first milestone:

• Converter builders were introduced. They implement a high-level API for created converters between the model and the view.
• Utils for testing the editing view were implemented. This allowed us to simplify many existing tests and speed up testing the view.
• Two issues required by the typing feature were closed – the diffToChanges() function and change buffer.
• Simple DOM utils were implemented.
• We have split the utils.js file into many small modules.

Other than that we are close to finishing a couple of other tasks:

• The first creator is nearly on review.
• Undo manager is on review and a part of it was already merged.
• CKEditor 5 builder has been modified in a way that will enable CKEditor 5 to become other project's dependency. Previously CKEditor 5 could only be built in standalone mode.

April 26, 2016

Last week we have witnessed a big moment for the CKEditor 5 team - we have integrated together multiple pieces of the engine and everything worked just fine!

We have been working on different parts of the engine for more than a year and a half, but we have never seen them working together in a real environment. Of course, the code has been thoroughly tested, but we still could not be sure that we have predicted everything.

What precisely worked? The entire editing engine (except selection handling which is not ready yet). Data inserted to the model through OT-ready operations were converted to a virtual DOM representation and then rendered to the DOM. Afterwards, editing events (such as typing, deletion, etc.) which happened on the DOM were properly handled, controllers modified the model and all these changes were once again rendered (on request).

Visually the outcome looks like a very basic text editor, nevertheless we were really thrilled! :)

We have also implemented a theme and icon builder. Part of the engine landed on master and we began working on utilities for generating converters (the existing API is very low-level). We finished first versions of Delete and Enter support and started working on typing. We have also progressed on the selection handling and hope to see it ready in two weeks. Selection covers more than half of issues left in the 0.1.0 milestone in the engine, so we may be able to create a developer demo soon!

March 30, 2016

Last few weeks were very productive for the CKEditor 5 team:

• We decided to split CKEditor core into UI and Engine, since these two parts work interdependently of one another. We also extracted common utilities to a separate repository and moved core classes which implement the base architecture to the main CKEditor 5 repository.
• Besides splitting, we also started to glue relevant parts together to create an editor with all necessary pieces. From the very beginning CKEditor 5 will be able to transform not only one, but multiple editable areas into a single editor.
• Thanks to having it all glued together, we were able to check what we have been missing in order to run the first sample. The most important parts missing are the selection handling and conversion (from the model to the view and from the view to the model). We have spent the last few weeks prototyping converters to solve various cases and obtained code which is as simple as possible, yet flexible enough to solve all problems. Now we just need to polish it. This week we have also started working on the selection.
• At the same time the first CKEditor 5 theme has been introduced as a result of the public discussion. Say hello to Lark!

March 1, 2016

We're continuing our work on the topics that we've started two weeks ago.

• The features concept has been moved forward. Commands are defined, a first implementation of the schema was proposed and we got some first, very basic UI components.
• The converters (from tree model to tree view and back) are the biggest and most demanding mechanisms that we currently work on. Their flexibility (or lack thereof) will strongly affect the degree of data model detachment from the "view".
• We also worked on allowing running the editor's test suite natively (without PhantomJS) in Node.js. Running a headless editor in Node.js will allow creating server-side solutions using the same API which is crucial for collaborative editing and similar features.

If you haven't yet joined the discussions around UX, UI and themes feel free to do so! We'll be grateful for your feedback.

February 16, 2016

Two weeks ago we closed the Tree View implementation (which is the lower part of the diagram below) along with the Tree Data model and Batches.

We also finished working on other pieces of the puzzle, namely the Position Mapper and some basic data processors. We started working on the Converters and prototyping first features, which also triggered discussions about commands and schema. This means that in a couple of weeks the puzzle will be complete and first features will start to appear.

However, for the features to be usable we also need the UI. Therefore, we started working on the first creators and editables, the toolbar and the UI library in general. We also made some improvements to the MVC framework along the road.

Other than that, we finished updating the design wiki (see e.g. the rewritten Modularity and Plugins pages and the new Packages page) and made some effort to make the code compatible with Node.js environment.

We are openly discussing our design choices and we invite you to contribute! Many topics were already linked in this post and the two missing ones are the API for processing pipelines and the state of inline style commands in the Editor Recommendations project. If you want to find out more about the Editor Recommendations project, which aims at standardizing features available across rich text editors, make sure that you read the latest article on our Medium publication.

February 1, 2016

During the last two weeks we have been able to close two major tasks and couple of less significant ones. First of all, the Tree View landed on master branch closing the lower part of this lovely diagram.

We have also finished porting all our code to ES6 modules, which allowed us to clear the code base and to move to more productive tasks.

Other than that:

• We started discussing UX related aspects. Feel free to contribute.
• We begun updating the documentation (e.g. CKEditor 5 Development Workflow, CKEditor 5 Architecture Overview). Recent refactoring effort brought us some important changes, so we want to make sure that the documentation is updated as soon as possible.

January 18, 2016

We have been working on architecture documentation regarding the data model and the UI library. We plan to publish two articles on GitHub regarding these significant topics as soon as possible.

We were able to close a big part of a major refactoring task, which is porting the code to ES6 modules. That required significant architectural changes, but allowed us to clean up the code. The work will be continued though, because during the course of action we understood that we must introduce ES6 modules also in the tests (so far we have used them in the code). Additionally, we need to check the distribution scenarios to make sure that the library will be usable in all environments.

In the meantime, we continue to work on the rendering pipeline for the data model. This is the last huge task required to build a real editor. However, it is really big and really tricky, so it is hard to estimate how much time will be needed to close this topic.

Other than that, we are working on a couple of other small tasks including bug fixes, tests and code refactoring, as well as some improvements to the already existing code.

December 7, 2015

During the last two weeks we were able to close most of the topics which we have mentioned in the previous biweekly.

We have finished working on the MVC architecture and part of it (module bindings) is already available in the master branch. The other part awaits the second review. We are now working on mockups of the new UI as well as the infrastructure, in which we need to implement a selection system. Our transformations and deltas API passed the review, so we are now into tree data model's change event.

We are also working on CKEditor 5 Dev Tools, which will become a big step forward in the way we will maintain and develop CKEditor 5 in the future.

November 23, 2015

We are currently battling on two major fronts - the basic application infrastructure and the data model.

The Infrastructure

• After a lot of discussions we have rewritten the Collection class.
• We have been working on a prototype of our MVC infrastructure. The outcome happened to be very fruitful and we finally came to a design we are now implementing. We also designed a nice syntax for binding models (it has already been implemented).
• We converted our existing code in such a way that we use even more ES6 features. This work continues as we are finishing research on how to use ES6 modules to enable a few things i.e. the ability to build a distribution for Node.JS. We also realized that this is the last moment when we can do bigger infrastructure changes, so we have redesigned our approach to plugins basing it on our past experience. We are happy with the outcome and we will be concluding the research and implementation this week.
• We are working on development tools for CKEditor 5 which will ease managing all the existing repositories and scaffolding the new ones. We hope that this will speed up our daily work.

The Data Model

• Our Tree Data Model was reviewed and merged into the master branch.
• The transformations and deltas API is currently on review. We are working on converting the Tree Model to DOM and back which is the last piece of the puzzle.
• We have worked on implementing and then porting code and tests for Operational Transformations to our Tree Model - the outcome was merged into the master branch.
• At the same time we worked on extending ChangeOperation (so it is able to work with ranges spanning over multiple levels of a tree).

We are very close to finalizing all the fragments necessary to start coding something substantial like the first real features and UI. Keep your fingers crossed!