Diego Pacheco Tech blog

Github Co-Pilot is in high hype right now. Co-pilot is an IA/ML tool that allows engineers, coders, in general, to get more productivity from their IDEs and Editors. Right now co-pilot is on early access, I had to subscribe and wait for +3 months to get my access. There are things that need to be improved for sure but overall I can tell it's a pretty cool and yet useful piece of technology. Of course, it raises ethical and IP concerns. Like would private secret source code be used from one company to another? In the land of the AI/ML we never know what will happen so I did not actually use for Real code, to be safe I did not even use it on my main IDEA (IntelliJ for Java)  - I did it in VSCODE where I used it much less and that sense I could isolate from the rest of my personal projects. I have a SlideCast with some thoughts and later there is a live demo with some cool co-pilot in action.

TestContainers is a great project for integration tests, mocking, and even for Chaos Engineering. Scala TestContainers is the library in the form of idiomatic-scala with some sugar to make it even easier to use it. I want to show you guys how we can use Scala Test Containers in an SBT 1.5.0 Project using Scala Spec in order to test as MySQL docker container. So let's get started!

Chaos Engineering is an important discipline of modern cloud-based services. Failure will happen no matter what and it's improved to prove your infrastructure, code, and configurations are reliable and can resist failure and proper recovery. The only way to know is to either by the worst way possible i.e error 3AM on Sunday night or you can test it and sleep better at night :-).  ToxiProxy from Shopify is a pretty useful and interesting solution. It's a proxy that allows us to introduce all sorts of network chaos in our applications such as latency, hang, timeout, and much more. ToxiProxy is written in Go and you can run the server in a self-contained executable like all Go good stuff. ToxiProxy has multiple clients in multiple languages. I will demonstrate some chaos with Redis using the Lettuce driver in Java and ToxiProxy java client library.

Go lang is a cool language to build services. Several DevOps and Infrastructure solutions are built-in go such as Vault, Terraform, Kubernetes, ToxiProxy, Chaos Monkey(CHAP), and many others. Go-Zero is a framework built-in Go that helps us to code microservices in Go. Go-Zero is endorsed by the CNCF foundation. Today I want to share with you a video and POC demonstrating how easy to get started with Go-Zero based microservices written in Go. 

Sometimes applications need to interact with the underlying OS, even with Bash and Process. JVM has a native implementation for Process, in Linux, there are system calls that are invoked. Today I want to show how easy to make Java and bash to talk to each other. This kind of technique can be used for all sorts of DevOps Engineering solutions or automation. So Let's get started!

Factory and Builder and super popular design patterns and still relevant and useful. However what happens if you need to allow others to create objects? That's like a reverse factory where the user needs to define the creational rules. So how can we do that and also have some guardrails and fences to drive some control and even some abstractions, is that possible? yes - that's the factory-kit pattern. Hold one a second why the heck I would need that? Let's say you are creating a game or a modular solution and you need to allow you consider defining customizations within some constraints. 

Reading and writing configs and objects can be more challenging than it looks. As your application evolves and your contract is used across several services, you might need to have Backward Compatibility. Easily we can think about 2 scenarios, the first scenario let's say you have a distributed monolith and you have multiple apps using the same database. The second scenario considers you have an Event Sourcing + CQRS application using Kafka for instance where you emit and read domain events. In both scenarios, there will be breaking changes, so how we can make your parsers and serializers to be more efficient and resilient to change, well: The Tolerant Reader Pattern is here to rescue.

The lazy Loading pattern is very interesting because allows us to make the code starter and also delays expensive computations to an appropriate moment. There is a way to combine this pattern with Java 8 Functional Interfaces and make it even more interesting and java idiomatic. This pattern is used by Spring and Hibernate. You can use it too. So today I have a video and some POC code. Let's get started!

