While investigating Protobuf I shot from the hip and wrote that: to model money, one should use BigDecimal.
That’s the conventional wisdom and it is correct - in a lot of cases.
It’s fine when you deal with one single currency and you are most of all concerned with the precision of financial calculations.
But what are some other options? let’s find out.
The iterate
function create a lazy, infinitive sequence based on function calls. The iterate
function takes a function and an initial value as arguments. The first element in the sequence is the initial value, next the function is invoked with the previous element as argument and this continues for each new element. Suppose we have a function #(+ 2 %)
that adds 2
to the input argument. Then if we use this function with iterate
and start with value 1
the first elements of the sequence will be 1
, (+ 2 1)
, (+ 2 3)
, (+ 2 5)
. So first element is the initial value, next element is the invocation of the function with input argument 1
. The result of this function is 3
, which is then the input for the function to calculate the next element and so on.
In the following example code we use iterate
in different scenario’s:
Continue reading →
In my last blog I gave you a small introduction into the term "Reverse Shell".
I described it as: "A Reverse Shell is where your target machine creates a connection to your machine, after which you get a shell on the target machine in which you can execute system commands."
It is similar to SSH, but without any encryption and the connection is created the other way around (from target to you, instead of you to the target).
Continue reading →
The first
function in Clojure returns the first item of a collection. The next
function returns a new sequence with all elements after the first element from a collection. Clojure adds some utility methods to combine first
and next
with different combinations. We can use the function ffirst
which is will return the first element of the first element of a collection and the nfirst
function to get the next elements from the first element of a collection. We can use the function fnext
to get the first element of the next elements of a collection and the function nnext
to get the next elements of the next elements of a collection.
In the following example we use the ffirst
, nfirst
, fnext
and nnext
:
Continue reading →
At JCore, we follow a three year program to become senior developers.
After following this program successfully, you will be promoted to the JDriven company.
In the final year, we have a specialization in a topic of our choice.
I chose to specialize myself further into security.
I have been studying this topic for some time now, even contributing to the fast track courses as a security teacher.
Until now, most of my time I spent on the defending side and now I want to take a look on "the other side".
So my specialization is all about attack, also described as joining "The Red Team".
Continue reading →
In the previous blog I introduced the gRPC calls and told about the absence of error handling in the model itself.
Let’s investigate how this came about.
Continue reading →
Since Java 9 we can use a function as argument for the Matcher.replaceAll
method. The function is invoked with a single argument of type MatchResult
and must return a String
value. The MatchResult
object contains a found match we can get using the group
method. If there are capturing groups in the regular expression used for replacing a value we can use group
method with the capturing group index as argument.
In the following example we use the replaceAll
method and we use a regular expression without and with capturing groups:
Continue reading →
In the previous blog I started my journey into Protobuf and introduced my first steps by
introducing an example Contract service and some business operations on it.
Now let’s start with diving into details of how to model the gRPC calls.
Continue reading →