Author Archives: Klaim

Developers: Migration to Git and GitHub.com

This is a development-specific announce.

As part of the effort to help volunteer participate to this project, I just finished the migration of all our development resources to Git and GitHub.com

aos_github

You can now reach it using this the default development address: http://dev.artofsequence.org
Or you can get directly to the GitHub account for Art Of Sequence projects: http://github.com/artofsequence

The following is some details about what changed.

Continue reading

Focus in 2013 (part 3): Company Support

In the initial article of this series, I reported that I am working on living from my productions which mean I will officially create a company at some point:

Since mid-July 2012 I have been working full-time both on AOS (which resulted in AOSWP 0.1 release) and a video game (which I restarted using previous code I wrote through years). In the same time I’ve been doing the necessary steps in building a company sometime in the next year, for me to live from my projects. [...]

I’ll need my projects to make me live. The game I am making is designed to be commercially viable,  which don’t mean it will be but just that I’m focusing on making it sell-able at least enough to make me live from it. However, none of the current AOS projects is sell-able or even meant to be. [...]

The main point I’m trying to make is that I want AOS to be part of the projects of my future company, while still being open source, [...]

I have some plans [...]

This post will be about these plans.

objectives

Other than having a working and released version of AOS Designer out in the wild, another less technical objective, but still important, will be to make sure Art Of Sequence projects are supported by my future company, which means I benefit enough from it to be able to spend more time on it, or allocate resources or people on it. This will not be easy at all, but I will work to make it happen.

The core projects will stay free and open-source.

It is important that I first state some changes I will not make. The core projects, the AOSL format, AOS Designer and AOS Web Player will definitely stay open source and with a very free license (currently MIT but maybe it will change to a similar one). These projects still need to allow anyone to build commercial or free tools over, without any constraints.

My main commercial projects will be based on these technologies, so any improvements on these will be made public and free too. However, I am not sure if my commercial projects will be open source or not. Maybe some of them. Or if there will be a dual licence or not. The legal details requires to consult a lawyer but I have a general idea of what I want to do: just build some paid tools over my free tools.

Here are some of the tools I plan to build after AOS Designer 0.1 release.

New Players

Currently there is only one player implementation, unfinished actually, which shows how AOSL format can be exploited. Anybody could build other player implementations that would solve specific context problems. I see real opportunities, that I’m sharing without fear of having my ideas stolen as for the moment no serious effort have been made to exploit AOS code for commercial purpose yet, so I think I will have to pioneer them myself both for profit and demonstration. Here are some ideas:

  • Native players: what I mean is a player that can read the generic format I was talking about in the last article. Basically, it would be a player you install on your desktop or tablet or smartphone, then just play any story that you download. I believe this is less interesting commercially than the other projects, so I might do it for free and in less priority than other projects. If this will be open source, I think a lot of people will be interested anyway.
  • Native specific players: there would be an important difference with the previous case: the author of the story would generate a full custom application for his story. This mean the author can sell his story (that can be a series) as an application, the same way you sell a video game. This one is interesting for me because it would both help a lot of authors, it’s interesting technically and it seem viable commercially (by selling a license to the author). Also, it don’t force the author to pay, he still have the choice to use more generic players.
  • Embedded native players: one of the possibilities I envisioned when I started working on Art Of Sequence was to allow game developers to embeds a player implementation in their game code and use it do play some nice cinematic sequences. As a game developer, I know that most game companies have their own technologies to do this or just rely on video. But sometime, video is more expensive (in space at least) than using a custom tool that just display pictures and play sounds in a specific manner, to tell a bit of story. AOS technologies is exactly that, so providing a way to embed a player into a game might help a lot of game developers. It would help any other software company that want to display a story a bit like displaying a PowerPoint, so I think it is a commercially viable project too. What I’m not sure about is the nature of the “native” part of the project. Most game company use C++ to make games, but indie game developers tends to use anything that work. Maybe I’ll provide a C interface.
  • Flash player OR native player in Flash plugin: I’m not sure about this one but it is certain that it shouldn’t be very hard to write a player that runs in Flash. Maybe I’ll start an ActionScript3 implementation that would be free and read the generic format, and then make a native implementation (derived from the previous point) that would just run into the Flash environment (which allow native code now).

