Diego Pacheco Tech blog

 2020 the year that we were not expecting. The world did not end in 2012 as the Mayan calendar ended, but 8 years later, it felt almost like it. Jan, Feb, March was normal: Traveling, Going to Office to Work, Going to Restaurants, Pubs and Bars. Life was good—them after march never-ending lockdown and self-quarantine for +9 months and counting. Only going out for groceries and to take the garbage out(which surprisingly was one was the good real moments of the day).  I thank God for being alive and have work and food, and air condition appliances (3 to be precise). 2020 was bad, we lost so many people, and it still looks like 2021 won't be so easy; my bets are high for 2022, but some scientists say that normal only would be back in 2025 . The year was nothing but bad, awful, and I never want to go back to it for lots of people. For me, personally, it was not that bad. I mean, dont get me wrong, I had friends who got COVID, and thanks to God, they are good. I know people had a b...

Reactive programming is not a new thing. Thanks to reactivex and rx-java it's a reality for almost 10 years. There are other implementations like Project Reactor  and even Vert.x . However, for Databases, we are still not there. Some databases have better support than others like Cassandra and Redis have decent support in drivers but JDBC and JPA are not quite there yet. Hibernate just went reactive. There is a hibernate-reactive project now(still beta 1.0) but looking promising. So today I want to share some simple POC I made to make Hibernate Reactive work with Spring Boot 2.x using webflux: using Netty of course. So I made a video going throught the code and explaining how it works. I personally worked with all sorts of persistence on the last +17 years on technology but not an ORM fan nowadays. However I always appreciate performance and better APIs, so I think this is promising even if is for legacy application modernization.

So this is the second post about monorepos. The first post was about Google Bazel, this one is about Facebook Buck . IMHO Monorepos makes all the sense for Mobile(Ios and Android) since it's all about the same application. Of course, if you have libs that can work across multiple platforms(built-in C) or similar which make sense have generic repos outside of the app monorepo. At least one app should have a monorepo. I also believe a similar strategy can be applied for SOA and Services where we could have one monorepo per business domain. In that case, we would reduce the number of microservices drastically but still work with modules. For this post, I want to share another post. We will build a monorepo with Buck and Java. Facebook Buck is very similar to google Bazel on usage and principle. So without further due Let's get started. 

So this is a hot and problematic subject: Monorepos. IMHO there are good use cases for mono repo when your project is really one thing such as angular. However, there are good use cases for microservices. IMHO we should avoid extremes and just have one big monorepo for the whole company and at the same time avoid having microservices for everything. There is a need to strike some balance between maintenance, isolation, and organization. This is the first post about the monorepos, today I will cover the solution from Google called Bazel . In the next post, I will cover the solution from Facebook called Buck. All posts will have practical videos building mono repo with Java.  IMHO the IDE integration is not ideal for both Bazel and buck. There is some support for VSCode and IDEA but is far from being ok. So Let's take a look at the video.

Agile is a wasteland . Don't believe me? Read Kent's Beck(Creator of Extreme Programing) article . IMHO Agile has been in decay since 2013. However, Agile become mainstream since 2000; in Brazil, agile become mainstream in 2015, more or less. Success means misuse. The demand for agile is very high in some countries like Brazil and quite inexistent in Europe and the USA(mainly Silicon valley). Scrum has often sold dogma and easy answers with easy certifications. Scrum is really a big part of agile being mainstrain and also why it is such a shit show. There is so much demand in some places and literally very few people who really understand the software and digital products which greats a very complicated enviroment. So having said that, should we drop agile completely? Well, in some sense, yes. Things we just do because of Dogma and we dont understand and really dont add value should be dropped 100%. However, would all problems just go away? 

Regulated Industries like Financial/Fintech, Insurance/Insuretech, HealthCare/HealthTech requires more care in sense of security. However pretty much everybody else It's very likely your PII(Personal Identifiable Information) will be in form of plaintext(unencrypted) in your databases. When I use the word Encryption I mean Symmetrical encryption. Asymmetrical encryption often used for Certificates and Files. When we have data in our Datastores(Relational, Non-Relation, New-SQL, or BigData) we often rely on symmetrical encryption. Symmetrical encryption is being around for many decades. AES (Advanced Encryption Standard) is one of the most Standards. So if there are standards why encryption is hard? Security/Encryption it's a cross-cutting concern which is hard for lots of reasons and also ends up introducing other engineering challenges. Cloud computing also it's another force that will eventually more and more push companies to deal with security and therefore encryption. 

