Domain Specific Languages with INGENME
AIDE: designing for the people
Develop a library of sensors and a a language to specify assisting technology
Increase the Character Intelligence
Open document formats Export/Import
Group selection of wikis and metrics in tabs and share those selections
Visualization of metrics about article quality and types of edits
More info: http://ingenme.sf.net
Software repository: https://github.com/Grasia/ingenme
This project is based on existing software, namely jgraph/jgrpahx, to create an infrastructure where visual languages can be designed and become a regular component that can be reused elsewhere. JGraph original work was intended for diagramming in stand alone applications, but new visual editors had to be manually built. INGENME is a framework built over JGraph that allows the developer to visually define a modeling language and produces self-contained editors you can reuse anywhere. Examples of such editors are INGENIAS (http://ingenias.sf.net) for Multi-Agent System Design, SelfMML (http://selfmml.sourceforge.net/) for defining self-management systems, or SociAAL (http://grasia.fdi.ucm.es/aide/tutorial/) for defining ambient assisted living situations.
In terms of functionality, it is close to the EMF, but much simpler, light, and portable.
The candidate requires knowledge in Java and Javascript. The project uses as well Maven, but training can be acquired.
The JGraph has been extended to work over browsers in MXGraph (https://github.com/jgraph/mxgraph). The idea would be to reproduce work done in INGENME to generate purpose-specific browser based editors, such as http://bpmn.io. With this adaptation, a developer could reuse the same modeling language specification and produce different flavours of the purpose specific editors (both stand alone and web based).
This web based version could be complemented with integration with google drive and allow the user to store the specifications either locally or in google drive.
Mentor: Jorge J. Gómez Sanz (jjgomez@ucm.es), Marlon Cárdenas (marlonca@ucm.es)
More info:http://grasia.fdi.ucm.es/bolotweet
Software Repository: https://github.com/Grasia/bolotweet
This project is based on AGPL software called Status.net, which later one formed the basis for GNU-Social, the open source alternative for Twitter. Bolotweet is about implementing the continuous evaluation methodology in the higher european education space as agreed in Bolonia. This has turned out to be expensive in Spain because the lack of resources for education during the global crisis. Hence, the motto of the project is how to provide a continuous evaluation which is sustainable, that does not overload professors, but it is still effective. The answer was microannotation systems, such as Twitter. Bolonia and Twitter are the inspirations for this work.
Bolotweet is a tool and a teaching method. If classes take 50’, 40’ are used for whatever classroom activity, and the last 10’ for annotating something learnt along the previous 40’. This annotation is reviewed and scored by the teacher later on. Students are free to reply, retweet others. Also, they are given a rank to know how good they are with respect the rest. Although other students cannot see how your tweets were scored, they will see when a tweet had the highest score. This is used to show other students what kind of annotations are considered as exemplary.
It has been proven that students that microannotate (e.g. produce tweets), perform better than those who don’t. However, our work in study shows that, if twits were evaluated with a 0 to 3 score, a correlation would appear between your final exam score and the total accumulated scores obtained from your evaluated twits (https://link.springer.com/chapter/10.1007/978-3-319-40165-2_6).
This project requires knowledge in PHP and MySQL. Also, working regularly with linux based systems is useful. The developer requires working with docker too.
The tool needs some assisting software to suggest students how to improve and also to reduce the reviewing time on behalf the professor.
Right now, the system uses a responsive design approach, but it is not very effective in most devices. For professors, it is highly ineffective because the additional buttons for evaluation can hardly be situated in a smartphone screen. Besides, writing answers in a screen is slow. Reusing answers sent to other students or creating predefined answers can be a solution.
For students, recommendations about their status and how to improve are becoming increasingly necessary. For instance, if the student constantly receives low scores, it would be motivating to have messages from the system telling how to improve (e.g. repeat the tweet), and congratulating when receiving high scores. The system could try to play with the student asking the student to score tweets from other students that were already scored by the professor. This could help the student to acquire the same criteria as the professor and self-evaluate when tweeting.
Mentors: Jorge J. Gómez Sanz (jjgomez@ucm.es), Marlon Cárdenas (marlonca@ucm.es)
Just tweeting ideas can be boring. We propose to gamify the experience by giving a configurable background to the experience. Each classroom would become an adventure where the goal is to make a character progress. Positive scores to tweets would make the character advance and acquire capabilities useful when challenging other players. A challenge could be one student sending another a test question and ask the other students to answer correctly. A student could use acquired capabilities to reject a question, to allow one failure, or to rebound the question to another student. There could be battles between teams too. By automatically assigning students to teams in a classroom, the last 10’ could be a battle of tests sent to each team and the scores represented in a screen. The challenges and the battles would be used to motivate students to create tweets that receive high scores on behalf the professor.
Mentors: Jorge J. Gómez Sanz (jjgomez@ucm.es), Marlon Cárdenas (marlonca@ucm.es)
More info: http://grasia.fdi.ucm.es/aide
http://grasia.fdi.ucm.es/hackwithpeople
Software Repository:https://github.com/Grasia/phatsim
AIDE stands for Ambient Intelligence Development Environment. This project is about the serious use of game engines to test/design/conceive assisting technologies for people with special needs. In these games, one or many characters interact in a house and perform some activities. The same activity should be possible regardless of the character conditions or limitations. Hence, our goal is to reproduce typical impairments in the game, and then, experiment with simulations of technologies that can cope with the difficulties. A typical example is an old couple that lives alone, but one of them has Parkinson. The partner has to monitor and pay attention just in case the patient falls. If there was technology 100% reliable that told when the patient fell, this could reduce the anxiety and stress on the partner. Given this engeering problem, the questions is how many sensors and how much privacy invasion is required to achieve this goal. This kind of scenarios is what AIDE is about. With AIDE, we reproduce the scenario and the interplay of simulated technology and the characters. Then we use the simulations to discuss and essay different control software, as shown in our HackWithPeople initiative (http://grasia.fdi.ucm.es/hackwithpeople)
It is entirely based on FOSS. It uses Java and the game engine is JMonkey. The project uses Android as default OS for assisting devices, but building others are possible, since most of the communications with the simulation infrastructure are made with sockets transporting plain text. This facilitates the creation of a variety of external programs that process what is going on within the simulation.
The framework is used in public official courses to train students in this kind of problems (e.g. how to detect the fall of a patient https://www.youtube.com/watch?v=Rd4YDQ8VknE). The different scenarios are programmed visually or hard coding directly. We don’t use Unity or Unreal.
The AIDE candidate should have interest in game engines and have experience using one at the programming level (no GUI). The project requires experience in Java too. The compilation and testing environment is Maven, which we can provide basic training if not familiar. The candidate should be curious about hardware and not be afraid when reading a specification of a device or a MQTT protocol.
Current sensors cover sound (with distance attenuation), inertial (accelerometers that can be place almost anywhere), camera, tactile (simple screen tapping). The development of technologies would be easier if there was a framework to easily create new sensors that used the information from the simulation and permitted to try out easily the performance of different solutions.
If the current state of the art of sensors is known and avaliable in simulations, this could accelerate the simulation of complex assisting technology deployment.
Besides, by identifying key concepts of assisting technologies, it would be possible to quickly prototype new ways of assisting people, at least, at the simulation level.
Mentors: Jorge J. Gómez Sanz (jjgomez@ucm.es), Marlon Cárdenas (marlonca@ucm.es), Ruben Fuentes (rfuentes@ucm.es)
Characters in the simulation are rather plain. They follow a simple state machine. This reduces the chances the character tries to learn how a device works or can interact by reading what a screen says. Adding basic AI capabilities to the character would aid to create more credible simulations of the scenarios. Also, to stress the assisting technology and determine if the simulated prototype performance is the one expected when the simulated user is not collaborating.
Mentors: Jorge J. Gómez Sanz (jjgomez@ucm.es), Marlon Cárdenas (marlonca@ucm.es), Ruben Fuentes (rfuentes@ucm.es)
More info: http://swellrt.org
Software repository:
https://github.com/P2Pvalue/swellrt
SwellRT, is a free/open source backend as a service that allows faster development of apps providing -out of the box- common features found in any modern application (auth, real-time storage, event based integration...). In addition, servers can be federated on Internet through the Matrix protocol, enabling decentralization of data and users, and interoperability among providers. It has similarities with Google Firebase, Meteor or Realm frameworks, but it provides stronger capabilities for collaborative text editing and a simpler API.
SwellRT is interested in proactive candidates with experience in backend development and mobile platforms. Depending on the project, different sets of programming languages are required (as specified in the ideas below), although SwellRT core components are developed using Java and JavaScript. Qualities that we would welcome are initiative, creativity, and interest/experience with decentralized / federated / distributed systems or protocols. You may check Github’s open issues and the project ideas below to have an overall idea of the possible evolutions of SwellRT. Of course, GSoC candidates are encouraged to adapt our proposals to their interests and we are very open to new ideas or unexpected evolutions of chosen ones.
To develop a native client library of SwellRT for the Android platform. Starting with the current Java client implementation, some platform dependent components should be replaced with native ones for Android, mainly, the HTTP and Websocket client libraries. This work would also require knowledge of Android's threading model, Gradle tool, and Java/Android application packaging models. Knowledge recommended: Java and Android, HTTP and Websocket protocols.
Mentors: Pablo Ojanguren pablojan@ucm.es Antonio Tenorio antoniotenorio@ucm.es
SwellRT server is a Jetty-based Java application. It has an internal bus architecture and a custom thread model. As long as SwellRT is based on processing live transformation operations we would like to refactor current code base to provide a better scalable implementation, ideally based on a non-blocking IO server and an actor based architecture. Knowledge recommended: Java, HTTP, Websocket, non blocking IO servers and actor based frameworks.
Mentors: Pablo Ojanguren pablojan@ucm.es Samer Hassan samer@fdi.ucm.es
SwellRT is a fork of the Wave protocol which uses Operation Transformations (OT) to provide real-time synchronization with eventual consistency. In a past edition of GSoC a proposal of an encrypted Wave OT model was developed. In this project we would like to fully adopt that encrypted Wave protocol into SwellRT. Good knowledge of Java, JavaScript and encryption/security concepts are required.
Mentors: Pablo pablojan@ucm.es David Llop dallop@ucm.es
More info: jetpad.net
Software Repository: https://github.com/P2Pvalue/jetpad
JetPad is a Free / Open Source collaborative text editor in the cloud. It looks for to provide a simple, flexible and open alternative to create documents in real-time on the Web. It is built with http://swellrt.org framework and Angular.io for the UI. A first and basic version is already in place at jetpad.net but a comprehensive list new features must be added to provide a useful product. Source code is available at https://github.com/P2Pvalue/jetpad
JetPad is interested in proactive candidates with experience in UI development and UX knowledge. The main development language is TypeScript/JavaScript. We use Angular.IO as UI framework. Qualities that we would welcome are initiative, creativity, and interest/experience with text editors. You may check Github’s open issues and the project ideas below to have an overall idea of the possible evolutions of JertPad. Of course, GSoC candidates are encouraged to adapt our proposals to their interests and we are very open to new ideas or unexpected evolutions of chosen ones.
JetPad is originally developed as a responsive Web application, considering a good mobile experience as a must. However, several improvements can be done regarding UX in mobile web browsers. Also the adoption PWA (progressive web application) techniques should improve such experience. Knowledge recommended for this task is Javascript, CSS, Typescript and Angular.IO. Knowledge in PWA and latest Web APIs is valuable.
Mentors: Pablo Ojanguren pablojan@ucm.es Antonio Tenorio antoniotenorio@ucm.es
Currently JetPad only provides text editing. Nevertheless, its core technology (SwellRT) can support other document types keeping the real-time collaboration. Here we suggest to add spreadsheet documents in JetPad integrating an existing Open Source UI library for spreadsheets with JetPad UI and SwellRT API. Knowledge recommended for this task is Javascript, CSS, Typescript and Angular.IO. Ability to assess and integrate 3rd party Web libraries and frameworks is required.
Mentors: Pablo Ojanguren pablojan@ucm.es Samer Hassan samer@fdi.ucm.es
We would like to allow JetPad users to export their documents to well known formats as ODF and PDF. Also it should be able to import at least ODF documents to JetPad format.
For this work, a comprehensive knowledge of Java and XML is required.
Mentors: Pablo Ojanguren pablojan@ucm.es Samer Hassan samer@fdi.ucm.es
More info: http://wikichron.science
Software repository:https://github.com/Grasia/WikiChron
WikiChron is a web application to visualize history data of multiple wikis through time. This tool aims to facilitate the generation and validation of hypotheses around multiple research questions, especially those around growth, distribution of work and health of an online community.
We are using data extracted from wikis using the mediawiki engine, in particular, we are currently using wikis hosted in wikia.com because it is a very diverse wiki ecosystem.
A wiki dump is downloaded with a custom script that uses the mediawiki download page history endpoint. Then, another script parses this dump generates and generates a csv file of the processed data. Finally, these csv files are the input which wikichron uses in order to plot the graphs.
WikiChron is written in Python using the Dash framework, which uses plotly and reactjs under the hoods.
The webapp is available online here: http://wikichron.science and its source code is here.
Researches want to explore different selection of wikis and metrics at the same time, they want to quickly switch between them and to be able to share their selections with colleagues.
We want to provide this feature with the implementation of tabs, and then, provide a way to to share those selections through a URI.
First part will consist in resolving #24, which in turn depends heavily on this Dash PR and in our own version of the Tab component. Second part will consist in resolving #26, so that users can share and save their visualizations of wiki data.
This task would require knowledge of both Python and ReactJs. Experience in Flask and/or plotly is a plus.
Mentors: Abel Serrano Juste abeserra@ucm.es, Javier Arroyo javier.arroyo@fdi.ucm.es
While between the open collaboration community, the number of words in an article is considered a good proxy of the article quality, this aspect can be analyzed from several perspectives. For example, the degree of linking and cross-linking (internal and external links, wiki links, etc), the structure of the article (table of contents, headings and subheadings), the use of images and media objects, bibliography sources, readability using scales such as Flesch Kincaid, etc. We would like WikiChron to visualize the evolution of quality metrics such as those mentioned that need to be first computed by the parser, then new kinds of plots may be used to visualize quality evolution in a wiki or a set of them.
Similarly, the edits of contributors can be categorized according to their type and complexity. For example, simpler ones can be spelling and punctuation correction and text formatting, while complex ones typically include new content introduction, content substitution, whole article re-structuring, etc. Wikichron could visualize the evolution of the different kinds of contributions. First, a taxonomy needs to be created according to the literature on wiki collaboration. Then the parser has to be extended to count their appearances through time and then the edit history should be properly represented in WikiChron.
This project would require knowledge of Python. Experience in plotly, Pandas and ReactJS is a plus. Interest or experience in data visualization and fancy plots is also a plus.
Mentors: Javier Arroyo javier.arroyo@fdi.ucm.es, Abel Serrano Juste abeserra@ucm.es