New Formats

In coordination with native players implementation, another AOSL-derived format is necessary. It would be a very compressed format, something like just byte instructions. The goal would be to provide this alternative (for a cheap price) in case you want to use AOS technologies in very constrained contexts (like embedded devices).

AOS Designer Plugins

After AOS Designer 0.1 is released, it would be possible to create plugins for it. Basically, plugins would only add some ways to constraint authors for specific platforms, like preventing the author to export a sequence that would not have a canvas size that fit into an iOS device. These plugins would go in pair with exporters that them-self are related to player implementations.

Other than plugins associated with commercial player implementations, I might build some utility plugins that would not be useful to everybody but would appeal to a niche of authors. In this case, providing a useful plugin for a fair price would also help both sides.

End of plans

Now that I exposed all this, it is time for me to first wish you all a happy new year (don’t drink too much!) and get back to work! See you next year!

 

Focus in 2013 (part 2): Development

After discussing what will change in AOS project communication starting next year, here are some more technical shift of focus that are on the work.

Folklife_Festival_Welsh_Blacksmith

Development Effort Priority: AOS Designer

I need to use AOS Designer (AOSD). I say this as an author not as a developer. What I mean is that I want to make some stories that I know are hard to do with current tools but should be easier with AOSD. I am not the only one and a lot of people have been waiting years for me to provide a first usable versions of it, even if it’s broken, just to help with the development effort.

Unfortunately, in the middle of developing the first AOSD version, I discovered several code architecture problems that made me rewrite everything once – which was to be expected as I never did write this kind of editor before. Then I hit a point where I really needed to have AOSL stabilized to be able to exploit it correctly. At this time, the development effort shifted back at stabilizing AOSL. Once done, I had to make sure AOSL was interpretable by tools, some kind of working proof-of-concept, which meant I had to write a player implementation, resulting in the work done on AOS Web Player version 0.1.

Now that these basics constructs are finally ready, I can focus on AOS Designer. It really needs tons of love so it will be my priority and I already started working on it.

AOS Designer relies on Qt for the GUI parts -the other parts are supposed to be totally independent, even if it’s not yet totally the case in the current code. Qt had a major release this month, Qt5, which I already began to migrate AOSD code to, as you can see in this repository. One of the reasons to use Qt5 is that it solves some problems I have been hitting in developing AOSD. I also will consider making all the interfaces in QML / QtQuick to help UI designer contribute to the project. I’m not sure yet if it is the right approach for this project but I’ll have to play with it enough to get enough experience to know, or rely on a contributor’s Qt experience in the future if someone feels like helping.

AOSL 1.1

In the beginning of this year I started a discussion in the developer forum to review the features that I feel are needed to make AOSL more useful, as an inter-operable format to represent digital story-telling . Among the important features, text object support, localization (which can currently be done with the “layer” system, but is not perfect for the job yet) and standardized effects would be the most important ones.

As the effort will focus on AOSD as a priority, enhancing AOSL will take some time but can be done in a parallel effort. The first step is to decide which features will get in, how it will be represented and update documentation (more on that in the following section). However, once this is done, an updated version of AOS WebPlayer should be implemented as a proof of concept OR an updated version of AOS Designer OR both if we want to be complete. Any way, this work is necessary to make all the tools very useful but as I can’t clone myself (yet) to work on several projects at the same time, it will go slowly. Fortunately, the first AOSD and AOSWP versions can still rely on AOSL 1.0 while we figure out what AOSL 1.1 will be.

Technical Documentation

