---
title: Posts tagged GhentCDH
canonical: https://0110.be/tags/GhentCDH
markdown_url: https://0110.be/tags/GhentCDH.md
page: 0
posts_per_page: 30
total_posts: 7
filters:
tag: GhentCDH
previous:
next:
---
# Posts tagged GhentCDH
## [Sampo-UI Meets Ontop: Publishing Relational Digital Humanities Data - Semantics 2026](https://0110.be/posts/Sampo-UI_Meets_Ontop%3A_Publishing_Relational_Digital_Humanities_Data_-_Semantics_2026.md)
- Published: 2026-09-16T00:00:00Z
- Updated: 2026-09-16T07:46:02Z
- Author: Joren
- ID: 582
- Canonical: https://0110.be/posts/Sampo-UI_Meets_Ontop%3A_Publishing_Relational_Digital_Humanities_Data_-_Semantics_2026
- Tags: [Code](https://0110.be/tags/Code.md), [GhentCDH](https://0110.be/tags/GhentCDH.md), [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
The [SEMANTiCS conference](https://2026-eu.semantics.cc/) took place in Ghent from 15 to 17 September 2026. Our contribution was a collaboration between GhentCDH and the Semantic Computing Research Group at Aalto University on publishing humanities data with Sampo-UI and Ontop.
> *[Sampo-UI Meets Ontop: Publishing Relational Digital Humanities Data on the Semantic Web](https://0110.be/files/attachments/582/semantics-poster-sampo-ui.pdf)*, Joren Six¹, Jahid Chetti¹, Annastiina Ahola², Frederic Lamsens¹, Heikki Rantala², Eero Hyvönen²
> ¹ Ghent University, Ghent Centre for Digital Humanities ([GhentCDH](https://www.ghentcdh.ugent.be))
> ² Aalto University, Department of Computer Science, Semantic Computing Research Group ([SeCo](https://seco.cs.aalto.fi))
At GhentCDH, we often publish research datasets in the digital humanities. Several projects need similar search filters, map visualizations and data exports. Sampo-UI makes it possible to reuse these components when the data is available as Linked Data. In collaboration with the original Sampo-UI team, we worked on modernizing the framework. Our first contribution separates the shared core from project-specific configuration, making updates and reuse more manageable. The second uses Ontop to expose existing *relational databases* through a SPARQL endpoint. This lets us use Sampo-UI while keeping the database infrastructure and tooling we already have. Having one fewer database system to maintain is welcome.
> **Abstract**: *The Sampo model and its Sampo-UI framework have become an established approach for publishing Cultural Heritage and Digital Humanities data on the Semantic Web. Sampo-UI enables exploration of data originating from SPARQL endpoints through faceted search across multiple views with seamlessly integrated visualization and data analytic tools. Here, we present two contributions to the Sampo-UI ecosystem: (i) a separation of Sampo-UI core from application-specific configuration; decoupling core and application simplifies updates and facilitates reuse of efforts, and (ii) the use of Ontop --- a virtual knowledge graph system --- to expose relational databases through a SPARQL endpoint and Sampo-UI. The use of relational databases and reuse of tooling and expertise around relational databases lower the operational burden of publishing small-to-medium-sized datasets typical of digital humanities projects. These contributions originated outside the original Sampo-UI team but were developed in collaboration with it, and are being prepared for upstream integration. We illustrate the approach with two projects at Ghent University: one on Roman coin finds in Belgium (NuMAD) and one on historic Belgian company data (BelHisFirm). Both portals run the same Sampo-UI core with a different configuration, and operate on existing institutional relational database infrastructure without a dedicated graph database.*
The demo below shows the NuMAD portal for exploring Roman coin finds in Belgium through the modernized Sampo-UI. Another [demo presents historical records of Belgian companies](https://0110.be/files/attachments/582/belhisfirm_demo.mp4) through the BelHisFirm portal. Both portals run the same Sampo-UI core with different configurations, demonstrating the flexibility of the system.
Alongside the [Sampo-UI Meets Ontop paper](https://0110.be/files/attachments/582/sampo-ui_ontop-semantics_2026.pdf), a [conference poster on Sampo-UI](https://0110.be/files/attachments/582/semantics-poster-sampo-ui.pdf) that I prepared is also available.
Video: NuMAD — exploring Roman coin finds in Belgium.
---
## [ Introduction to Sampo-UI at FedOSC Linked Open Data Visualisation Workshop](https://0110.be/posts/_Introduction_to_Sampo-UI_at_FedOSC_Linked_Open_Data_Visualisation_Workshop.md)
- Published: 2026-09-08T00:00:00Z
- Updated: 2026-09-08T12:02:58Z
- Author: Joren
- ID: 583
- Canonical: https://0110.be/posts/_Introduction_to_Sampo-UI_at_FedOSC_Linked_Open_Data_Visualisation_Workshop
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
FedOSC, the Belgian Federal Open Science Cloud, supports open science and research data management at Belgium's federal scientific institutions. On 8 September 2026, it organised a [day on data visualisation and Linked Open Data](https://fedosc.miraheze.org/wiki/Events/DataViz) at KIK-IRPA in Brussels, with talks, demos and a approaches on cultural heritage datasets.
My contribution to the closing talks was an introduction to Sampo-UI, an open-source framework for building search and visualisation interfaces on top of Linked Open Data. I explained why we use it at the Ghent Centre for Digital Humanities: several projects need similar filters, maps and data exports, so it makes sense to reuse a common framework. The presentation covers how Sampo-UI works, our contributions to it, and a practical example with the NuMAD coin database.
The [Sampo-UI presentation](https://0110.be/attachment/cors/2026.09.08-sampo-ui-fedosc-brussels/index.html) is available online and embedded below.
---
## [GhentCDH at the Faculty Research Day](https://0110.be/posts/GhentCDH_at_the_Faculty_Research_Day.md)
- Published: 2024-11-27T00:00:00Z
- Updated: 2024-11-27T10:07:51Z
- Author: Joren
- ID: 551
- Canonical: https://0110.be/posts/GhentCDH_at_the_Faculty_Research_Day
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [Presentation](https://0110.be/tags/Presentation.md), [UGent](https://0110.be/tags/UGent.md)
The [research day of the faculty of Arts and Philosophy of Ghent University](https://www.lwresearchday.ugent.be/) took place last November. The theme of the day was ‘*From Source to Understanding*’ and the program gave an overview of the breadth of research at our faculty with topics as logic, history, archeology, chemistry, geography, language studies, ... There were several contributions by our group: the Ghent Center for Digital Humanities. The contribution by me and my close colleagues [was a poster about a reusable text annotation](https://0110.be/files/attachments/551/poster_text_annotation.webp) building block.
Fig: Poster on a text annotation component.
At GhentCDH we support several text annotation projects and have extracted a text annotation component for reuse. The abstract reads:
> "*Text annotation is essential for analyzing ancient texts, identifying entities in texts, or documenting evolving grammar. There is a need for reusable annotation methods which copes with challenges such as overlapping annotations, filtering annotation types, and enabling large-scale collaboration and computational analysis on text annotation work.*
>
> *We present a reusable text annotation component built with TypeScript and Vue 3. It provides an intuitive interface for creating, visualizing, and editing annotations, it allows component users to enrich annotations with complex metadata, and facilitates flexible annotation filtering. This solution meets many needs of researchers in digital humanities and ancient language studies and will be used in several GhentCDH projects.*"
Get more info, try it out and use it in your project by checking the [text annotator source code repository](https://github.com/GhentCDH/vue_component_annotated_text).
---
## [Offloading authentication and user management to Keycloak - A minimal example with Nuxt and Litestar](https://0110.be/posts/Offloading_authentication_and_user_management_to_Keycloak_-_A_minimal_example_with_Nuxt_and_Litestar.md)
- Published: 2024-03-13T00:00:00Z
- Updated: 2024-03-19T09:13:26Z
- Author: Joren
- ID: 542
- Canonical: https://0110.be/posts/Offloading_authentication_and_user_management_to_Keycloak_-_A_minimal_example_with_Nuxt_and_Litestar
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [UGent](https://0110.be/tags/UGent.md)
At the [Ghent Center for Digital Humanities](https://www.ghentcdh.ugent.be/) we provide software services for researchers. Think about, for example, annotation platforms for ancient texts or collaborative databases with geographically referenced historical data. Each of those services need some kind of authentication and user management: some parts of the service might be public, some only accessible for researchers at Ghent University and other parts need to be accessible e.g. to external researchers or collaborators. Providing authentication, login-flows and user management for each and every service quickly becomes tedious and, frankly, boring.
We went looking for a solution and stumbled on [Keycloak](https://www.keycloak.org/). Keycloak is an open source __Identity and Access Management__ system and is able to either authenticate users itself or pass through authenticate to other authentication providers like LDAP, GitHub, OAuth accounts, or others. It avoids the need to setup application-specific user management system. Flows like 'forget password', 'verify email', 'two factor authentication' are not part of your application itself but are provided by Keycloak. Leaving the developer to focus on application specific tasks.
Video: An API call to a protected back-end first fails. After authentication and receiving a JWT token, the back-end call succeeds. The authenticated session is then shown in Keycloak.
Integration with Keycloak is a bit of work and not straightforward. As part of trying out Keycloak I have created a [minimal working example of a front-end / back-end system which uses Keycloak for authentication](https://github.com/GhentCDH/nuxt-keycloak-jwt-auth/). To get full access to the back-end API the user first needs a valid JWT-token provided by Keycloak. The flow can be seen in the video above. The dockerized environment can perhaps serve as inspiration for similar setups. Please do try out the [dockerized minimal working example](https://github.com/GhentCDH/nuxt-keycloak-jwt-auth/) and see if Keycloak can fit your use-case.
---
## [Containerized development - Dockerized Python database development](https://0110.be/posts/Containerized_development_-_Dockerized_Python_database_development.md)
- Published: 2024-01-22T00:00:00Z
- Updated: 2024-01-22T10:31:50Z
- Author: Joren
- ID: 540
- Canonical: https://0110.be/posts/Containerized_development_-_Dockerized_Python_database_development
- Tags: [GhentCDH](https://0110.be/tags/GhentCDH.md), [UGent](https://0110.be/tags/UGent.md)
Fig: Containerized development.
At the [Ghent Center for Digital Humanities](https://www.ghentcdh.ugent.be/) (GhentCDH) we offer IT-services mainly for researchers in the Humanities at Ghent University. The services range from internal collaborative research tools to publicly facing science communication platforms. Technically, it is a mix of off the shelve software with or without modifications and custom solutions using several technical stacks. It is a challenge to keep these services running, secure and up-to-date for years with a limited budget.
In an attempt to make maintenance of these services more manageable we are in the process of [containerizing](https://en.wikipedia.org/wiki/Containerization_(computing)) our software. __Running software in containers has advantages__. One of the advantages is a guaranteed consistency across environments. Also, isolated software containers can be beneficial for security and stability. It also allows one to run different versions of a stack on the same server without running into compatibility problems.
Next to running software in containers, __development in containers also has advantages__. It allows you to switch projects easily without needing to install dependencies - e.g a specific database system version - directly on a development machine. The main advantage I see is that containerization promotes developer hygiene. Stereotypically, developers do not have the best hygiene and can use any available help. Containerization forces developers to think about separation of code and configuration, code and data and it forces to be explicit about dependencies and environmental assumptions.
The main disadvantage is that some configuration is needed to get the containers running and that there is a small performance penalty. The following might help with that first part.
## Dockerized Python database development
To put the theory to the test my colleagues and I put together a [GitHub repository with a dockerized Python development setup](https://github.com/GhentCDH/Python-db-dev). It shows interaction between Python and a PostgreSQL database. The database system runs in a container and the development environment is also kept in a container. Both containers are started with `docker compose` and configured via a `.env` file.
The stack uses a recent Python version, [PDM](https://pdm-project.org/latest/) to resolve Python dependencies and SQLAlchemy to interact with the PostgreSQL database. The VS code editor allows developers to __run and debug software in a container__. The video below shows the startup procedure and setting a breakpoint in some Python code.
Vid: Starting a database server and development container. Running and debugging Python code in a container.
Note that this is just an example setup, your setup might look quite different. You might need a different stack, use a different container environment (e.g. podman) or IDE but the principle of container based development could stay the same.
I have put off using containers for quite a while and I am quite a late convert, but now that I am doing more technical work in a small team I do see the advantages of an easy-to-set up, controlled, containerized development with explicitly defined dependencies. If you have no experience with containers yet, I would encourage you to at least __try container based development__ out and see where it could help you!
---
## [Printing a part of the world - a 3D-printed cityscape](https://0110.be/posts/Printing_a_part_of_the_world_-_a_3D-printed_cityscape.md)
- Published: 2024-01-09T00:00:00Z
- Updated: 2025-11-13T22:55:02Z
- Author: Joren
- ID: 537
- Canonical: https://0110.be/posts/Printing_a_part_of_the_world_-_a_3D-printed_cityscape
- Tags: [0110.be](https://0110.be/tags/0110.be.md), [GhentCDH](https://0110.be/tags/GhentCDH.md), [UGent](https://0110.be/tags/UGent.md)
Fig: 3D printing your part of the world.
My ex-girlfriend and current wife likes maps. While looking for a gift for the new-years I got the idea to give her a 3D map of the nearby [historic city center of Ghent with its three iconic towers](https://earth.google.com/web/@51.05385689,3.72537111,16.45165093a,593.4748548d,35y,19.92318437h,59.99406466t,359.99999999r/data=OgMKATA). I have a 3D printer at home but still need to find a printable 3D model of Ghent.
Luckily, a couple of days ago a piece of software appeared to [capture Google Earth tiles -cubes- into a single 3D file](https://github.com/OmarShehata/google-earth-as-gltf). There you can select an area of interest via google maps and download a GLTF file which captures the landscape in 3D. The software needs an API key which can be requested via the Google Developer tools.
After downloading a GLTF file, the 3D model needs to be made 3D-printable. There are online [GLTF to STL converters](https://products.aspose.app/3d/conversion/gltf-to-stl) but a bit of care needs to be taken to end up with an actually **printable** STL. My selected area of interest only has slight height differences in the landscape which are handled by placing the STL file on a base which compensates for these differences. Your 3D slicer can also generate structure to support inclinations in the landscape.
The 3D model generated by Google Earth is quite noisy and can contain floating parts and holes. It may be needed to edit the STL mesh directly. Selecting a slightly shifted area of interest may also solve problems with the edges of the print: take care to chop less buildings in two.
Have fun printing your own piece of the world!
Fig: a 3D model for the Ghent city center visualized with an Three.js STL viewer.
---
## [Look, Ma! No Javascript! A case against the overuse of Javascript](https://0110.be/posts/Look%2C_Ma%21_No_Javascript%21_A_case_against_the_overuse_of_Javascript.md)
- Published: 2023-12-20T00:00:00Z
- Updated: 2023-12-21T07:59:13Z
- Author: Joren
- ID: 534
- Canonical: https://0110.be/posts/Look%2C_Ma%21_No_Javascript%21_A_case_against_the_overuse_of_Javascript
- Tags: [Code](https://0110.be/tags/Code.md), [GhentCDH](https://0110.be/tags/GhentCDH.md), [UGent](https://0110.be/tags/UGent.md)
Fig: Hammer vs. screw. Not the right tool for the job.
For the last couple of years this blog has not been using any Javascript. During the last decade this has become quite rare. Only [1.2% of websites do not use Javascript](https://w3techs.com/technologies/details/cp-javascript) I see this as a problem. In this text I want to argue that Javascript is perhaps not always the right tool for the job. Especially for web-pages which visitors simply want to read and where *no explicit interactive actions* are wanted from a user perspective, I see Javascript as detrimental.
I was triggered to write this by a few observations. One is by a Rails frontend framework which claims that [*"the only technology we should be using to create web UI is JavaScript"*](https://github.com/rage-rb/rage). This implies that the whole DOM should be rendered by Javascript. On the other hand there are frameworks which now advertise server side rendering as new feature like [Blazor](https://community.devexpress.com/blogs/aspnet/archive/2023/12/13/blazor-new-net-8-render-modes-v23-2.aspx) and [Nuxt](https://v2.nuxt.com/docs/concepts/server-side-rendering/). The old thing is new again.
Let's look at a few examples. Take visiting news website. On a news site, a user expects to be able to read current news, reviews, opinions, .. and there is no expectation of interactivity. Basically, a news site could work equally well on physical paper, as was the case for the last century or more. Ideally, a news site is a static HTML page with an easy to follow layout and some images, perhaps some static ads, with information flowing in a single direction.
If we look at, for example, the Guardian, we do not get this ideal experience, instead 82 Javascript files are loaded and the full website takes six full seconds to load on a fast fiber connection. The site even tries to load files from other domains. This bloat results in 8 website programming errors and [CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing)-issues. The Guardian website is far from the worst example of this sprawl of Javascript, the [front-end for the Guaridan](https://github.com/guardian/frontend) is even developed in the open.
Another news site is [Hacker News](https://news.ycombinator.com/). With its focus on Sillicon valley and technical news, this site has probably one of the most tech-savvy readers and ... it does not rely on Javascript for functioning. There is a [single small, **readable** 150 line script](https://news.ycombinator.com/hn.js) to improve usability but that is it. The makes the the website fast, easily indexable, straightforward to maintain, accessible, future-proof, failsafe, and compatible with even the most basic browsers and screen-readers.
Similarly, this blog is a dynamic [Rails](https://rubyonrails.org/) site but thanks to extensive use of server-side rendering and caching it behaves more like a static site generator: once everything is cached, the application mostly serves static HTML fragments. The client-side requirements are minimal as well: since no Javascript is used to modify the DOM - or even at all - lay-outing is straightforward.
Note that some blog posts feature advanced web *application* prototypes which do use a boatload of Javascript e.g. to [convert audio](https://0110.be/posts/An_audio_focused_ffmpeg_build_for_the_web), [visualize audio](https://0110.be/posts/Gabber_-_Visualizing_constant-Q_transform_in_the_browser), [interact with micro-controllers or MIDI instruments](https://0110.be/posts/mot_-_MIDI_and_OSC_Tools_-_Sending_UDP_messages_from_the_browser),... . These prototypes use many of the available browser APIs like the Web Audio API, WebAssembly, Web MIDI API, Web Bluetooth API, WebGL, .... I really do like targeting modern browsers with offer many possibilities to build easy-to-use *applications*. But that is exactly a distinction that needs to be made: *applications versus pages*. Javascript versus No Javascript.
---
