Lately I had to restore my macbook from time machine. Luckily, the reason was that I got a new MacBook 🤓. So I created a last time machine backup, said goodbye to my old macbook, and moved on to my new machine, starting with restoring from my all new time machine backup. I did this several times now and it went well every time. And… no problem this time either and this is what I tell all my jealous Linux and Windows friends. But what I didn’t tell them is that the next step is less fun: inheriting the backups of the old machine.
In March I wrote about a new project called DIME (Dynamic web application Integrated Modeling Environment), which enables to create full-fledged web applications via a family of GDSLs (Graphical Domain-Specific Languages), with an additional textual representation. It is the beginning of a development style, where technical experts and application experts (e.g., business experts) can work together on one artifact. The underlying idea of the approach is, that the different types of modeling languages (for data, control, and user interface) are interdependently connected and describe the application completely, so that they can be full code generated to a ready-to-use web application. Everything that cannot be captured adequately on the model level, can be integrated in a service-oriented fashion via so called native components.
At the end of that post I announced a DIME landing page, created with this very tool. Now a first version is online, which is responsive and shows already a few dynamic features, like internationalization (you can choose between english and german in the menu) and a comment form, where you can leave your first impressions. But please be kind, the
Add Comment-process informs us about new comments and we can delete rude commments in the private area (all generated). The site is work in progress, we will update it with new features, more information, news on public events, and projects where DIME has been used. Further on, we will add a download section as soon as time has come for going public with DIME.
We already have some nice demo applications like a TODO-App as well as a “Reddit”-Clone, which will ship with the DIME installer. Just last week we held a DIME workshop on STRESS’16 co-located to ISoLA 2016 conference.
So please, take a look at the DIME landing page, leave a comment, and stay tuned for more to come.
Dear Jan, thank you very much for your time. I really like the ecosystem around Xtext, Xtend, Xcore, Xbase, and EMF. I think it is one of the most-disrupting decisions (in a positive way) that, starting from 2.9.0, you address more than just the Eclipse platform! But with this new approach and your all new company TypeFox (as well as the spin-off from itemis), some questions arise…
SpriteKit offers two ways to play audio:
SKAction.playSoundFileNamed:waitForCompletion: for playing a sound once
SKAudioNode(since iOS 9): for playing background music in a loop, or do other advanced audio stuff like positional audio (3D spatial audio effects).
The first option is quite unflexible. It just plays the sound once. You cannot change the volume or put any effects on them.
SKAudioNode on the other hand offers a lot of cool features via
SKActions like changing the playback rate and volume and adding live effects like reverb.
This seems to be a no-brainer. I tried it in my game Fusionate and there was a real bad whistling sound, although I didn’t use any effect or positional audio (just volume changes). So, back to the first option and create a lot of audio files by hand, in order to get the desired effect even for simple things like changing the volume?
Mustache is a well-adopted template language which itself says that it is logic-less. So, there are pseudo-logic statements, which allow to iterate over a list or do a
null-check, and it is possible to add arbitrary (unparameterized) template function. But they make a hold when it comes to an
if-statement with a boolean check.
There is a lot of discussion going on in the nettm on why a
null-check and template functions are ok, but an
if-statement and parameters are not… but hey we have template functions, so why not add our own implementation of such things?
Lately, I wrote a small text in markdown and felt the need to share it with someone (non-technical). I searched for solutions to convert markdown to PDF and was very surprised, that there were only so-so solutions. After some googling and coding I found an easy to use solution which comprises a markdown tool for converting markdown to html and phantomJS (a headless WebKit scriptable) for converting html to pdf. The cool things: hyperlinks and custom css work.
In my last post I described how to cope with generic types in a meta model regarding the scoping mechanism of XText. This post is about the oddities (not meant in a bad way) of XTexts object creation strategy.
Let us take the entity model example from my last post and refine it a little bit. Since we are creating a textual DSL (domain-specific language) and not a GPL (general-purpose language), we would like to add (further) abstractions to our language. Therefore, we do not use the language itself to describe collection types, but integrate it into the language. In contrast, in Java a
List is an interface with several implementations like
ArrayList. They are all implemented in Java and not part of the language features itself. Of course, there are some general-purpose languages like Python, which integrate collections directly into the language, or others like Google Dart which semi-integrate them via syntactic sugar, but still have implemented them as normal classes. But this is not the point here: We would like to integrate collections as a concept into our language…
This post is about some juggling with technologies in the EMF ecosystem, namely XText and XCore. Consider a small (and not completely realistic) DSL for defining entity types (like the introductory grammar example of the XText documentation). Often there are two different kinds of types in such a language:
- primitive/native types, provided by the system, e.g., String, Integer, Boolean, …
- composite/complex types, which have been modeled in the language and can have attributes of primitive type or refer to other complex types
So we might model these variants of properties as
Attribute for primitive types and
Association for complex types…
A major part of my research/work at the university and in some of my personal projects is about integrating business experts into the development process. You can read more about it in my dissertation. We reincarnated a very ambitious project, which now focuses on modeling complete web applications. We defined different interconnected graphical DSLs (Domain-Specific Languages) with Cinco and allow to one-click generate and deploy it on an application server. I am very excited about this great project and some of my posts are (and will be) inspired by it.
As of recently, we use XText as an alternative serialization format to XMI for our graphical DSLs. XText languages have some nice properties over XMI, like syntax highlighting, scoping, validation, just not being XML, compatibility with VCS, etc.. But most important it is much easier to “repair” XText models after a format/meta model change, than with a graphical editor (which just ignores friendly inquiries to open an incompatible file), or with XMI (trust me it is a 😵).
This brings me near to a dream I already have for quite some time: Bringing together textual and graphical DSLs to describe the same model. This is so great because all these integration efforts of business experts (i.e. non-programmers) into the development process is up-to-now a one-way approach. But with a textual representation both the technical and the business experts are likely to use (different views on) the same modeling artifact. Since December 2015 XText (2.9.x) supports IntelliJ IDEA, some web editors as well as standalone usage besides Eclipse. This is great news again (although I have some problems to get it up and running the way I would like to. But more on that later)!
So stay tuned, to news regarding this great new project called DIME (Dynamic web application Integrated Modeling Environment).
The Java 8 Stream API is pretty cool as you can see in my last post BFS with Streams. But there is a catch. You cannot reuse Streams. Consider the following code Java-Code:
final List<String> helloList = Arrays.asList("H", "e", "l", "l", "o", ", ", "W", "o", "r", "l", "d", "!"); final Stream<String> helloStream = helloList.stream(); final Predicate<String> checkUpper = s -> !s.isEmpty() && !s.substring(0,1).toUpperCase().equals(s.substring(0, 1)); helloStream.filter(checkUpper); helloStream.filter(s -> !checkUpper.test(s));
This results in
IllegalStateException: stream has already been operated upon or closed.
The problem with Java 8’s Stream API is that they are designed for parallel execution. This decision introduced some constraints. Unfortunately, there is no sequential only-switch. What you can do is collect the results with
groupBy into a map and then create two new streams from that. But collecting is a terminal operation, not lazy, and therefore inefficient (especially in combination, with early-exit operations like
limit). You can also try to do the first filter, chain it with a
peek, and finally do the second filter. But since only elements matching the first filter will reach the second filter (i.e.
a && !a which is equal to
false), you won’t get any elements past the second filter. If you have a so called cold source (i.e. like a collection), you can just use two different streams which results in two iterations. But for hot sources (like a network or file i/o stream), this is not that easy. A possible solution is to cache the input in a collection, i.e., cool it down. But this comes with a space and performance penalty. So let us see, what our options are…