Forem: Julian Schlickmann

Unlocking Your Future in Software Development: A Beginner's Guide

Julian Schlickmann — Fri, 31 Mar 2023 20:47:51 +0000

Welcome to the exciting world of software development! Whether you're a total beginner or have dabbled in coding before, starting a career in software development can be daunting. But fear not, with the right mindset, resources, and guidance, you can turn your passion for technology into a fulfilling and rewarding career.

First things first, start by learning the basics of programming. Don't worry if you're not a math whiz or have never written a line of code before. You can find plenty of online resources that cater to different learning styles, from interactive platforms like Codecademy and Khan Academy to more traditional classroom settings like Udemy.

Once you've got the basics down, it's time to choose your area of focus. Do you want to build websites and user interfaces? You might be interested in front-end development. Do you prefer working with databases and server-side technologies? Then back-end development might be more your thing. Or maybe you want to do a bit of everything and become a full-stack developer.

Regardless of your area of focus, the key to success in software development is to build a portfolio. Create projects that showcase your skills and knowledge in software development. These can range from simple web apps to more complex systems. Share them on platforms like GitHub, LinkedIn, or your own website so potential employers or clients can see what you're capable of.

Staying up-to-date with new technologies and frameworks is crucial in the software development industry. Follow tech blogs, attend conferences, and participate in online forums and communities. This will not only keep you informed but also help you network with other developers and professionals in the tech industry.

Speaking of networking, building relationships with others in the industry can open up new opportunities, from finding your first job to getting mentorship and support from experienced developers. Attend meetups, conferences, or join online communities to meet other developers and learn from their experiences.

Finally, remember that practice makes perfect. Keep honing your skills and building projects to gain more experience. Set goals for yourself and challenge yourself to learn new things. With hard work, dedication, and a willingness to learn, you can turn your passion for software development into a successful career. So go ahead and take that first step today!

Avoiding unnecessary network requests with Apollo Client

Julian Schlickmann — Thu, 03 Jun 2021 00:06:18 +0000

Hey, 👋 I'm Juliani and I work as a Front End Engineer at Thinkific. Here at Thinkific, we've been using GraphQL to help us interact with our API and it's been amazing because it gives us the flexibility to request data as needed by our client applications. So, today I wanted to share a way to improve the performance of applications as a whole reducing some network requests that maybe aren't necessary.

Getting started

Let's suppose we have an application that allows employers to create job posts and candidates can see those posts on a job board. In addition, the candidate can see a specific job post and all the ones related to a specific company.

To be able to accomplish that we will need to have three queries.

one to fetch all the job posts to be able to display them on the main dashboard;
another one to fetch a specific job's details;
and last but not least the query to fetch the company information and its job posts;

In addition to the queries, a mutation to create a job post is also required.

When a mutation to create an entity is executed it isn't added automatically to the cache, the same happens when we want to delete an entity or edit multiple entities, the cache isn't touched. Therefore, the UI doesn't reflect the change. So, one common approach I've seen is to use the refetchQueries option to refetch all the queries needed after the mutation has occurred 💔 ❌. That causes new network requests that could be avoided by cache manipulation.

For the create post mutation it could be something like the following. However, I'd recommend using useMutation to follow the most recent changes to the Apollo library.



async function createJob(input) {
  const {
    data: { job },
  } = await createJobPostMutation({
    variables: { input },
    update: (cache, { data }) => {
      cache.writeQuery({
        query: jobQuery,
        variables: { id: data.job.id },
        data,
      });
    },
  });
}

Apollo offers ways to manipulate the cache, which might be beneficial in reducing additional requests to the API.

You can read and write data directly to the Apollo Client cache, without communicating with your GraphQL server. You can interact with data that you previously fetched from your server, and with data that are only available locally.

When using writeQuery, writeFragment or cache.modify it triggers a refresh of all active queries that depend on modified fields and therefore we have the UI up-to-date 💚 ✅.

Any changes you make to cached data with writeQuery and writeFragment are not pushed to your GraphQL server. If you reload your environment, these changes will disappear.

By reducing network requests we can improve our app's performance 📈.

Functional Programming — What I have learned