There are several reasons, other than the lack of exposition and clarity, which makes programmers interested in AOS don’t feel like they can help. One is that AOS projects mix a wide range of technologies that can be intimidating for some; another, more important, is that there is a big lack of documentation necessary to jump in the wagon of the slowly rolling train that is this project. It’s not like I totally neglected technical documentation. It’s just not enough yet.

Here is a list of documents that I made so far to help clarify how to work on AOS:

  • How to contribute: expose the different work fronts of the different projects.
  • Development Setup: for programmers, how to setup a development environment to work on AOS projects.
  • Coding Standard: for programmers, some (unfinished but usable) coding rules.
  • AOSL Design: an explanation of the goals and guidelines to use in designing AOSL
  • AOS Designer : Vision : a description of objectives and design guidelines used in designing and developing AOS Designer.

And here is a list of documents that are missing to help contribution:

  • AOSL Specification: currently, AOSL is described in an XSD file, which is very helpful for programming works, but only if you already understand how the AOSL format is supposed to work. The missing document is a human-readable description of how a AOSL file is composed. I started working on this long time ago but stopped because it needed first to have a proof-of-concept showing that the format is readable (to software, not to humans) and usable the way it was designed.
  • AOSD Use Cases: this would be to clarify development goals for future developers. However, I think this might not be necessary. First because it will be more obvious what have to be improved in AOSD once a first version is released. Second because such documentation takes a time that I don’t really have. So for now I will put this in stand-by and only reconsider it once AOSD 0.1 is available.
  • AOSD Code Architecture: a description of how the AOSD code is organized. It would just be helpful to have a quick overview for new developers before diving into the actual code. Some time ago I began making a diagram that would make things easier and will be accompanied by some short description of what you see there. I think it is not necessary to complete this document yet because AOSD needs to be stabilized first, but part of the work is done and once AOSD 0.1 is released, I will finish this document.

If you think other documents would be helpful, please describe them in the comments.

New AOSL-based Format

I had some discussions with some people interested in the AOSL format. One of them suggested to provide a specification for another format that would contain the resources used by the AOSL format.

Currently, AOSL don’t specify what format of resources (images, sounds, etc.) are required, it is up to the interpreter implementation to set limitations. This design decision was taken to make sure AOSL can describe any kind of digital story-telling regardless of the kind of resources that it is composed with. However, this means that different interpreters will read the resource infos differently, maybe look for the resource files in different ways depending on the context. This allow nice features, like having an interpreter inside a video game to make “cinematics” using AOS technologies, but it is not really practical for more general cases like when you just want to have a file that contain your whole story and don’t care what player will be used in the end.

This generic case require that some kind of format is specified over AOSL to make possible to just throw a sequence file to any player that accept generic sequence file. This format would be something similar to the epub format: a zip file with an AOSL file to drive the story and resources in sub-directories. It might also specify which generic formats of resources are accepted, certainly something close to HTML specifications.

I will take the time to specify such format as it will help other developers tools exploit AOSL power. It will be used by AOS Designer too.

Development Website Migration

I notified some months ago that the development resources, code & documentation, will migrate from Google Code to BitBucket.org. Nothing special here. The new repository is already in place and what’s missing is the migration of the current documentation. Hopefully it will be done in no time very soon.

The reasons for the migrations are multiple. One is that Google Code forces the user to have and use a GMail account. Another is that it don’t allow easy pull-request manipulations. I would have used GitHub if the project was using git, but it uses Mercurial and I don’t have any reason to change this at the moment.

Repositories Split

Once the migration of the development resources is done, I will also split the code repository in the following way:

  • aosl : the repository containing the AOSL specification and documentation, including the XSD file.
  • aoslcpp: the repository containing a C++ library that can read and interpret an AOSL file.
  • aoswebplayer: the repository containing the code of the web player. I’m not sure yet if I will put the demo in this one. It’s likely but not sure.
  • aosdesigner: the repository containing the code of the AOS Designer project.