Today career frameworks are a thing, they are pretty popular along with culture handbooks. Career frameworks are an interesting compass no not only to grow up on a company ladder but also to understand what the culture is and how to be effective. Of course, the paper accepts anything and you might write down beautiful things and have a completely different culture in reality. Besides that the fact that your writing down helps to achieve clarity and spread the word. Especially in REMOTE times like we live today where we have little to zero physical contact. Today I want to comment on 3 career frameworks and also see some similarities and opportunities for us to learn.

@Configuration allows you to distribute your Spring Beans across several classes and even jars.  However, with great power comes great responsibility. IMHO you should avoid as much as possible ship configurations with @Configuration inside jars. Because it creates binary coupling on Pojos instances and that has a huge blast radius. In IMHO is completely fine to have Config beans inside in your own service however we are considering a shared libs landscape thats a completely different question and IMHO the wrong move. Let's take a look how @Configuration behavior in sense of ordering and with multiple jars being loaded to the same application.

Modern Cloud Services need to have health checkers. Even some shared libraries might make sense to have health checkers. There is a lot of debate in the community on how the health checker should be implemented. If should just return dummy 200 hardcoded or if should check all dependencies of the services like database connections and other essential downstream dependencies. Which would require us to have a background thread in order to do it in a sane way. IMHO both can work. If you have observability into the other components is not required to make the service look all that, if you dont have or dont have to control to add it, it might be a good idea to have on the service. Besides health checkers, I believe we need to have greater Observability in Services and even for some shared libraries and we should collect metrics and expose config values other key aspects. IF you already have a service let's say running Spring Boot(Tomcat or Netty) or Quarkus, you already have a service. H...

Observability is a must-have nowadays in modern cloud services. There are multiple levels and options to provide observability into a service. Logging is the basic one but is well used can perform miracles, metrics, dashboards, and alerts and at the top of the chain however, the true nirvana is to have a self-managed / self-healing system and for troubleshooting a query interface. If you let it sink for a moment and think about it you will realize we often had such power in the past with relational databases with a SQL client for instance. However using a Spring Boot stack using polyglot persistence, with JPA, Reactive Programing, Multiple property sources, and Beans it's easy to get into the application and shared libs internals. So what's best? To have access to all properties at runtime and spring beans and be able to execute CODE in a very fluent way. That's where Groovy comes into the play. Inspired by Gabor Bata work , today I will show how we can get that and more w...

Configuration management is an important aspect of any service. However, configuration management is way bigger than just using a source control system like Git. CM(Configuration Management) is about Branching Strategies, or avoiding branches might be the best strategy in the line of Trunk Based Development. Besides branches and configuration management versioning systems like git we also need to be able to version applications in a proper way. It's pretty default to use semantical versioning. i.e: $major.$minor.$sec-patch however sometimes is important to know what version the app from inside the de application.  Java has a way for us to version packages(which can be used as modules) and we can know what versions we are getting, thats interesting for building modular monoliths and also for troubleshooting reasons, imagine you deploy to service and want to be sure you are running a specific version no matter the name of the jar is. Java JAR can have a build number or whatever versi...

Some years ago, every backend engineer wanted to be doing microservices . There was absolute hype. A vast majority of the market joined the microservice bandwagon without previous expertise in SOA. Some companies were successful. Still, several companies ended up in the worst place they were before. Therefore we see the Death of Microservices . IMHO there are many reasons why that happens to name a few: Lack of proper architecture skills in SOA , Lack of Isolation, Lack of Analysis, and jump to solutions too fast. Once you start distributing code across several code bases with multiple contracts, it is better to be correct because the rollback is a multi-year migration project and not easy to sell. How does that kind of thing happen exactly? In Microservices, the way to go is to use the Strangler Pattern, however by applying the pattern in the wrong way, thats where we arrive at the worst outcome: A distributed monolith. 

