DEV Community: Alexis Pavlidis

How I keep up with software

Alexis Pavlidis — Sat, 13 Mar 2021 10:39:49 +0000

Intro

The software industry is really dynamic and it requires a lot of effort to keep up with the latest trends. Basically, there is no end to learning in the IT industry. One of the most important skills that a software engineer must have is the way of staying up to date with the latest updates. I'm often asked how I keep up with the trends in the field of software engineering, and how I learn new stuff. Undeniably an important part of learning is practice. I still remember Uncle Bob`s quote in the Clean Coders book

It is not your employer's responsibility to make sure you are marketable. It is not your employer's responsibility to train you, or send you to conferences, or buy your books. These things are your responsibility. You should plan on working 60 hours a week. The first 40 are for your employer. The remaining 20 are for you. During this remaining 20 hours you should be reading, practising, learning, and otherwise enhancing your career.

Saying that I thought writing a blog post will give some guidelines to people that are finding it hard to follow up with software or want to discover other alternatives of learning.

Podcasts

Podcasts are a great way to learn new stuff and keep up with trends. I`ve been listening to podcasts since I was an undergrad and it's been an important way of learning for me. I used to listen to podcasts during my commute but nowadays working remotely I will probably do it in parallel with another activity. I prefer podcasts that are less than an hour because it does not require a lot of time commitment.

Books

Reading books seems kinda outdated. But books have been an important way of my learning process. If you want to explore a technical topic in-depth, then books are an excellent choice. Yes, the industry evolves incredibly fast, but certain books will help you explore your field of work on a much deeper level. The most influential thing throughout my career was reading Clean Code by Uncle Bob. I read that book while I was in the second year of my studies and it completely changed my mindset about software. Back then I did not know who Uncle Bob was, so after googling I learnt about Martin Fowler, Kent Beck, Grady Booch, Jim Coplien and all the well-known people in the software industry. This of course helped me create a backlog of books that I had to read since some of those books are "must-reads" for all software engineers regardless of their experience.

Here is my notion page of Books that I've read or about to read soon:

Attend Events

Conferences and meetings are an excellent way to follow new trends. Many new products and developments in the IT realm are presented at conferences and meetups. One of the most important benefits of such events is the ability to meet new people from the software industry and make valuable contacts. It's also a great way of discussing software, exchanging ideas with people that work in different domains/companies with different dynamics. Some of the events I would recommend attending are the following.

Conferences

Meetups

I`ve met great people throughout my participation in those events and they helped me massively with my career progression. I feel really lucky that I had the chance to participate in such events which boosted my knowledge.

Practice

Whenever I learn a new technology, tool, or programming language I will always use Stack Overflow to verify my knowledge and try to answer questions regarding the new topic. One of the best ways to learn something is using the Feynman Technique where you try to explain in a simple way solutions to other people's problems. Answering questions in Stack Overflow helps me a lot construct my thoughts and potentially find gaps in my explanation. A second benefit of using Stack Overflow when learning a new subject is that you can quickly get a good essence of the common issues and problems other devs are facing regarding that subject. Another good way of practising a new topic I am learning is by doing code katas.

A code kata is an exercise in programming which helps programmers hone their skills through practice and repetition.

Code katas are an excellent way of practising a new tool, library, concept, programming language, or a new design technique. It's a practice session where the goal is not only to solve the problem but to practice and sharpen your skills during the process of solving it. You can find some of the katas I have solved in my GitHub account here.
There are two websites I use for finding katas:

One thing to note here is that pairing is extremely useful when solving code katas or working on side project. I strongly recommend working on a team so you can share tips, resources and experience.

Online Courses

Software is an industry where most of the information is publicly available through the internet. There are a huge number of tutorials that can help you learn new stuff. Tutorials are a great way of learning by doing, which for me is an effective technique of learning. Online education is really popular in our industry due to its low cost, and time-saving advantages. Besides, experience beats theory most of the time - so combining both is probably a more effective way of learning. These are the platforms I am using:

Youtube has a lot of good tutorials as well but compared to the above mentions the quality on average is much lower but there are exceptions.

Have a plan