Julian Schlickmann — Wed, 18 Mar 2020 03:26:33 +0000

Lately, I have been reading lots of papers talking about Functional Programming (FP), then I decided to summarize what I have learned writing this article.

Before throwing a bunch of concepts here, do you know what is functional programming? It is a software development paradigm that is becoming more and more well-known among developers. The idea is coding simply and cleanly avoiding side effects using the power of functions.

Wikipedia defines Functional Programming as

… a programming paradigm — a style of building the structure and elements of computer programs — that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data — Wikipedia

Most of the papers I have read address the following subjects.

Pure Functions;
Immutability;
Referential Transparency;
Functions as first-class entities;
Higher-Order Functions (HOF);

I believe it is important to understand the concepts mentioned before because you might be using FP and you do not even know. To comprehend them is essential to improve the quality of your code. So, let’s go to the concepts.

Pure Functions

You might be asking yourself what are pure functions? how do you create or to determine whether a function is pure or not?

Pure functions always return the same results when given the same inputs. Consequently, they have no side effects. Pure functions allow referential transparency, which means you can replace a function call with its resulting value. — Cody Arsenault

Well, based on the reference above we can define a pure function as something deterministic. I have written a simple example below.

Impure Function

Could we consider it a pure function? We cannot consider it one example of pure function due to the global variable used and not passed as a parameter. However, we can fix it by passing the global variable as a parameter, but I rather write it as below.

Pure Function

Some examples of impure functions are the ones that read external files, generate random numbers. It is due to the output that may be different even calling these functions passing the same parameters.

// It generates a value given a minimum and a maximum value
function getRandomArbitrary(min, max) {
  return Math.random() * (max - min) + min;
}

getRandomArbitrary(1, 10);
getRandomArbitrary(1, 10);

With that being said we can conclude that using pure functions concept the code becomes easier to test and we do not need to mock anything.

Given a parameter w → expect the function to return value x
Given a parameter y → expect the function to return value z

Immutability

The ability to remain the same over time under all circumstances

Data is immutable when its state cannot change after its creation. You cannot change an immutable object. You must create a new object with the new value instead. The following example is a common situation where people could refactor their code to follow the immutability principles.

Mutable total variable

Recursion is a great way to avoid mutability in iterations. Rewriting the code above we could have something like below.

Immutable data

The sum function receives the product array and calls itself until we get an empty array. For each iteration, we will add the product price to the total. In the end, we have the summation of prices and also immutable variables.

Referential Transparency

Referential transparency is the concept of having the same output, whenever we use the same input. For example, having the following pure function.

const cube = (number) => number * number * number;

Calling it three times passing the number four we always will get 64 as the result. So, we could replace cube(4) with 64. Therefore, we could affirm that referential transparency is the result of writing a pure function that has immutable data.

Functions as first-class entities

The idea behind functions as first-class entities is that we should be treating a function as a value and using it as data. When we adopt this point of view we can start to refer to it from constants and variables, also pass it as a parameter to other functions and even return it as a result of other functions. Getting back to our recursion example, we could have two new functions, totalAfterTaxes and applyDiscount5.

Functions as first-class entities

As you can see we are consuming functions as an argument. We are creating a chain of execution that removes the necessity of creating variables to store the results to pass into the other functions.

Higher-Order Functions (HOF)

The definition of a higher-order function is a function that either takes one or more functions as arguments or returns a function as its result.

Those new functions implemented above are an example of higher-order functions. If you are familiar with JavaScript you may have heard about filter and map functions. They are a common example of higher-order functions. Let’s take a look at some examples.

Filter

Let’s suppose we want all products under $2. We can use the filter function to evaluate another function and if the result is true store item into a new array.

Filter Function

Map

The map method can transform a collection by applying a function to all its elements and build a new collection from the returned values. If we would like to double the price of those products we could do something like the example below.

Map Function

My conclusion

After reading many papers and writing this article I think the Functional Programming (FP) paradigm a great way to coding high testable and bug-free applications. I hope to pass to you a little bit about my understanding of FP.

Note: This was my first article in English, so I am sorry for any grammatical error 😅