OWL Exercises

This time the exercises are exceptionally formulated in German as the ontology to be developed deals with the area of the dining hall at e.g. the University of Lübeck.

Diese Übung befasst sich mit der schrittweisen Entwicklung einer Ontologie, die in einer Mensa z.B. unserer Universität Verwendung finden könnte. Dabei werden Klassen für die Zutaten, die Gerichte und deren Klassifikationen genauso entwickelt wie für die Besucher der Mensa. Anhand von Testanfragen kann überprüft werden, in wieweit bestimmte Fakten automatisch hergeleitet werden können.

Exercise 1

Zunächst ist es sinnvoll, eine Klassenhierarchie für Zutaten (von Gerichten) zu entwerfen. Dabei sollen die Zutaten Schweine- und Rinderfleisch, Alkohol und vegetarische sowie vegane Zutaten extra gekennzeichnet werden. Zutaten sollen über einen Namen verfügen. Die Zutat Schweinefleisch soll immer den Namen 'Schweinefleisch' tragen. Analoges gilt für die Zutaten Rinderfleisch und Alkohol. Weiterhin wollen wir Komponenten von Gerichten einführen, die Zutaten oder weitere Komponenten beinhalten können. Ein Beispiel für solch eine Komponente ist Teig. Die Beziehung istEnthaltenIn soll auf Basis der Beziehung beinhaltet eingeführt werden.

Exercise:	Start	Data	Query 1	Query 2	Query 3
Solution:	Output 1	Output 2	Output 3	In Editor	Ontology

Exercise 2

Bei den Gerichten wollen wir eine Klassifizierung in Alkoholhaltiges Gericht, Fleischhaltiges Gericht mit der Unterteilung bezüglich Schweine- und Rinderfleisch, Vegetarisches Gericht, Veganes Gericht und schonend zubereitetes Gericht. Es soll festgelegt werden, welche Arten von Gerichten sich ausschliessen. Die Art des Gerichtes soll weitestgehend aus den Arten seiner Zutaten geschlussfolgert werden können. Der Preis für das Gericht soll angebbar sein, insbesondere sollen die verschiedenen Preise für Studierende, Hochschulangehörige und Gäste unterscheidbar sein.

Exercise:	Start	Data	Query 1	Query 2	Query 3
Solution:	Output 1	Output 2	Output 3	In Editor	Ontology

Exercise 3

In diesem abschliessenden Aufgabenteil entwickeln wir eine Hierarchie für die Besucher der Mensa. Diese teilen sich nicht nur in Studierende, Hochschulangehörige und Gäste ein, sondern auch in Veganer und Vegetarier. Es soll eine Beziehung definiert werden, die die gewählten Gerichte mit den Besuchern der Mensa verknüpft, sowie Bedingungen für Veganer und Vegetarier formuliert werden.

Exercise:	Start	Data	Query 1	Query 2	Query 3
Solution:	Output 1	Output 2	Output 3	In Editor	Ontology

RIF Exercises

You may use the RIF BLD specification for solving the exercises.

Exercise 1

In the first exercise it is your task to extend the tree traversal rules of the lecture to implement a calculator which determines the result of the expression contained in the given tree. The given tree represents the expression (1 + (2-1)) * (20/2).

Exercise 2

In this exercise we want to develop RIF rules for determining all possible paths in a given graph. Furthermore, as each edge has a weight, the RIF rules should compute the total weight of the determined path.

Exercise 3

In this exercise we want to develop a RIF variant of the merge sort algorithm.

Advanced Kotlin Exercises

The slides of the lecture are not enough to solve the following exercises. You often have to consider additional information from the internet like those of https://kotlinlang.org/!

Exercise 1: Kotlin - DSL

Write a Domain Specific Language (DSL) for relational algebra expressions. An example of its usage is

val q4 = query {
    projection("A.a", "D.d") {
        union {
            table("A")
            table("B")
            join {
                table("C")
                table("D")
            }
        }
    }
}
println(q4)

table("A") represents a relational table with name "A". union and join can have two or more operands. projection and query can have exactly one operand. If the number of operands is different, then an exception should be thrown (via: throw Exception("message")). Furthermore, you can specify an arbitrary number of attributes with projection. For an arbitrary number of parameters of a function, please consider this link.In this exercise your task is to develop Kotlin code with which one can specify such relational expressions (without providing code to execute the specified relational expression).

Exercise:	Start		Code
Solution:	Output	In Editor	Code

Exercise 2: Kotlin - Iterator

