DEV Community: Juan

Recommended podcasts

Juan — Fri, 03 Jun 2022 00:00:00 +0000

Here is the non-requested podcast lists around Software Development.

Podcast	Link	Review
Maintainable	maintainable.fm	Conversations with developers and engineers around maintain and evolve software. Important topic of you consider committed code as legacy code!
CaSE: Conversations about Software Engineering	vase-podcast.org	Interviewing developers and architects about software engineering and development.
Software Engineering Radio	se-radio.net	Engineers talking about their experience around different topics around building software.
Soft Skills Engineering	softskills.audio	Not everything is code and tools when we talk about software development.
Developer tea	developertea.com	This podcast focus as well in the human part of develop software.
Dev Discussions	Apple podcast	Conversations around topics around software development, techniques and patterns.

My DMs on twitter are open @qjuanp feel free to recommend me more podcasts! I’m looking for comedy (international and local Irish comedy for foreigners) and interesting stories in this format. Thanks!

Methodology vs Framework

Juan — Tue, 31 May 2022 00:00:00 +0000

Just trying to explain this two concepts that could help driving conversations at architecture level since there is always a situation in during the design where you will find using them.

So, first of all, they are not synonyms.

Methodology

This is a common used concepts among academics. For dissertations, the methodology explains how a particular conclusion was reached. A methodology express the procedures, methods, principles and rules under a particular discipline [1] that will lead you to an specific result, in terms of a thesis, the conclusion reached.

And moving that concept into the software development scope [2], a methodology defines the process and the set of specific deliverables and artifacts that are needed to develop and maintain applications during its lifecycle.

Framework

It’s basically a tool set or a set of methods that can be applied separately or all the same time, the process to apply each method might or might not defined, but, is not essential for the usage of each tool.

In software [3] we use the term frameworks as well, frameworks like .NET (yes, dotnet core is still a framework), Java EE, Spring, etc, define tools and components that can help you to build and deploy applications.

In Project Management for example, PM Book can be identified as framework, since it defines a set of methods to be used in projects, but it not defines the procedure to combine each method.

Core differences

In conclusion, a methodology defines what to deliver, how to create those deliverables and the logical order to do so, meanwhile a framework only defines what you can do.

That is why you can use 2 different frameworks to produce something new, for example, in software you could use Spring of top of Java EE, or Scrum with a Critical Path Method from the PM BoK (r).

Some examples

Now that we know the differences, we can categorize the following practices and software components under each category.

Scrum is a framework
Agile is a framework
Angular is a framework
Ionic is a framework
react it’s not a framework nor a methodology…
Nodejs it’s not a framework nor a methodology…

In software we use a lot frameworks, since we need to adapt the principles, deliverables, components to specific contexts.

You can check the post made by Michael Wood where he digs more in other Frameworks and methodologies used around technology projects and organizations.

VSCode-Java Maven configuration error

Juan — Mon, 10 Jan 2022 00:00:00 +0000

There is no day that I not face a “funny” error developing in Java, saying that, it’s not my intention generate drama nor a new whole discussion Java vs The world…. this error is merely product of my ignorance in java and the composability you could find in this development ecosystem (coff coff Msft!).

Joke aside, I found myself in a “particular” scenario:

When I run the cli command mvn clean compile project simply compile perfectly!, even the tests were running without a problem. But, when I opened up the project in a VSCode, the compiler went crazy and it was just saying that the project has a ton or compilation errors, errors like:

“Failed to read artifact descriptor for…”
“Missing artifact…”

VSCode-Java uses under the hood the same tools, java and maven, to verify the sources and bring us information during development, so, how can be possible get two different results if, under the hood, are basically the same tooling?

This error can come up with certain packages available in private repositories.

The problem is basically that VSCode-Java/Maven tool is not able to find the default settings that are commonly stored in ~/.m2/settings.xml or %USER_PROFILE%\.m2\settings.xml where the private repositories for maven are configured.

This can be specified using the VSCode setting entry:

"java.configuration.maven.userSettings": "C:\\Users\\<UserName>\\.m2\\setttings.xml",

Or pointing to the specific settings.xml location that you are using for private repos.

Hope that it helps!

References

Git - Deal with rejected changes over protected branches

Juan — Mon, 27 Sep 2021 00:00:00 +0000

Scenario: main(*) integration branch rejects changes when try to pushing into remote repository. This is a common practice to follow Gitflow (or other branching strategies) to enforce merge reviews into the into the main branch.

So, how to push correctly your changes into main integration branch?

Summary:

Create a feature branch
Reset your local main integration branch and sync up with remote main branch
Push your feature branch and create a Pull Request

Create a feature branch

Create a feature branch from your main integration branch, remember that branches are just named pointers to actual commits, so, new branch will be pointing out to your latest changes, which are the ones you’re trying to push correctly into the integration branch.

git checkout -b [feature-branch-name]

Remember to follow your defined naming conventions to name the new feature branch.

Reset main

Let’s move the local main branch pointer to the same commit that remote branch is referencing.

In this example we assume that is just one commit behind the last commit, in that case we just need to run:

git reset --hard HEAD~1

Where:

Reset will move the pointer
--hard just move the pointer, discard all the changes
HEAD~1 one commit before current HEAD pointer