Until now, all this code was contained in only one repository to simplify things. However, this is not very helpful for developers wanting to develop with specific version of one of these projects, while using specific version of another of these projects. Also, it is currently not really easy to just get AOSLCPP project to build another tool over it, like a (iOS or Android or Windows or Mac or Linux) native player for example.

These are separate projects, even if they are interdependent, so they should have separate code. I will use build system scripts (CMake) to make sure each project that needs some dependencies will check that these dependencies are available. This separation will also help me keep track of issues separate for each project.

It will also allow me to specify different licences to different projects. (The current code will stay MIT though).

Commercial Projects

As I stated in the introduction article, I will need to live from both Art Of Sequence and other projects. To achieve this, once AOSD 0.1 is out, I will also start work on other sub-projects that will have more or less commercial licenses.

More on that in the next and last article about my plans for AOS in 2013. Stay tuned!

 

Focus in 2013 (part 1): Communication

As explained in the previous post, communication about the project is, on all sides, a failure. Most people don’t understand the problem that is being fixed, the need nor the solution or how to participate to help. This really needs to be fixed as lack of participation on the development effort is the only bottleneck of the AOS projects. Here is what I plan to do in the coming weeks to fix this.

IMAG0194

The main information source on Art Of Sequence is this very website. In it’s current state, it have several problems:

  1. Text wallsTL;DR - any non-academic or already interested in the subject people will stop after a few lines of the text walls I put in each pages of this website.
  2. It don’t state clearly what is the problem being solved.
  3. It is not clear what exactly is the Art Of Sequence project. I mean, it does have some explanations about what it is but it is not clear enough how the AOS projects solve the unclear problem.
  4. The Web Player Demo isn’t clear enough what it is about, what is demonstrated.

That’s basically it.
The following is what I’m working on to fix all this.

New Website Front & Content

I started designing a new front page for the website that would be a simple static page that would look like a comics page. It would contain big sized texts with very short, succinct and concise explanations. Part of the page, in the biggest panel, there would be the AOS Web Player demo running, with a quick description of what the hell it is.
This front page should be done and public in the beginning of the year.

In the mean time I plan to radically rewrite each page describing AOS projects. The goal will be to make simpler explanations with more obvious examples of what it is about. I started writing and working these texts and I am confident it will be far better this way.

What is AOS

One of the first things I already changed in several places (including the project’s Twitter account description) is the quick summary of what AOS is.

Art Of Sequence is a set of “digital story-telling technologies”. No more, no less. This is a bit less precise than previous descriptions (which were different depending on where you look at…) but the specific technologies are different depending on what project you’re interested in, if you are an author or a programmer, if you are a reader or a digital comics enthusiast. Each project have a specific purpose, a problem to solve, but it’s only when all projects are put together that they shine.

I’m preparing a special intro to AOS that should be efficient enough to get the point of what are the problems and how each project solve a part of it.

Another important change in the way I will present the projects is what is AOSL. So far I often talk about AOSL as a “language”, but it’s actually a meta-format specification. It could be based on something else than XML, and it’s supposed to be used to create other more specific formats for specific platforms. So basically, I’m changing my discourse about AOSL this way: AOSL is an intermediate data format meant to allow different digital-storytelling tools and reader applications to work together. The AOSL page will be simplified and will clarify things by stating that not only it’s a potential standard for work files for different tools targeted at digital storytelling, for players and converters; it is also the base of future different file formats. More on that in the next article.

Clarifying the Demo

Originally, I planned to add clarification tooltips and other quick info in the AOS Web Player demo page, to make sure it’s clear what it was a demo about. Unfortunately I was short on time so I released the demo page as it is still today. Most people assumed it was an attempt at replacing Flash, which it is not. This is the hardest part to clarify as the demo don’t say what it’s showing exactly and most people will obviously say you can do the same in Flash. I know, that’s part of the point.

