See all articles

20th RRUG meeting report - full-text searching and app architecture

We’re happy to report that we participated in another successful RRUG meeting. During this one, two interesting topics were discussed: full-text searching, and IT systems architecture.

Full-text searching

The first presentation was delivered by Maciej Rząsa. To start of, he used some simple examples of how you can introduce the full-text search functionality into the code of your app - and why these ideas (which involve matching text fragments with SQL and regular expressions) are actually terribly inefficient. Next, Maciej explained the idea of text tokenization, paying attention to the simplest way of implementing it and how it helps with full-text searching.

Maciej also covered the normalization of tokenized texts. It’s an important process that can improve searching and make it less vulnerable to user error. The idea of text analysis was explained as a combination of tokenization and normalization. This concluded the theoretical part of the presentation.

The practical part involved letting the audience get familiar with text analyzers used in Elasticsearch. We saw examples of simple text analyses, breaking texts down into tokens, and normalization in Elasticsearch. We learned what the search result score is and what methods can be used to calculate it. The final part of the presentation was focused on how to apply what we’ve learned in practice - to build an autocomplete system for digital questionnaires and forms.

IT system architecture

The author of the second presentation was Paweł Janusz, a specialist from the JEE environment with many years of experience. He spoke about the broad subject of architecture, but focused on the most crucial aspects of it, such as:

  • What is architecture?
  • What’s its purpose?
  • What are the most popular architectural solutions?
  • How to effectively introduce changes to architecture?

Paweł divided architecture into the following levels: system, container, component, and code. A particularly valuable element of his presentation was a section on differentiating between available architecture types, from no architecture, through layered architecture with a classic database, an event-based architecture based on queues, to microservices and serverless. Each approach was described with attention to its advantages and disadvantages.

An important tip regarding introducing architectural changes was emphasizing the need to conduct an event storming, which allows for a better identification of barriers (bounded contexts) in the system under construction. Paweł also shared three good practices to keep in mind while reworking an architecture:

  • Building systems with the knowledge that their architectures are likely to require change;
  • Consulting architectural decisions with the entire development team, SysOps team, and business stakeholders;
  • Introducing changes slowly and iteratively.

A good architecture supports a high level of efficiency and productivity, is easy to maintain and scale, and is secure and reliable. Using these principles and good practices, it’s much easier to create well-designed architectures.

If you missed out on the recent RRUG meeting, keep an eye out for announcements about the next one. Meetings are held regularly and cover many interesting topics related to Ruby and software development.

Would you like to work with a software development team that’s focused on growth, learning and taking on amazing challenges? Check our vacancies.

Read Similar Articles