The DORA DevOps Report 2021 is out. Thats a very interesting report about DevOps and SRE covering 32K professionals over the world during the COVID-19 Pandemic time. We are in difficult times and having this data is very very interesting. IMHO We lose the battle, like Agile but at the same time, the report shows some interesting findings which always gave me hope.  I have read this report since the beginning and always find it interesting and super useful. Today I want to do something slightly different, I made a video commenting on some of my thoughts on the report. I hope you guys like it, so let's get started!

  Shape up is the new Basecamp book(former 37 signals). It's about product discovery. A book is a form or flavor of Dual Track agile . Is pretty interesting because it also blends with some Lean Startup ideas. 37signals/Basecamp was always an interesting company since they did not fit on the classical enterprise-like company neither typical silicon valley company. The books are often culture-heavy and show how they do business. This book is about product development, Discovery, Dual-Track agile, and a different way to manage scope. Basecamp explores the flexibility of Scope which to give them credit not often is explored. The book also shows obvious XP reference by tracking progress with Big visible charts and using lots of visuals to avoid heavy unrealistic planning. ShapeUp is cool but we also need to keep in mind they have executive buy-in since they literally run the company and do not rely on VC/Seed money, so this gives them the ultimate flexibility. Today I made a slide ca...

In the matrix movie(classical and awesome movie), there is a classic scene where Morpheus challenge Neo's understanding of reality and offers 2 pills the Blue one which would keep the status quo, and the red one, which could be painful but would be the reality.  If you have a successful company with software thats the reality of the industry. In other terns, the discussion can seem as should we re-write the software or should we strangle it. Re-write software and even strangler patterns have cases of success and failure. Before we enter into the trade-offs of this complicated dilemma lets us understand the forces which create problems and opportunities that are around this discussion. Let's talk more about the context and their trade-offs. 

Big Companies have lots of software. The Software industry moves pretty fast. However, not all pieces of software are moving that fast. There are always competing priorities between news business domains, acquisitions, new features, improving user experience, fixing bugs, improving security, and being up to date. If you have good architecture, isolation of databases, proper contracts, and tests, migrations can be much easier. However, not all pieces of software have the same conditions as you might have orphan software with no owners, old tech, lack of testing, lack of isolation; in those conditions, migrations could be pretty challenging. There will always have migrations one way or another. In the last decade, lots of companies have been migrating from on-premises to the Cloud. 

Tickets! Some people love them others hate them. I for sure dont have much love, however, I can see both sides of the same coin. There are lots of tracking systems such as Bugzilla, Track, Jira, GitHub Issues, and many others. There are companies with complex workflows with lots of approvals and complicated steps.IMHO there is little value in complex workflows, I understand the reasons why companies might arrive there but still think is not the way. Tickets can be used for multiple reasons, some could be valid, and others could be actually bad practices, meaning hiding inefficiencies. Let's take a look at the 2 sides of the same coin.

Some technical problems can get quite challenging. It's pretty common to feel like you dont know how to approach them or even panic. Especially if you are starting on technology. Even the most accomplished and experienced feel the impostor syndrome . IMHO if you do not panic is already 90% done 😉, then the next important thing is to keep going. Small incremental progress is essential emotionally wise in the sense of confidence-building. Small wins can be addictive. The first steps are often the most difficult because we are talking about a technical discovery process.  The tech discovery process might sound like something new and fancy, but actually, we are talking about something as old as the rocks: Analysis. But! How do we do this analysis? Which leads us to the questions such as: How to approach complex tasks? How to break problems down? 

From trait in Rust allow types to be created or converted from other types. From trait is used in the rust standard library. It's simple and yet effective. Is common to see From used with Into. However today I want to focus on the From trait. Thinking about coupling point of view you end up coupling 2 or more types, however, in sense of convenience is pretty useful since you dont need to lookup for other structs or external converters. You can use From in order to make it easy to convert from basic types to your types.I have a simple video showing From trait in action. Let's get started!

Rust is rich in sense of types. You can create your own structs and use generics. Rust even allows you to create a type alias. IMHO type alias is useful for 2 reasons. The first type alias makes the code more readable since the type alias can make the intention more clear. The second and less obvious is when you have generics because you can use the type alias to hide or save typing a big generic expression. However, this is a double edge-sword, at the same time is pretty useful to avoid typing and make the type construct proper it really could be hiding some unnecessary complexity. I have a video showing type alias in action. So let's get started.