Please develop iterators to compute prime numbers. Please develop a) a variant using an iterator generator and b) in another variant an iterator class.

Exercise:	Start		Code
Solution:	Output	In Editor	Code

Map/Reduce - Rel. Algebra Exercises

The exercises are mainly about realizing the processing of SPARQL queries in hadoop and its map/reduce framework. For this purpose, we provide the SPARQL queries in the exercises.

Exercise 1: Map/Reduce - Mr. Magic Sets

Your first query contains only one triple pattern and returns the blank node from which all information about Mr. "Magic Sets" is accessible. A corresponding SPARQL query looks like:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT *
WHERE { 
        ?person foaf:name "Magic Sets" .
}

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Start.kt
Solution:	Output	In Editor		Query1.kt

Exercise 2: Map/Reduce - Information about Mr. Magic Sets

More complex queries need processing a join: Your second query should return all available information about Mr. "Magic Sets". A corresponding SPARQL query looks like:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT *
WHERE { 
        ?person foaf:name "Magic Sets" .
        ?person ?p ?o .
}

In this exercise you should spend two parallel jobs for processing each of the triple patterns. One succeeding job should then evaluate the join result.

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Start.kt
Solution:	Output	In Editor		Query2.kt

Exercise 3: Map/Reduce - Information about Mr. Magic Sets in an optimized way

In this exercise you should optimize the solution of the previous exercise by only using one job for all - processing of the triple patterns and joining their results. This is a good example to show that many steps can be integrated in one job, but this may need careful design of the mapreduce program.

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Start.kt
Solution:	Output	In Editor		Query2Optimized.kt

Pig Exercises

You may use the pig documentation for solving the exercises.

For the first three queries, we provide the corresponding SPARQL queries, which should be transformed into pig script. From the fourth query on, we provide the query on this webpage only in natural language. Only if you need additional help, you may use the links to show the corresponding SPARQL query. Your task is to develop pig scripts working on the provided data. Note that the queries are the same as in the Hive tutorial.

Exercise 1: Pig Latin - Information about Mr. Magic Sets

Your first query should return all available information about Mr. "Magic Sets". A corresponding SPARQL query looks like:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT *
WHERE { 
        ?person foaf:name "Magic Sets" .
        ?person ?p ?o .
}

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 2: Pig Latin - Email addresses of all persons

The second query should return information about email addresses of all persons in the given rdf graph. A corresponding SPARQL query looks like:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?name ?mbox
WHERE {
  ?person foaf:name ?name .
  {
      { ?person foaf:mbox ?mbox } 
      UNION
      { ?person foaf:mbox_sha1sum ?mbox }
  }
}

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 3: Pig Latin - All persons and their depictions if available

The result of the third query should contain all persons in the given rdf graph and their depictions if available. A corresponding SPARQL query looks like:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?name ?depiction
WHERE { 
        ?person foaf:name ?name .
        OPTIONAL {
            ?person foaf:depiction ?depiction .
        }
}

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 4: Pig Latin - Jo Foo's friends

Develop a query to answer who knows "Joe Foo"? (Who are the friends of "Joe Foo"?)

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 5: Pig Latin - Friends of Jo Foo's friends

Who are the friends of the friends of "Joe Foo"?

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 6: Pig Latin - EMail-addresses of friends of Jo Foo's friends

What are email-addresses of the friends of the friends of "Joe Foo"?

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 7: Pig Latin - Person knowing someone not knowing him/her

Person A knows at least one person B, who does not know A. Develop a query to find such persons A.

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 8: Pig Latin - Having unknown friends

Person A knows at least one person B, who does not know A. Develop a query to find such persons B.

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Exercise 9: Pig Latin - All at once

Multi-Query: Ask for the results of all above queries in one pig script. Do not compute any intermediate result more than one time.

Exercise:	Start		Data	Script
Solution:	Output	In Editor		Script

Flink Exercises

The exercises are using the DataSet API and the SQL API. You may use the Flink documentation during your exercises.

Exercise 1: Flink/DataSet API - Mr. Magic Sets and his friends

Please compute the result of the "friend query" with the use of DataSet API, which determines all information about "Magic Sets" and the names of his (direct) friends. A corresponding SPARQL query looks like:

SELECT *
WHERE {
 ?magic_s <http://xmlns.com/foaf/0.1/name> "Magic Sets".
 ?magic_s ?foo_p ?foo_o.
 ?magic_s <http://xmlns.com/foaf/0.1/knows> ?friend_s.
 ?friend_s <http://xmlns.com/foaf/0.1/name> ?friend_name.
}

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	FriendQueryWithDataSet.kt
Solution:	Output	In Editor		FriendQueryWithDataset.kt