GraphQL it's an interesting approach for Data Aggregation. GraphQL is a query language API for existing data. You can leverage all your REST APIs and existing data sources. GraphQL it's mobile-friendly and you can ask literally just the fields you need. GraphQL also allows you to share queries and there are clients for pretty much all languages. GraphQL allows you multiplex and de-multiplex multiple requests in one, being really great for tail latency and nice for data-intensive applications. However, not everything in graphql is flowers and I dont want to paint a rosy picture. There are issues and tradeoffs you need to take into account. I highly recommend you read these 3 series of posts I made comparisons with other approaches like BFs. BFF and GraphQL Dilemma part 1 , part 2 , and part 3 . Today I want to share a video I made where there is a GraphQL Server written in Java and we have 2 clients one Written in Go Lang and the other written in Rust. So Let's get started....

Kafka Streams is a Streaming library similar to Spark and Flink which works with Apache Kafka. Kafka stream can be useful to process historical and near-real-time big data workloads but also for non-realtime analytical computations at scale for the online world as well. Kafka-Streams is elastic, highly scalable, fault-tolerant, and fully integrated with Kafka. You can use Kafka Stream with Java, Scala, Kotlin JVM applications and also have exactly-once processing semantics. Kafka-Streams is being used by the New York Times, Pinterest, Line, Trivago, Zalando, and many other companies. Today I want to share a video of Kafka-Streams running with Kafka 2.6 and Java JDK 15. So Let's get started. 

gRPC is a high-performance universal RPC framework. gRPC has support for interoperability between several languages such as Java, C++, C#, Go, Dart, Kotlin, NodeJS, Objective-C, PHP, Python, Ruby, Rust, and many more. gRPC has a schema for service definition and it can generate code based on that schema. gRPC also supports bi-directional streaming and authentication with HTTP/2 protocol. gRPC is battle-tested by Square, CoreOS, Cisco, CockroachLabs, Netflix, and many other companies. gRPC is also part of the CNCF project. Today I want to share a video made with gRPC and Java. So Let's get started. 

Cassandra is a kick-ass database. It's reliable and works pretty well for insert heavy workloads. Cassandra does well with reads as well as long as you design your tables with your access patterns in mind. In order to work well with Cassandra, you need to avoid Tombstones either by avoiding deletes and updates or by avoiding collections. Cassandra cluster configuration and distribution can be tricky and also repairs can be a challenge at scale. K8ssandra is a complete Cassandra distribution with observability( Grafana and Prometheus ) and a simple solution for repairs called Reaper . You also need to keep in mind that by using Cassandra in containers you will lose throughput. Let's say you want to explore Cassandra and you are already using kubernetes or you have a tier 2 or 3 need or even want to save some cost in your development environment that could be an interesting solution. Today I will show how to install K8ssandra in Minikube.

Akka is a kick as technology. Today I want to share a video I made about how we can model an actor system using Akka, Scala, SBT, and IntelliJ Idea. We will model a vending machine using Akka and Scala. We will take advantage of the Scala Type system and Akka typed actors. Type Systems are great because they make programming more secure and prevent bugs and require less testing since the compiler does more for you. For this video, we also will be using SBT 1.4.0, Scala 2.13, and Akka 2.6. So I hope you guys like it. So let's get started!

To be 100% clear this post is not about Java Garbage collector neither Java getting your money :D. Java 8 introduced Collectors, but still most engineers just barely know them. Collectors are pretty useful if you are working with Streams. According to the book Effective Java 3rd edition, you should not abuse from Streams but unfortunately thats, not the reality. However, if you still have fit you stream code in a few lines of code Collectors can be handy and save you some additional transformation steps. Most people when they know collectors they tend just to use the toList() collector but there is much more to explore. Today I recorded a video showing some other collectors' features with you guys. I hope you like it. Let's get started. 

  It's time for another Linux Terminal Goods post. This is post #6 of the series of posts about cool, productive Linux terminal tools for Engineers and DevOps Engineers. If you did not read the previous posts(there is lots of cool and useful stuff there) I recommend you take a look now: I , II , III , IV , V .  So without further due let's get started and checkout 5 new cool commands/programs for you! 