The result is something like this:

Push your feature branch and create a PR

Now you can push your changes under the new branch:

git push origin [feature-branch]

And after that you will be able to create a PR to merge your changes with the main integration branch.

Introduction to Sets in Rego

Juan — Sun, 25 Apr 2021 00:00:00 +0000

Rego is a declarative language used to define policies in Open Policy Agent (OPA). This declarative language works defining queries that behaves like assertions over structured data stored in OPA.

In other words, we could said that OPA is the engine that interprets and evaluate policies written in Rego.

But, what is a Policy? an over-simplified analogy could be that a policy is a pre-condition: “a condition or predicate that must always be true prior the execution of something” #.

An example of a policy could be:

Users can only buy if its profile has an address and a phone number

We could identify here a concrete action that is: “buy”, but before that action occurs the following pre-conditions should be meet:

User profile must have an address
User profile must have a phone number

In this particular case, rego assertions needs only to verify that a couple of fields contains some value, so, the final policy in rego looks like:

default profile_completed = false

profile_completed {
    count(input.phone) != 0
    count(input.address) != 0
}

^{see this example in action ▶️ https://play.openpolicyagent.org/p/4k0TZcT1hy}

Nevertheless, there are cases where expressions get more interesting, one of those cases is when you have to compare data collections with rego assertions.

One example of this type of policies is:

Only authorized roles assigned to an user can access the content

Rego collection data types

Collections (Composite values) in rego come in different flavors, has different built-in functions and syntactic sugar.

Object/Dictionary/Map: key-valued collections > we will talk in another post about particular data type.
Array: indexed collection
Set: non-indexed/unordered collections of unique values

As you may noticed, there are substantial differences between Sets and Arrays, despite they use same representation when is serialized into JSON.

For the specific scenario that we are evaluating, values in the collection are the important ones, not so much where are they located at, which means, Sets will suit perfectly to write a policy and when you dig into built-in operations you will notice why too.

Sets in Rego

Declaring sets

First thing first, how does it look a set in rego?

// Set of primitive types
s := {"this", "is", "a", "set"}

s := {8,2,26}

// Set of complex types

s := {
    {"country":"🇨🇴"},
    {"country":"🇮🇪"}
}

Sets and arrays share a similar syntaxis, although Arrays use square brackets [...] and Sets use curly brackets {...}. Yes, objects in rego use curly brackets as well, but remember that objects are key-value collections.

Equality

Here is where sets start to look interesting! since it contains only unique values the equality comparison is pretty simple

{1,2,3} == {3,1,2} // -> true

[2] Example taken from official documentation.

And yes, when you declare a set it just store unique values

s:= {1,1,2,2,3,3}
s == {3,2,1} // -> true

Projection

You could create new sets based on subqueries using “Comprehension”.

comp := { head | body ; condition<optional> }

Tip: You could use comprehensions to create other Composite values like objects and arrays, structure is the same (head, body, condition), just take a look of specific syntaxis for each type.

head → item to be taken for the new set.
body → expression indicating where to extract the item.
condition → if condition result is true the item will be added into the resulting set, otherwise is discarded.

Intersection

When you have 2 sets, you could get the intersection from both sets using the binary operator &

french := { 
    "🇳🇪 Niger", 
    "🇨🇲 Cameroon", 
    "🇬🇳 Guinea", 
    "🇨🇦 Canada" 
}

english := { 
    "🇨🇲 Cameroon", 
    "🇮🇪 Ireland", 
    "🇳🇬 Nigeria", 
    "🇿🇦 South Africa", 
    "🇨🇦 Canada" 
}

english_and_french := english & french ## --> { "🇨🇲 Cameroon", "🇨🇦 Canada" }

This intersection is precisely what we are looking to define a policy around the scenario proposed, let’s take a look

Let’s say for example that we have part of the content (what ever it is) and that content could be accessible for System Administrators and Publishers, so, the allowed set of roles could look like:

allowed_roles := { "admin", "publisher" }

And we are getting from the actual system that is validating content access against OPA the list of roles assigned to the logged user, so, we receive the following JSON:

{
    "username": "qjuanp",
    "roles": ["writter", "publisher", "developer"]
}

Knowing what is a set and how to use the intersection operation we could define the policy in rego as:

default allow = false # By default is not allowed

allow {
    user_roles := { role | role := input.roles[_] } # user roles came as an array, so let's create a set version
    user_allowed_roles := user_roles & allowed_roles
    count(user_allowed_roles) > 0 # final result of the alternative rule set `allow`
}

allowed_roles := { "admin", "publisher" }

^{see this example in action ▶️ https://play.openpolicyagent.org/p/gjMYmbDg4C}

It’s important to transform arrays into sets to use properly sets operations, otherwise OPA won’t tell you that there is an error and instead is going to use the unique values present in the array → indexes, which is going to mislead the rego policy evaluation.

Alongside with intersection there are two more interesting bult-in operations to work with sets: Minus (left join) and union, and other syntactic sugar “Rule Sets”, but I will write about them in future notes, stay tuned.

if you want to learn more in general about Rego, I’d recommend start with this post:

👉 make a suggestion

If you want to help me with this post redaction don’t hesitate on create an issue in the GitHub repo where it’s hosted, use this link to get you there, and thanks!