Exercise 2: Flink/SQL API - Mr. Magic Sets and his friends

Please compute the result of the "friend query" with the use of SQL API, which determines all information about "Magic Sets" and the name of his (direct) friends. A corresponding SPARQL query looks like:

SELECT *
WHERE {
 ?magic_s <http://xmlns.com/foaf/0.1/name> "Magic Sets".
 ?magic_s ?foo_p ?foo_o.
 ?magic_s <http://xmlns.com/foaf/0.1/knows> ?friend_s.
 ?friend_s <http://xmlns.com/foaf/0.1/name> ?friend_name.
}

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	FriendQueryWithSQL.kt
Solution:	Output	In Editor		FriendQueryWithSQL.kt

Flink - Stream Exercises

The exercises are using the DataStream API. You may use the Flink documentation during your exercises.

Exercise 1: Flink/DataStream API - Minimum of stream of sensor values

The given code prepares a stream of sensor values simulating e.g. a soft temperature rise.

Please compute the minimum of the temperatures in a sliding count window of size 100 each time sliding 10 events.

Exercise:	Start			MinStream.kt
Solution:	Output	In Editor		MinStream.kt

Exercise 2: Flink/DataStream API - Average of stream of sensor values

The given code prepares a stream of sensor values simulating e.g. a soft temperature rise.

Please compute the average of the temperatures in a tumbling count window of size 100.

Exercise:	Start			AvgStream.kt
Solution:	Output	In Editor		AvgStream.kt

Exercise 3: Flink/DataStream API - Join of sensor streams

The given code prepares two streams of sensor values simulating e.g. soft temperature rises.

Please compute the join of the temperatures in a tumbling time window of size 2000. The join should combine the stream tuples according to the second field (containing the number of measured sensor value).

Exercise:	Start			JoinStream.kt
Solution:	Output	In Editor		JoinStream.kt

Flink - Graph Exercises

The exercises are using the graph library Gelly. You may use the Flink documentation during your exercises.

Exercise 1: Flink/Gelly - Try out Single-Source-Shortest-Path (SSSP)

Your task is just to try out the Single-Source-Shortest-Path (SSSP) example of the lecture...

Exercise:	Start		Data	SSSP.kt
Solution:	Output	In Editor		SSSP.kt

Exercise 2: Flink/Gelly - Cycle Detection

Please detect cycles in the given graph with the use of the Gelly API.

Exercise:	Start		Data	NodeCentricAlgo.kt
Solution:	Output	In Editor		CycleDetection.kt

Exercise 3: Flink/Gelly - All-Pairs-Shortest-Path (APSP)

Please solve the All-Pairs-Shortest-Path problem with the use of the Gelly API. APSP computes the shortest paths between each pair of vertices.

Exercise:	Start		Data	NodeCentricAlgo.kt
Solution:	Output	In Editor		APSP.kt

Exercise 4: Flink/Gelly - PageRank

Your task is to develop a Flink/Gelly-program for calculating the weights according to the PageRank approach.

The PageRank approach is still used today (besides other criteria) in search engines as basis for the ranking of websites. The input of the PageRank algorithm is a graph, where the (weighted) nodes represent the websites and the weighted edges between the nodes the links between the websites.

The weigths of the edges are after applying the PageRank approach as larger as more nodes (with large weights) are linked to this node. The weight G_i of a node i is calculated from the weights G_j of those nodes M_i, which are linked to the node i (i.e., which edges end in node i). If j (in M_i) is linked to c_j different nodes, then the weight of G_j is proportionally divided between these nodes. Hence one iteration of the PageRank approach can be described by the following formula for the determination of the new weight G_i of a node i:

In the given formula, d is a damping factor and n the total number of nodes.

The PageRank approach is typically processed in a given number of iterations (and sometimes based on converging ranks). In this exercise we compute the ranks of given websites only in one iteration. The input data is given in the form i G_i M_i, where the nodes in M_i are separated by commas.

Example:

Exercise:	Start		Data	PageRank.kt
Solution:	Output	In Editor		PageRank.kt

Exercise 5: Flink/Gelly - Mr. Magic Sets and his friends

Please compute the result of the "friend query" with the use of Gelly API, which determines all information about "Magic Sets" and the name of his (direct) friends. A corresponding SPARQL query looks like:

SELECT *
WHERE {
 ?magic_s <http://xmlns.com/foaf/0.1/name> "Magic Sets".
 ?magic_s ?foo_p ?foo_o.
 ?magic_s <http://xmlns.com/foaf/0.1/knows> ?friend_s.
 ?friend_s <http://xmlns.com/foaf/0.1/name> ?friend_name.
}

Semantic Web:	In Editor	Output	Data	Query
Exercise:	Start		Data	NodeCentricAlgo.kt
Solution:	Output	In Editor		FriendQueryWithGelly.kt

CSS Exercises

The slides of the lecture are not enough to solve the following exercises. You often have to consider additional information from the internet! Especially look at CSS3 selectors and CSS4 selectors.

Exercise 1: CSS - Table

Please look at the rendered solution and try to write css code such that the html table is rendered exactly the same as in the solution!

Exercise:	Start		Page
Solution:	Output	In Editor	Page

Exercise 2: CSS - Absolute Positioning (Deprecated)

Please look at the rendered solution and try to write css code such that the site is rendered exactly the same as in the solution!

Exercise:	Start		Page
Solution:	Output	In Editor	Page

Javascript Exercises

The slides of the lecture are not enough to solve the following exercises. You often have to consider additional information from the internet!

Exercise 1: JS - Interactive Forms

In this exercise we develop an interactive form about job experiences, which may be part of a job application form. Depending on the type of job chosen different input possibilities should be given (for the cook the number of stars and his/her specialties, for the software developer his/her homepage and his/her programming languages, for all a field for notes). Furthermore, it should be possible to add more job experiences. Again please try the rendered solution to find out how the interactive form could look and behave like.
You can use the javascript function element.insertAdjacentHTML(A, '<p>new paragraph</p>'); to add new html code (here a new paragraph) right before/after the (opening) tag of element (A is 'BeforeBegin'/'AfterBegin') or before/after the closing tag of element (A is 'BeforeEnd'/'AfterEnd').

Exercise:	Start		Page
Solution:	Output	In Editor	Page

Exercise 2: JS - Duck Shooting (Deprecated)

Please write a simple game. The goal of the game is to shoot the black duck as often you can in one minute. However, do not shoot the yellow ducks! You will get a penalty in this case. You can play the game of the rendered solution for getting an idea how it could look like. We encourage you to develop this game further and send us your solution!
In Javascript a function is called every X milliseconds by using var myInterval = setInterval(function () {...}, X); You can stop this with window.clearInterval(myInterval);
The width of your current viewport can be determined by document.documentElement.clientWidth. You can set the x-position of the duck image to 100 px with duck.style.left = '100px'; (duck must contain the corresponding img tag). duck.offsetLeft determines the current position of the duck.
You can use the audio files ente.mp3 and failed.mp3 to play a sound of success and of the penalty respectively.

Exercise:	Start		Page
Solution:	Output	In Editor	Page

JQuery Exercises

The slides of the lecture are not enough to solve the following exercises. You often have to consider additional information from the internet!

Exercise 1: JQuery/AJAX - Page-wise CV

This time we want to have a page-wise version of our duck CV: There are four buttons on the sidebar with which the user can choose a page of the duck CV. After pressing on one of the buttons, the old page is faded out, the new page is loaded from the server and faded in. You can render the solution for an example how it could look like.
You can access the server under the url page.php. The server requires a parameter page set to 1, 2, 3 or 4. The server returns the html code for the different pages. For any invalid input, the server returns the string Server: invalid input!.
Furthermore, the buttons for active pages should be disabled.

Exercise:	Start		Page
Solution:	Output	In Editor	Page

Exercise 2: JQuery - Paginator (Deprecated)

In this exercise we want to implement a paginator. With the help of a paginator, a user can easily choose a page, navigate to the next, previous, first and last page. Furthermore, if not all page numbers can be displayed, the paginator shows only those nearby the current active page. The paginator should be responsive, i.e. resizing the window adapts the paginator, such that always as many page buttons are shown as possible. Also the page button over the mouse pointer should be marked (implementing the hover-functionality) as well as the active page.
You can render the solution for an example how it could look like. Please play around with the window sizes to check the responsive capabilities of the solution.
In the given code of the exercise, a canvas is used in which the paginator is drawn. The example code already gives you some entry points by adding some event handlers whenever the window is resized, the user clicks into the paginator or moves its mouse. By collecting the page buttons to be drawn in the array currentButtons using objects of type DrawObject it is possible to have all information at hand. Drawing those objects of type DrawObject is also already given. Have fun!

Exercise:	Start		Page
Solution:	Output	In Editor	Page