UML . Ouch. OK, Diego don't you have some newer or shinny or sexy to talk about. Well, it's 2020 right? So jokes apart.  UML is modeling language from the 90s. Software Architecture and Software Engineering evolved a lot in 30 years. So is UML still relevant? IMHO Yes and No. The part that I dont think it makes sense is the notation part of the formalism part. Visual diagrams can be simple enough to be understood and you can survive without notation language. So if UML is not about the notation what is about? Or why there is value in UML in 2020? Questions that I intend to Answer in this very blog post - Let's get started.

  So if you read my previous post , I saw saying that for Platform / DevOps you dont want to have 1 single team but several small teams actually. However, when we are talking about Product Teams I believe we need to go the other way around. Could we have small teams in the product and yet be a good thing? Well depends. IF the Product teams are completely autonomous and selling their own product or completely independent module in sense of the business (Meaning autonomy is a business construct). Well for that case yes, have smaller and more teams will make sense however in practice what happens is the other way around. What happens is that many small product teams tend to create small microservices with have dependencies on each other and at scale, it becomes more problem they benefit. In order words, business verticals or bigger scoped SOA Services would make much more sense and also would fix several problems that small services at scale tend to create. If you want to know more ab...

DevOps it's a mindset, Skillset and it's not a Department. It's very common to see in the technology industry Centralized and Unique DevOps/Platform Teams. IMHO we are still not there. Most companies are still catching up on AWS and DevOps Engineering skills such as (Networking, Terraform, Observability, OS/Linux, etc...).  So DevOps centralized teams tend to be "Gate Keepers" for good practices and hygiene and several times cost zealots. That's is fine and has value, dont get me wrong. However several times unique and centrlized teams are just a pure form of a bottleneck. AWS has great infrastructure and tons of purpose-built services, I would argue most of the time you dont need to build anything in front of it. Using AWS directly could be coupling but as long as you use open APIs you should be fine. Several years ago I use to be bottered by coupling solution with ORACLE and with AWS the coupling is much bigger, not sure if any company would ever leave AWS, ...

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. 

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 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.  

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.

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. 

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. 

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 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 ap...

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...

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!

SOA it's all about Services. Services are the first-class citizen and there is no mistake in that decision. Some problems requires shared libraries and thats fine, however, I would say most of the internal shared libraries are not needed and they only cause trouble and little benefit. There is plenty of abuse of shared libraries and we need to start to recognize that we need to reduce the number of shared libraries and do fewer libraries and accept more code duplication and others from os package solutions. Shared libraries tend to spread and as a side effect, they create lots of binary coupling, complexity, and maintenance issues that kill any real Service/Microservice benefits. Services require flexibility and freedom to upgrade and release in different schedules. You might not realize but Shared Libraries are killing services and making them just a big complex distributed monolith . That's not the first time I blog about, but I still think the industry still did not get this...

So this is 3rd part of the series of BFF Dilemma. If you did not read part 1 and part 2 I highly recommend read them before continuing with this one. GraphQL is a kind of BFF I would say. BFFs then to be more flexible and allow all sorts of programming models and techniques. GraphQL is Data-Driven and has fewer options in a sense of flexibility. However, GraphQL is an interesting solution that could be used as a BFF solution or in conjunction with a standard BFF solution. Several people wonder if GraphQL is the natural replacement of REST. There are all sorts of comparisons with SOAP vs REST vs GraphQL. IMHO GraphQL is not the REST replacement I would not expose APIs only with GraphQL ONLY for all sorts of reasons. 

Testing is important. However, not all designs are testable and somethings we end up not being able to test things. A good design is always testable but not all testable code means you have good design. Sometimes we need to deal with old libs, old systems, 3rd party, or some active lib that is used a lot in your company that you cannot refactor. Not all tests have value however we need to be to test things which sometimes can be very very challenging.  Powermock helps us to test things that were impossible before.  Today I made a short video to show Powermock in action. So let's get started. 

Previously I was blogging about the BFF dilemma . I want to continue to explore the subject because I find it very interesting and I believe they're still a lot of things to explore on the subject. BFFs are super popular nowadays, for several reasons, mainly I would because of the nature of modern products.  If you have a digital product is very likely you will need to ship your problem in at Least 3 platforms (Web, Ios, Android) somethings even more platforms and specialized devices like TVs, Tablets, IoT, Arduinos and much more. Also, microservices were a big force pushing for BFFs since the services are "micro" and code need to live somewhere. It's really interesting when we think about them since we have so many options and places where our code can live. 

I always had mixed feelings with Agile. Mostly like it but I think some disciplines were always left behind like Architecture and Design. There is another discipline which often times I think we need to do more which is analysis. There is a huge relationship between Analysis and Being Data-Driven. Amazon is a Data-Driven company. There is no sense to just collect data and do nothing with it. So analysis is an old and yet important discipline. But what being data-driven means? Well, it means a bunch of things it could be from a Deep Dive analysis or simply rely on industry data or evidence of someting rather than just opinion.  So you might be wondering why we dont do more of that? That's a good question and I believe there are a couple of reasons. 