Java is the backend solution for several companies, mainly for services and microservices. However, when you need to ship java for a CLI or DevOps solution java is a bit verbose. First, because you need to have a JDK, and second java by default is not self-contained. Meaning you will java multiple jars and if you are not running on a standalone server or using a framework like Spring Boot this could be a bit annoying. There are other solutions like you could be doing a Uber Jar or Fat Jar where you can bundle your app + dependencies in one and one jar. Today I want to share a bash trick where we can embed a Java jar into a single bash script. This trick is neat because with a single file we can combine bash and java. 

Podman is the new cool kid on the block. Podman is a deamonless container(OCI) engine for Linux. It's the natural open-source Docker replacement. Docker recently changed the license and plans. Podman commands and flags are compatible with docker and the replacement is very smooth. OCI makes things much more simple and portable. So today I want to share how we can install and use podman. So let's get started. 

IAM is one of the most powerful tools in AWS. IAM is centralized and super powerful. However, IAM can be pretty complex. IAM is all about managing access to resources and services in AWS. AWS IAM is for free, meaning free of charge but you will pay(of course) by other services you end up using for computing and storage. IAM is made for fine-grained access control, with MFA, Active Directory Integration, and much more. AIM has auditing capabilities integrated with AWS Cloud Trail. IAM allows us to create individual users, groups, and credentials that should be rotated often. Today I want to share a slidecast about IAM. So Let's get started.

Holacracy is an organization system where authority is distributed with self-organizing groups. I first heard about these ideas back in 2013 through Zappos's book . Culture is delicate and often moves much slower than technology. As generations are changing some values are slowly changing. Even COVID-19 is shaping how we live and do business. Holacracy has interesting properties, IMHO is all about the people, having the right talent might work in almost of forms of management systems, of course, the lots of great engineers don't care about what management systems they are in but others do. Today I want to share a slidecast I made sharing some ideas about Holacracy.

Builder Pattern is useful when we need to create complex objects(structs in rust case). Also if you want to do a fluent DSL Builder is a useful pattern for that as well. Today I will show how we can implement this Pattern in Rust, so I have a simple POC to show and also a video. So Let's get started! 

Rust has amazing support for concurrency programming. Today I will cover Mutex, Rc, RefCell, Channels, and Threads. I might make a second post covering the rest of the concepts like Arc. Rust dont have green threads since focus on having zero cost of abstractions. However, using channels we have a powerful abstraction to work with threads. Combined with Rc/Arc and RefCell/Cell we have a good foundation for good concurrency programs. Today I want to share 4 small pocs and 4 videos about Mutex, Rc/RefCell, Threads, and Channels in Rust. Let's get started!

Rust has this interesting trait called Add  which allows us to use the + operator and add 2 structs together. This is very useful for numeric types but also for engineering productivity lets say you are building a DSL for instance or an internal DSL. So I made some implementation and a video - Let's get started!

