Posts

Showing posts from September, 2020

Iterator

Image
Trade-offs are super interesting and excellent exercises you can do to have better design and better coding. Let's say we want to do some simple algorithms that return vols from a String. So how many different implementations can we have? So easily we can think about some sort of Utils or generic function that can do the work for us. What if we cant to be Lazy or Early loading or be able to abstract the process? Well and Iterator is an interesting pattern that we can use to help us to abstract state and have more functionality around the data structure. So because there is the Pattern Iterator you might think that there is just one possible implementation right? Actually, there are several different implementations we can do and we can play with different trade-offs. So today I made 2 java videos to co trought this pattern and show some practicality in code. I hope you guys like it, let's get started. 

Dependency Management Best Practices

Image
Every single technology project uses dependencies. No matter the language you use, you always will use dependencies. Monoliths and Monorepos make dependency management more manageable by having it all in the same place. Services and Microservices make them a bit more challenging because now they are spread across each server, updating libs is a challenge that requires automation to be fixed. Besides automation, some best practices are also needed. Several times engineering teams take dependency management for granted. After all, we are just adding some strings and numbers to a file, right? So how complicated can that get? Often dependency management issues only appear after time and scale. Dependency Management is a super important and relevant discipline. Today I want to share some best practices to make your life better and make sure you scale your codebase with speed and solid practices rather than piles of tech debt and pain. So In case your not geek enough, the post icon image is

DDD The Lost Discipline

Image
DDD is a modeling method highly focused on business domains and comunication. DDD solves several issues we have with Services/Microservices and Backend Systems in General.  One of the biggest challenges in Services but especially microservices is to find the right boundaries meaning what should belong to one service or what should belong to another service. It's common for engineers, often, just write code right and ignore the design. Modeling is hard for several reasons but one reason is the software might work, even with the wrong design. The right Design starts placing the code in the right place. DDD is key to that. DDD is not only about placing the code in the right place but also about how we communicate with the business to figure out that and other ways(DDD Patterns) to express the solutions.  

Github cli tool (gh)

Image
gh is the new  Github command-line tool. I'm super excited about this new tool. It makes the engineers / devops engineer experience much better. It allows you to use github(not fully yet but the basics) in the command line, so you dont need to use the browser. GH is written in GO and I believe in the future we will have amazing tooling from Github to CI/CD using GitHub Actions. So let's get started.

JDK 15

Image
Java is finally getting interesting again since JDK 8 thats the first time I wish to be using a new JDK in production. I'm really looking forward to JDK 16 and to the future. JDK 15 has lots of interesting things such as Records , Pattern Matching for instanceof, EdDSA algo , Text Blocks , Local classes and interfaces, Sealed classes and interfaces , ZGC , FMA , and much more.  So Let's get started and take a look at a quick video I made to show Java 15 working with Maven and Idea. 

Micro Frontends: It's frontend making some mistakes as Backend?

Image
Services are a thing for a long time in the backend. +20 years I would say. Microservices are much newer however they also started the backend. Micro Frontends is a very hot topic in frontend engineering right now. Frontend engineering evolved a lot in the last 5 years. Ui are becoming more and more complex and frontend teams are growing a lot. With complexity and growth, we stumble into classical backend problems such as Teams Organization and Scalability and the need for Isolation as a base for Independence and increase the number of deploys. Frontend technology evolves much faster than backend. With all that comes debit and believe me or not the difficult to find people to work on old tech like AngularJS. 

Business Agility are we back to CMMI?

Image
Agile is around for at least +20 years. However, one big complaint was "how can we scale agile" or "how we go beyond teams". You might consider business agility as the 3rd wave of agile.  But is really hat the case? The world changed a lot in the last +20 years there are many other things to change in the next years. COVID-19 amplified lots of the issues that was already in place.  It's really business agility something entirely new or just an aggregation of previous movements, practices, and values? Business Agility is a hot topic right now, lots of people talking about, very few really doing it. It's hard to get real agile teams nowadays, imagine whole orgs being agile, even harder. IMHO to make the org agile is super hard, however, some of the reflections that business agility is proposing sounds right in the sense we might be asking these questions anyway. 

SOA for Internal Shared Libraries

Image
SOA has the right principles for scalability with cohesion and consistency. Microservices are dying nowadays for several reasons like  Lack of Isolation , Distributed Monolith & Shared Libs Abuse , and many other reasons such as the wrong boundaries. I deeply believe we need to double down in Services and SOA . Sometimes the Sidecar Pattern also makes sense and is an interesting approach .  However, there are times where we really need to go to Internal Shared Libraries.  When that's the case we can still apply SOA for Internal Shared Libraries and have a better a clean design such as having a clean CORE . Keep in mind there is a lot of shared libs abuse in companies but in the cases where internal shared libs are the right choice, there are some important considerations. SOA can philosophy can help internal shared libs to do better and by doing so we can have better solutions with much fewer headaches. I need to repeat Internal Shared Libs should not be your goto approach. Se

Big & Micro Retrospectives

Image
I'm doing retrospectives for more than 10 years. I saw it all, the good, the bad, and the ugly. Retrospectives are fundamental and instrumental part of Agile. Even if you are not doing Agile or is not agile-ish in our way of work I would 100% you need o to have some form of retrospective. Retrospectives are an important mechanism to introduce improvements. Pretty much all companies spend lots of time in planings sessions. Long planing sessions are pretty normal(4h or more). However long retrospectives are not popular at all. It's possible to work without classical retrospectives however you would need some form of Reflection and Guilds/Chapters might be a place to have retrospectives. IMHO Retrospectives is something you want to do without mercy(Maybe I'm watching too much Cobra Kai ). Meaning you should do lots of retrospectives. Retrospectives have different flavors and styles however I believe there are 2 important ones: Big & Micro. Retrospectives help to change t

Linux Terminal Goods V

Image
It's time for a new kick-ass console application to boost your productivity. The tools can be useful both for engineering productivity on your local workstation/laptop or doing some remote pair programming but also for the cloud as you profiling or debugging something. So if you did not check it out the other 4 posts please check it out here: I , II , III , IV . So like Bruce Buffer would say it Iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiit's time! Linux Terminal Goods V!