Engineering means coding. However how many times do we consider proper error handler? Most of the languages like Java, .NET, Python, C++ can be a very trick in the sense of handling errors. Business validations are like tests but they are hardcoded on the software and run part of the main flow of our applications. We need to worry not only with the "Happy Path" but also with the "What if" moments where things might not happen as we expect. There are many different opinions and options around in sense of validations, exceptions, and error handling especially in a language like Java. Error handling, Exceptions, and validations are a critical part of making systems more reliable and hardening production I would argue. Amazon Builder library talks about that in the context of avoiding Circuit Breakers and hardening the main execution path and make running code more reliable. 

The software industry is always becoming more specialized. We have backend engineers, frontend engineers, edge engineers, cloud/DevOps engineers and I'm sure we will have more specialization in the future. With specialization and growth on systems, we end up having more layers or places that we can put software. Microservices often end up making a huge proliferation of services at the backend(check out Uber case for that).  There are so many places that you can "put" your software but one particular place that is growing a lot is the BFF(Backend for Frontend)  place. Often we have different stacks for backend and frontend. Frontend often is on JavaScript or TypeScript. Backend is often in Java, .NET or Go. So the first dilemma is, is BFF a frontend thing or a backend thing? IMHO it's a frontend thing where frontend means consumer. So how different BFF is from a driver or client? Well if you look into drivers and clients they often dont have network logic like routing,...

