Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.Sign up
Table of Contents
S.IM.PL is different from many serialization frameworks because it natively supports graphs and cycles in data. Doubly linked lists and hypertext are typical cyclic data structures. Many JSON and XML serialization frameworks cannot handle such data structures, which requires designers to add additional boilerplate code to serialize their data. Supporting cyclic data means that very little modification needs to be done to data structures to support de/serialization. (At the moment, data structures need to be annotated in a target language; future work will eliminate this requirement and replace it with a description language)
S.IM.PL also works to support more formats than most other serialization frameworks. Its architecture is designed in such a way that new formats can be added as needed, building on reusable type system software components. Any application that uses S.IM.PL can de/serialize data in all of the formats supported by the S.IM.PL implementation in its source programming language!
S.IM.PL also facilitates cross-language translation of data structures. For example, if you have written a class in Java, it is possible to use S.IM.PL to generate source code for an equivilant C# class. (And, since the classes are the same, data from your Java application can be deserialized in a C# application!)
Overall, S.IM.PL aims to simplify many development tasks which are tedious and time consuming. Instead of focusing on writing serialization code, you can focus on writing more exciting application code. And, in the future, when you decide to port your application to another language, you can do it just as easily as recompiling your data structures! S.IM.PL also makes interoperability between programming languages that support nearly painless!
S.IM.PL supports a wide array of use cases. In general, it functions superbly as a foundational data layer for your applications. Here are a few ways that you can use it:
- As a quick and simple mapping between serialized data and your objects
- For multiple format support for applications
- To provide the foundation for complicated "data semantics" applications
- As a base data-layer for web services
- To improve communication between multiple application layers in a distributed system
- To foster integration between your application and applications written in different programming languages
- To abstract away programming languages and focus on a strongly-typed service abstraction
- ... The list goes on!
Here is a brief list of projects that S.IM.PL has been used on:
- BigSemantics (Wiki) is a free and open source language and software architecture for defining, extracting, manipulating, exchanging, and presenting rich semantic data across applications. BigSemantics is a great example of how to leverage S.IM.PL to design applications. It uses S.IM.PL for:
- The data-layer for its metadata representations
- The interpreter for its Meta-metadata language
- The foundation for its semantic service
- The translator to cross-compile metadata objects into many programming languages.
- InfoComposer (Website) A tool designed to help people compose information in a "composition" space.
- combInformation (Website) An agent-supported curation tool to help users come up with ideas from the web.
- Trans-Surface Interaction: All of our trans-surface interaction work leverages S.IM.PL as a data layer to communicate between Android/iOS devices and servers. Videos and papers are here.
To get started, Check out code and set up a development environment. and then work through the introductory overview and tutorial about S.IM.PL here.
We are in the process of writing more detailed tutorials about S.IM.PL (both about using and reimplementing it!) If you have any general questions that haven't been answered by the Overview, consider browsing our Tutorials. If that hasn't solved your problems or answered your questions, Contact us and we'll write up a tutorial just for you! (Chances are, other people have the same questions!)
S.IM.PL has been implemented in the following languages. If you have created an implementation, feel free to share the link with us and we'll place it here! If you are interested in implementing S.IM.PL, peruse some of our documentation and feel free to contact us!
Our reference implementation of S.IM.PL is written in Java. We've leveraged this implementation for some of our lab's prior research, such as InfoComposer and combinFormation. You can access the code here.
We also maintain an implementation of S.IM.PL written in C#. That can be accessed from Github as well.
A preliminary implementation of S.IM.PL has been created for Python, but plenty of work is needed to bring it up to speed. The code can be accessed here