AOSWP demo is meant to show how the AOSL language works with a player implementation. This means even if I add clarifications in the AOSWP demo page, there will still be a need to explain better what AOSL is. The ideal demo would be to have both a Flash implementation and a JavaScript implementation of the same story in the same page. This way the reader would start to understand that the same story, defined using AOSL, can be converted to different platforms (HTML5, Flash, NACL, etc.) with almost no difference.

But writing a Flash implementation of a player, even if in my plans, isn’t a priority at the moment. I will not focus on this but I will make sure at least that the demo page is clarified.

Presentation (PowerPoint)

In the first half of this year I was working in Japan in a creative company which was interested in the kind of technologies AOS was, in particular as it is theoretically possible to build a digital manga editor business over these technologies. We couldn’t continue working together in the end, but when I was there I was allowed to take the time to setup a presentation about what AOS is. I have a copy here and with some modifications, I could publish it. I think it was a good intro on what is AOS.

However, I am a bit annoyed that it’s a PowerPoint. You see, the best way to present a technology that allow (or focus on) narration is to use this technology to make a presentation. Lacking an edition tool, as AOS Designer is far from being usable yet, I would have a very hard time today making the same presentation with only AOSL code. I hope to be able to do this in a few months -more on that in the next article- but clearly it’s not a possibility today. Is it tolerable to publish a PowerPoint for now? I have some doubt but I think publishing something OK today have more value than publishing something perfect in 6 months.

To Be Continued…

In the next article, I will present the development, purely technical points on which I need to focus my efforts on to both make the project going forward and attract contributors to help on the project.

If you have suggestions of improvements on the communication of AOS projects, or any other feedback, please comment here!

Focus in 2013 (part 0): Status & Context

First of all, Happy Holidays to you all.

In the coming days, I will publish my “plans”, or more precisely “effort focus”, for the Art Of Sequence projects for the coming year. As several months passed since last update (the release of AOS Web Player demo) I first need to put you up to date about what happened in the projects since then and also what problems we need to fix to go forward. Then the following articles will focus on different work fronts we need to focus on, with some ideas that will be attempted.

AOSWP_0_1_demo_doc_4

My (Future) Company

I’ll make a brief description of my current context as it is an important information to understand the following articles.

Since mid-July 2012 I have been working full-time both on AOS (which resulted in AOSWP 0.1 release) and a video game (which I restarted using previous code I wrote through years). In the same time I’ve been doing the necessary steps in building a company sometime in the next year, for me to live from my projects. I am currently paid by French government help (a percentage of my last salary from France) so on the money side it’s not perfect but at least I can focus most of the time on these projects, when I’m not doing other urgent works like moving to a new place again.

I’ll need my projects to make me live. The game I am making is designed to be commercially viable,  which don’t mean it will be but just that I’m focusing on making it sell-able at least enough to make me live from it. However, none of the current AOS projects is sell-able or even meant to be. They are half base code on which you could build commercial software on, half proof-of-concept. This unfortunately means that since November I need to focus more on my game development to quickly reach the point I can start sell it, impacting seriously the technical work on AOS projects. As some could have noticed, I didn’t do any code improvements since the AOSWP 0.1 release for this reason.

Actually, I did work on technical stuffs for AOS (in September and October) but it was more research code, which failed (but provided me good data) so I didn’t publish the code. So far, AOS projects didn’t move forward at least on the technical side.

Fortunately, I did work on some other aspects of the projects which might help the global projects more, as I’ll explain in the following paragraphs. The main point I’m trying to make is that I want AOS to be part of the projects of my future company, while still being open source, which means I will have to setup some solutions to be able to spend more time on it or have more resources (people helping on the open source side, companies helping, money to buy tools or hardware) to accelerate the development that is clearly too slow but cannot get faster today. I have some plans, but let me continue explaining what happened since last time, to get the full context.

Siggraph-Asia Communication Failure

The AOSWP demo release was a proof that it was possible to read an AOSL file and interpret it efficiently in something like a browser. This was a total success, even if the current web player don’t implement all features of AOSL 1.0.