Rust allows us to do functional programming. One important thing in FP is being also to pass functions as parameters and also return functions which are also called high Order Functions. Today I want to share 2 videos and 2 pocs showing how we can do High Order Functions in Rust also you will get currying for free :-). I also will show how we can do closures using traits as well. So Let's get started!

 Java Agents are an interesting capability of the JVM. Agents can either be Static(Load when the java app starts with a special flag) or they can be Dynamic(using the dynamic API from java we can dynamically bind to a specific JVM PID. Agents can be used to run any code before the app starts or even to change the bytecode. The cool thing about agents is the fact that is a runtime thing and we do not need to change the source code of the target app. Agents are similar to Aspects but IMHO much better. Mockito uses mocks in order to test difficult scenarios, pretty much all observability solutions for logs and metrics also have agents. Today I want to share 2 pocs, one using a vanilla java app and doing bytecode manipulation, The second using Spring Boot 2.x and running code forever in a background thread as the app also runs. So Let's get started!

Bloom Filter is a probabilist data structure, created in the 70s. The data structure is used to test if an element is a member of a Set. False Positives(possible in Set) are possible but False negatives(Definitively not in the set) are not. Who uses Bloom Filters? Apache Cassandra, Google Bigtable, Apache HBase, and Postgress to avoid Disk Lookups. Bloom filters are also used by Akamai CDN to prevent one-hit wonders to hit the disk. Medium use Bloom Filters to avoid recommend articles the user already read to the user. Bing, Squid Proxy, Bitcoin, Ethereum also use Bloom Filters. Today I want to share a simple Bloom Filter implementation in Java. So Let's get started! 

Bitwise operations are faster and secure. Highly used in Security/Encryption,  Finite State Machines, Graphics, Comunication over ports/sockets, and Bit Fields. Java has support for: AND, OR, Complement, Signed/Unsigned Right Shift, Signed Left Shift. Java does not have Unsigned Left Shift. Today I want to share a simple POC showing all these operations and understanding them in detail. So Let's get started! 

This is not a production-ready neither serious parser, it's for pure fun! I was bored during one of the pandemics late nights watching Sam Rose's 3h parser video . So I decided to do something similar, inspired by Sam's video. Of course, I did not want to make a 3 hours video fighting Rust compiler - which is the ultimate reality but something shorter. The code is similar but I have few more operations like * and inc.  I also using a queue for Args not Stack so we can preserve ordering. So this is a cool way to learn rust because in the code we will be using Stack and Queue Data Structures and basics of borrow and ownership in rust. Let's get started!

Vector is a core collection in Rust. Vector(Vec) can be used for storing a list of values or even if you need a Stack - it's your data type. Rust language is pretty fast and secure however dealing with borrowing, ownership, and lifespan lifecycle is a high wall that often you can bash your head pretty hard against it. Returning Vecs and passing them as parameters could be pretty challenging if you were new to Rust. Strings also are pretty challenging in Rust. So today I want to share a video doing common operations with Vecs but always using functions and passing Vecs and Receiving Vecs. Hopefully, this will be useful in your common and daily work with Rust. Let's get started!  

Complexity is something that needs to be managed down and is an eternal battle. Part of the battle is to stay away from the style and cosmetical changes. Can we really get 100% of style discussions? Even removing discussions of 2-4 tabs, there will be some form of style on the discussion because every engineer has a background towards JEE, Spring, or Functional. That's a greater generalization, and there are other "design schools" over there but still quite common to find people within these 3 backgrounds. A Philosophy of Software Design is a great book that explains what complexity means. In the book, complexity is mainly described as "Obscurity," something that is not readable and has a high cognitive load to be understood. IMHO some problem spaces require you to have some background and experience on how some problems are solved; otherwise, it might look the worst they actually are. Complexity discussion often hard since lots of engineers have high EGO and h...

Cloud Development Kits are becoming very popular. Terraform, Cloud Formation, and many old solutions in the sense of infrastructure provisioning support CDKs. All infrastructure provisioning started as an OPS-ish thing, and often developers/engineers were far away from that. Terraform did a good job of being declarative for OPS and being simple and easy for developers. However, today there is a push to have provisioning happening into multiple programming languages such as Python, Javascript/Typescript, and even Java. Mainly to be more developer-friendly and really on the power of established programming languages. There are a bunch of CDKs popping up nowadays. However, CDKs have a price, code generation, and underlying complexity. Today, I have a slide cast and 2 code demos to show you CDKs more detail and compare them with standard solutions like Terraform. Let's get started!

Properties are around since java.  Properties are a persistent form of K/V pair which is mainly used for configuration. Configuration can be extrapolated all the way down to Feature Flags, Feature Toggles, and Canary. Java properties are cool because they are a simple API that allows you to do simple and yet powerful programing around them. There are 2 interesting projects enhancing properties such as Apache Commons Configuration and Netflix Archaius . These projects are pretty cool and give you killer functionally however the Java Stand SDK can also be pretty powerful if you have enough creativity and know-how to use it. So today I want to share a video exploring the Java Properties API in Depth showing how we can do some pretty powerful and simple configuration management for Dynamic Configurations, Feature Flags, Toggles, and more. So Let's get started!

I want to share my cents about the post: " On the Diverse And Fantastical Shapes of Testing ". First of all, I believe this is a very interesting subject and yet still see very few engineers talking about it. People mostly take tests for granted. Secondly, I would like to acknowledge the parts I agree with on this post mainly around the concept of Sociable and Solitary Unit Tests are quite useful and show be widespread. Also with the need for teams to have reliable, fast, Bounded(Isolated) and not Flacky on Justin tweet . Now that I acknowledge that, let me elaborate on what I think we are missing and why IMHO the pyramid is dated and we need a mentality shift. I have 4 points I want to elaborate on and give more context.

Fat Jar is a very useful technique. Having one jar and one jar only makes the distribution of software much easier and also mantaince much more sense as you need to roll out bug fixes and changes. Scala allows us to create self-package, self-executing one single fat jat by using the Assembly plugin. Today I want to share a simple POC and video I made showing how we can create a Fat Jar using Scala, Assembly, and Sbt. The code will be using a java dependency, a project called Apache Commons Lang .  So let's get started! The Video The Code https://github.com/diegopacheco/scala-playground/tree/master/fatjar-assembly-sbt-1.5.0 Cheers, Diego Pacheco

Java has 4 visibility options: Public, Protected, Private, and Default. However, is those visibilities enough? Sometimes we need to weigh tradeoffs between different dimensions such as Design, Abstraction, Testing, and Security. C++ Has interesting fine-grained, class-level control with a friend. Java does not have that, but there are some interesting options we do in order to imporve things a bit. Today I want to share a video going through the options we have in Java. I also will show some C++ code so we can see how C++ would handle it. Java also has modules but that is not widely adopted in the industry as most companies still run on java 8. So Let's get started! The Video The POCs  https://github.com/diegopacheco/cpp-playground/tree/main/friendly-visibility-fun https://github.com/diegopacheco/java-pocs/tree/master/pocs/caller-fun https://github.com/diegopacheco/java-pocs/tree/master/pocs/visibility-control-design-poc Cheers, Diego Pacheco

Encryption is super important nowadays.  However, it is straightforward to end up making the wrong choices and compromising your brand and customer experience. AWS CTO Warner Vogels once said Security is everybody's job. Today I want to share another Slidecast I made about Encryption. We will do a Deep Dive into the Encryption problem space, and also, we will see how to do the basics with Java Standard JDK. No Matter if you are a DevOps Engineer or Engineering, you might found this useful. I will cover Symmetrical encryption in-depth, RNGs, PRGNs, AES, AES Operational Modes, Rotation Challenges, AWS KMS, Java Code, and more. So without further due, let's get started! 

Security is the new black. Years ago Tests were not widespread as they are today and the same happened with DevOps where automation, Infra as Code, Versioning become the norm today. However, for security, we are not there yet. I believe this will change in the next years and more and more security is a concern where the teams need to care about and understand more about. Security can be pretty scary but at the same time is not rocket science and you can learn it for sure. Today I made a slidecast which I want to share with you guys and go over the security principles, common vulnerabilities and attack vectors, culture, trends, and much more. So Let's get started!

Every company has a legacy code. Often we confuse legacy with multiple different concepts, and this confusion makes improvements harder to happen. Most engineers don’t like to deal with legacy code-we all like shiny new things. Unfortunately, most of the time, there is no easy way out. It is possible to replace a legacy system with a brand new system because it is easier and faster than fixing all the legacy’s problems. We can’t get out of legacy systems because they have old languages, old databases, and often messy. Is that so? However, there are 2 kinds of old languages. The ones who are dying and dated like Delphi or Clipper and the other ones are old but are perfectly fine to use C++ or Java. I’m not defending legacy systems; however, I believe several essential aspects need to be considered. Old: Mature vs. Dated Commonly, we confuse mature software with dated.  Boring technology  is full of good arguments there. Old technology not necessarily means it is terrible. ...

Normalmente eu nao blog em português, mas hoje quero compartilhar um programa que participei recentemente. Programa gravado com o Inacio da South System sobre Arquitetura de Software, mais especificamente falando de Microservices, SOA, Shared-Libs e bem como os problemas e as soluções. Microservices estão em baixa nos dias de hoje. Porém muitas vezes não entendemos por que estamos usando microservices e nem por que estamos parando de usa-los. Muito difícil conversar sobre SOA e microservices sem falar de shared-libs e o impacto nessas arquiteturas. Nessa conversa você ira entender mais os problemas desse landscape bem como muitas alternativas para editar esses problemas. Entao bora la ver esse video! 

Every company out there works with teams. There are all sorts of teams such as teams specialized in technology stack like Hadoop or teams which are domain-driven and have cross disciplines( Cross-Functional Team ) inside such as backend, frontend, QA, UX, Architecture, and more. People don't leave companies they leave teams, also it would be accurate to say that people don't join companies and they join teams. So should we have dynamic or static teams? Should teams self-assemble or should we have PMO doing that? Should the teams be stable or should we allow dynamic reteaming? Is work always fitting well in our team's structure? What about Platform vs product teams, which one is best? Should we just pick one model or should we use different models? Should engineers organize around managers or managers organized around engineers? Teams affect Architecture and our perception of ownership. Teams should be a people organization but often is just a grouping of people where everyb...

Branches are almost a religious topic on technology. Git made branches easier and the default approach nowadays. However, do branches always help us and improve the status quo? Do we understand where we are going and what goes do we have or are we just following the herd and choosing technology as a fashion choice? Branches can impact your Refactoring, Code Review, and Collaboration habits. Branches also have high relation with software architecture or the lack of then. Many teams want to do CI/CD or at least talk about modernizing the release technologies but do all teams understand the principles behind it. To answer these questions and many others: Today I want to share a slide cast I made about branches and SCM in general. Doing some reflections and thinking about the benefits and the issues around branches. So Let's get started! 

SOA(Service Oriented Architecture) is all about contracts. Contracts can either be managed explicitly by doing Contract First, Customer-Driven Testing, having POs manage the contract as an important asset as much as a UI is. Contracts can also be unmanaged or managed implicitly just pushing problems to consumers and making the whole org move slowly. So what is a contract anyway? Why should we care?  The contract is all Data, Behavior, and expectation involved in the services capabilities. It's easy to see just the endpoint's input and output data and forget about the rest. The rest is smaller things like data formats, access protocols, serialization formats, and do not forget about expectations. For instance let's say you are returning a list of customers, if the data is in ascending or descending order it might affect your consumer code or tests.  Contracts cab be versioned and we should have specific tests on the Implementation provider side in order to make sure we don...

There were some interesting posts about UML recently. Mainly being  “   Has UML died without anyone noticing? ” and “   Why UML “Really” Died ”. I also made some po s ts about UML in the past — mainly “   UML Hidden Gems ” and “   Architecture 101: Thinking about Design ” and “   Internal System Design: The Forgotten Discipline   “. IMHO success means decline and eventually abuse. That happened to all successful movements, technologies, and methodologies I can remember such as Agile, Architecture, DevOps, Docker, Spring, and many more. Yes UML was abused and used in the context of the heavy and rigid process. UML was often used for all CRUDs which does not make sense and does not add value. But honestly, if we see things with DDD lens even CRUDS don’t make sense especially with UX sense CRUD are not ideal at all. IMHO what happens is we are exposed to fashion and marketing. There is internal and external pressure to do things in one way instead of anot...