Often successful companies have significant growth. Meaning: grow in structure. More people, more departments, more managers, more coordination and often more overlaps. Enterprise companies always end up having some form or governance issue. I remember at the beginning of the SOA world "Governance" was a very bad word and there was abuse. After 3 waves of Agile manifestation, we are with much less "Governance" look like we still have plenty of abuse. Abuse can be also called WASTE(Lean Concept). Some rules can really promote best practices and better software like: Do not share your internal data stores, Expose data via Common Interfaces like (HTTP / gRPC).  Systems tend to grow and get more complex as companies grow with them. Every single improvement(refactoring) often means more investment($$$) which also can be saying as business entropy as the time passes it only gets worst(more complex and more expensive). When we analyze refactorings individually(business imp...

So before the COVID-19 every single company out there was seeking to be digital and to transform the way they operate and improve the products. Right now I'm sure lots of companies regret their investments in the past however several companies dont have money to invest and improve things right now and thats fine. I'm and I always was a big fan of new technologies, new languages, new servers, new approaches to problems. However, new shiny things have issues  and drawbacks and sometimes take time to figure them out, look microservices for instance. However we tend to think we always can innovate, we always can do new things. But before we jump to new things, are we doing the old things right? Are we sure there is space for more innovation? So basically we can see innovation as a gold rush, there some much gold you can mine. That thought I was blogging about 6 years ago . There are lots of technology floating us with several applicability issues Blockchain for instance. 

Building products(software) is hard. There are so many things that can go wrong. At Scale, everything becomes more laborious. More people, more coordination needed, more things that can go wrong and more pieces and more dependencies. To scale, we create team structure and software, often in the form of SOA Services. Any architecture or Design should survive a set of hard questions; otherwise, the idea or solution might not be good enough. Having people thinking into different dimensions, with varying points of view and various schools of touch, would create disagreement with could be an excellent and healthy thing. However, not always thats is the case.

Github is an amazing platform. Today I want to show in a video 2 super killer features which is: Pull Request Template and also Branch protection with CODEOWNERS. This feature makes the PR Reviewer life much better and improves documentation, learning, save time, and just push the team to a much better direction. Sometimes people might create too much bureaucracy, however, the other extreme to have no comments in chaos and not good. So we need to look for some sweet middle ground. So Let's get started. 

I really like blogging. I believe everybody should blog, it's really good to learn and improve skills and also share with others. I talkd with several people across the years that always have doubts about blogging, like OH I dont anything interesting to say or I did not perform anything unique.  I believe people have different experiences and always can add value therefore there is value in expressing those experiences. Today I made a video and I want to share with you guys a bit more about my writing process.  Video Cheers, Diego Pacheco

Terraform is a great DevOps tool. Terraform has support for Custom Module which is a killer function. Functions allow you to take much more advantage of Terraform and avoid the right custom code in bash or other languages. Today I made a video showing some functions in terraform like how we can work Custom Module. So Let's get started.

Terraform is a great DevOps tool. Terraform has support for Dynamic Provisioning which is a killer function. Functions allow you to take much more advantage of Terraform and avoid the right custom code in bash or other languages. Today I made a video showing some functions in terraform like how we can work Dynamic Provisioning. So Let's get started.

Terraform is a great DevOps tool. Terraform has support for Dynamic Resources which is a killer function. Functions allow you to take much more advantage of Terraform and avoid the right custom code in bash or other languages. Today I made a video showing some functions in terraform like how we can work Dynamic Resources. So Let's get started.

Terraform is a great DevOps tool. Terraform has support for functions  which is a killer function. Functions allow you to take much more advantage of Terraform and avoid the right custom code in bash or other languages.  Today I made a video showing some functions in terraform like how we can work with external JSON files and use functions. So Let's get started.

Line by Line coverage can be very tricky. Many companies rely on line coverage as metric signals however you can easily have waste with that kind of metric like Getters/Setters, Database Calls, etc. The other issue is that kind of tools can be easily gamed.  The mutation test is not a new idea, it appears in the 70s. The main idea behind mutation testing is to test your Tests. Therefore harden your application solution and tests. The mutation test has the concept of mutators . Mutators are bugs and they should be KILLEd if they SURVIVE it means you have bugs in your code that your tests are not catching. Mutants are much harder to fool unlike line coverage tools. Today I want to share a hands-on Refactoring video I made using Pitest .  So Let's get started.

Java is an old language. 25 years now. Java has several limitations and issues however java is the robust and pretty well-stablished solution for backend, databases, Caches, Search Engineers,  IoT, and much more. Today I want to share some patterns about object creation. I highly recommend you read Effective Java book, which was a huge inspiration for this blog post. So I want to show you guys some useful patterns like Static Factories, Builder, Singletons and Immutable Objects.  So I made a quick video with code, let's get started. 

Design Systems are pretty popular nowadays. As you company grows and has multiples apps/sites and products you new have a consistent experience across your brand. Having components is a great architectural pattern to help you to deliver the design system to code. However coding tests for a design system component can be very time consuming and super expensive.  IF you are using React, Jest is really your natural choice. Jest can let you do both Example based testing but also Snapshot testing. Snapshot testing can be amazing or complete waste really depends on what you use for. For Error messages snapshotting testing be super useful but for testing design system components is IMHO the killer use case. Jest has great tooling and make you life as an engineer, dealing with snapshots super easy and fun. So I made a video about Jest and React. Let's get started. 

Software Design is a super important discipline. However, Design is often made by accident. Software Design is really needed because there is a huge cost associated with some changes further down when you have a scale and lots of software. Lots of engineers dont understand design or understand it on a superficial level. Software design is on the core of everything we do in software and I believe we need to talk bout this super important discipline. So I made a slidecast talking about the subject. Let's get started. 

Testing is important. Unit testing makes a lot of sense for Backend where we have business logic, however, for frontend, I would argue the value is not exactly the same. There is a concept called Property-Based Testing that comes from functional programming which is super useful. It makes the engineering life much easier and not only saves time typing but also makes your tests more robust with really not much more effort. So today I made a very short javascript / nodejs video talking about JSVerify . So Let's get started. Video Code https://github.com/diegopacheco/Diego-Pacheco-Sandbox/tree/master/scripts/node.js/jsverify-fun Cheers, Diego Pacheco

Quarkus is a super interesting project.  IMHO Quarkus is JEE done right. It's super-fast, relies on Netty, uses GraalVM . Today I want to share a video I made about Quarkus with Panache using the Postgres database running on Docker. So Let's get started.  Video Code https://github.com/diegopacheco/java-pocs/tree/master/pocs/quarkus-hibernate-panache-fun https://github.com/diegopacheco/java-pocs/tree/master/pocs/quarkus-jpa-mysql-fun Cheers, Diego Pacheco

Kotlin  is a Jetbrains language that has lots of inspiration from Scala. Spring-boot-2 is a popular solution for microservices like Quarkus and Micronaut . Today I want to share a simple video I made so you can get started with Maven, Spring-Boot-2, and Kotlin. If you are new to Kotlin I also recommend seeing my previous post about the language. Okay, let's get started. 

Kotlin is a JVM language created by JetBrains in 2011. Google declared the official preferred language for Android in 2019. Kotkin is heavily inspired in Scala . Kotlin claims to have the good parts of scala without having the bad parts. It's also possible to see some Python and Groovy influence as well. Kotlin makes java much less verbose and has awesome support in sense of IDE thanks to IntelliJ. I'm a Scala guy and prefer scala, however, kotling is an interesting choice especially if you are making android native apps. So today I want to share a video I made with a good walkthrough through several features of the language in a Maven project. So Let's get started!