Keeping up with software is certainly a hard task. Things do change constantly at a fast pace. The amount of information we as software engineers consume every day is huge and keeping track of everything is really difficult. Having a plan or a list of topics you want to learn can be quite helpful. I`ve been using tools as my second brain to help me structure all this information. To be honest I had a hard time finding a good tool to fulfil that purpose. I used Trello, Asana, Miro, Google Keep, Evernote but nothing quite worked for me.

Last 3 months I've been using Notion as my second brain tool and it's been an awesome experience. Notion has components for notes, kanban boards, wikis, databases, calendars etc. By connecting those components you can create systems for knowledge, data and project management. Here you can see my dashboard for the software section. I have subpages to each one of those pages but you probably get the idea. Everything new that I might need to read later, will go to the Reading List. If I have an idea of a project, or a blog post it will add that to Ideas and so forth.

Another useful resource I used throughout the years is the roadmap.sh. It's been a great guide for me to pick up the next topic I want to learn especially when I was more junior and I was overwhelmed by all the different topics under the software umbrella.

Other ways of following trends

The following list is resources that I don't heavily rely on and it's more like optional ways for me for learning new stuff.

Surveys - Surveys are great for giving you insights into the trends in software. In my opinion Stack Overflow Survey is by far the best one related to software.
Follow People that Talk about Tech
GitHub Explore
Newsletters: HackerNews, TLDR
Certifications: AWS Cloud
Competitions: HashCode, IEEEXtreme

Final Thoughts

The world of IT is changing regularly and hence you have to evolve as IT evolves. Staying ahead of the competition and on top of your game requires a formidable effort. A final suggestion would be to read, practice, repeat.

How to support filters to your restful APIs with Spring Data MongoDB

Alexis Pavlidis — Wed, 20 Nov 2019 18:00:01 +0000

Introduction

Writing truly Restful APIs is not simple. There are a lot of features that need to be covered to call an API restful. One aspect of those features is providing parameters to filter and manipulate the data of a resource. Two months ago I was practicing my TDD skills, and I decided to build a simple blog engine using Spring Boot + Spring Data MongoDB (technologies that I never used before). So I got to a point that I needed to support filtering, selecting, sorting and pagination. I realized there was nothing "simple" that I could use, so I build a custom solution and published it on the Maven Central Repository.

Concept

We will build an endpoint that supports filtering, selecting, sorting and pagination using Spring Boot + Spring Data MongoDB. We will build it in a way that implementing it to other controllers would be straight forward.
To support these filters we have to accept a parameter to our controller, so we have to define a RequestParam.

The paramater must be a type of Map which will represent our filters. The valid keys of the map should be sort, select, q, pageSize, page representing our different filters that can be applied to our resource.
For example to limit the results of your query you have to add the parameter pageSize with value a a number greater than or equal to 0 to the URL.

GET /blogs?pageSize=5

The pageSize parameter will be a key to our RequestParam map variable with a value the number defined to the URL.

There are two steps for implementing this.

Collect the URL parameters and pass them to the repository.
Translate the URL parameters in a way MongoDB understands.

Implementation

Let's begin by defining our Rest Controller.

After having our filters as a parameter we have to validate their existence and collect them to pass them to our service and eventually to our repository. This function should be in a separate class from our Rest Controller to be reusable to other controllers as well.

The collectRestApiParams function will accept the filters from a controller and check if there are valid keys defined as a parameter to the URL and if there are it will add them to a new map. It's responsible for collecting all parameters, so for each one, we have a separate function.
The collect functions are pretty simple, they just check if there is a valid key in the filter's map and adds it to our new map called restApiQueries.

For example the collectPageFilter checks if there is a key "page" and just adds it to restApiQueries.

The collectRestApiParams will be called from inside our Rest Controller and the returned value will be a map of valid keys to be passed to the service.

The service will delegate these filters to the repository and with that, we finished the first step: ~~Collect the URL parameters and pass them to the repository~~ ✔️

The next step is to translate these filters in a way that MongoDB understands. To do that we will use a Query object and apply MongoDB filters upon it before the database call. Our repository function looks like this:

The last missing part is the functions that are applying these filters to the query object. So let's define the functions that translate the parameters to MongoDB filters. The function applyRestApiQueries is responsible for applying all parameters to filters of the query object and should be to a separate class for reusability purposes.

This query object is received from the repository function before the database call.

Now let's write the functions that apply each parameter separately to the query object.

The applyPageQueryParam takes the value of the key "page" and applies the "skip" filter to our query object by calling query.skip(skip).

Because we are passing the query object by reference, any changes made to this object will be affected to the repository's query object as well.

The applyPageSizeQueryParam takes the value of the key "pageSize" and applies the "limit" filter to our query object by calling query.limit(limit).

The applySortQueryParam takes the value of the "sort" key which is a field name of a resource that represents the sorting field. If the field has a minus "-" symbol in front of it, it means the direction is descending otherwise it's ascending. After storing its value, we apply the "sort" filter to our query object by calling query.with(new Sort(sortDir, sortBy)).

The applySelectQueryParam takes the value of the "select" which is a string of field names of a resource separated by a comma. Then split the fields with the comma delimiter and we append each field by using query.fields().include(selectedField).

The applySearchQueryParam is the trickiest one. The value of the "q" key in the map is a JSON object, so we have to parse the JSON and pass it to the query by calling query.addCriteria(Criteria.where(field).is(value)).

The second step is done: ~~Translate the URL parameters in a way MongoDB understands~~ ✔️

Testing time

Here is our testing resource:

Let's try to sort our blogs by title with descending order.

We can select specific fields from the blogs, such as id, title.

We can also limit the results and retrieve the second page.

Note that the page starts from index 0.

Now let's search for a blog with the text "This is content 1".

Conclusion

The implementation is pretty simple, we just added two extra steps to our flow to support the filters, the collection of the parameters which will take place on our Rest Controller, and the filter applier which will take place before the database call.

Here is a sequence diagram of our process

As I said before I published this code to the Maven Central Repository so you can support filters to your application by just adding the dependency.
Read the documentation for more details.

Source code

Available on GitHub.