This milestone being a success, there was a deadline associated to it which was motivated by the submission of pannel at Siggraph Asia explaining a bit what AOSL was about. This submission was a failure. There was actually two things that failed.

The first failure was that the submission wasn’t accepted which meant I don’t (yet) have an opportunity to explain what is AOSL myself to people that might be interested in it. Having good documentation (current one isn’t good enough, but I’ll get back to that) is a good thing but having someone answering your questions interactively is far more helpful for everybody. With help of some people in academic and commercial circles interested in AOS technologies, I will have other opportunities to communicate on this but it’s still an opportunity lost.

The second and actually more important failure is that the reviewers of the documented asked questions that made obvious that nobody understand the point of AOSL or even any AOS projects. Over the months I have come to believe that the whole communication around AOS projects, purpose and essence is just a big failure. This wouldn’t be a problem if there was a dedicated team (I mean more than one person) working on the project to fix this and make everything happen. It is actually the main thing that prevent the project from being understood by people who could be interested enough to help on the technical side of the development of the projects.

Communication have to be fixed. After having analysed what exactly was misunderstood, I spent some days working on designing some solutions to fix this. I’ll explain in details what strategies I’ll use in the next article, including on technical communication, so stay tune.

Promising Meetings

Around October and November, in Skype and in real life, I got contacted and had meeting with several people interested in AOS and in particular in AOSL which is the central core of the ideas behind all the projects. After some live clarifications on the purpose of these projects and where they are meant to go on the long term, we agreed that there was really something useful going on and that the main problem with the project is that it is going slowly by lack of resources.

Recently I got notified that several companies in France (digital) book edition circles have been made aware of AOS projects and seem to be interested in them. I don’t know yet what will happen but there are chances I will be able to have some important meetings with people that are in positions to help the project in significant manners, for both commercial and simplification reasons.

The communication fixes I’m planning will in part involve preparing presentations for different meetings and events. More on that in the next article.

Slow Development

As my focus shifted more on my commercial game project, the lack of contributions to the project made the technical development of all AOS stalled. I initially thought that the AOS Web Player demo would have piqued interest in Javascript enthousiasts, or even Flash enthousiasts maybe to write an ActionScript based player that would have easily read an AOSL file. It didn’t happen, unfortunately.

Part of the problem is communication of the concept itself, as pointed before, as few people understand the huge problem I’m trying to solve. Another part of the problem is the lack of good technical explanation of some important technical aspects of the projects. One example is that AOSL still don’t have yet a human-readable specification or complete tutorial, to help developers implement players or converters. AOSL isn’t very complex but it’s still not straightforward exactly how to interpret it without reading the comments in the XSD specification (which helps doing half of the parsing work, so it is still helpful).

The bigger problem is AOS Designer, the edition tool, which still isn’t usable today as it’s development have been paused while I was focusing on AOSWP. I actually worked a bit on it in last months but not in a very significant manner. One problem with this tool is that UI designers and other programmers are having a hard time helping without a first usable version showing them what is the core usage of it. I was asked to write use cases to fix this, but even writing blog posts burn (necessary) hours of developments that I should spend, with others in an ideal world, on coding the damn tools. UI designers need pointers to understand how then can help with AOSD and programmers need more specification.
Another problem with this tool is that it’s still technically the most demanding project. It require quite a lot of work, much of it would have been done quickly if it didn’t need to be cross-platform and very responsive. Some of the tools I use to develop it also had problems that will be fixed soon, so it made me loose a lot of hours figuring this out, but at least now it is clear what I need to fix to make AOSD development go forward.

As a reminder, if you think you might help with the project, or think you know some people that might help, please be my guest. All technical data, including all the sources of the projects, are available at http://dev.artofsequence.org and you can ask for pointers if necessary in the development mailing list.

Resume Work

Now that alll this is stated, I can start explaining how I will spend the time I can spend on AOS in the coming months of the next year. Stay tuned!