CodeIsGo.com

Andrey Redko published this guide how to implement microservices for Java developers. There is a variety of paradigms you may encounter while implementing the internals of your microservices.

The pace of innovation in Java has increased dramatically over the last couple of years. With the fresh release cadence, the new features become available to the Java developers every 6 months.

In the guide you will find code example and implementation of microservices using:

• Synchronous programming paradigm
• Asynchronous programming paradigm
• What blocking means in context of I/O
• Non-blocking in JVM ecosystem
• Reactive programming (programming with asynchronous data streams)

Short, but very informational post for seasoned developers wanting to learn more about microservices pattern implementations in Java world. Good work!

An article by Niklas Heidloff and Mark Sturdevant on hot Alexa skills topic. In it you will find how to create an Alexa skill with serverless and a conversation. Apart from Alexa you will also use Watson to discuss the weather, build a conversation, or choose one from a library.

Watson is a question-answering computer system capable of answering questions posed in natural language, developed in IBM’s DeepQA project.

In the article you will create an Alexa skill using Watson™ Assistant via the Apache OpenWhisk serverless framework. An example conversation is included to demonstrate how to pass context between different intents, resulting in a weather lookup.

To remember the conversation state and be able to request external actions, authors chose Redis to save the state across invocations of serverless functions, and they built an external action that retrieves the weather forecast.

When you complete this pattern, you will understand how to:

• Create an OpenWhisk action in the IBM Cloud Functions serverless platform
• Use Redis to store a session’s conversation context across events
• Import a conversation from the BAE or a JSON file
• Invoke a conversation with Watson using Node.js
• Use The Weather Channel data service to look up locations and forecasts
• Create an Alexa skill to reach tens of millions of customers

Flow chart, video demonstration and open source code in GitHub repository for all systems included. Amazing!

Harry from csswizardy.com shared this post about performance testing and where it sits within software development life cycle. Often performance testing ownership is not clear and this is a common reason why performance gets overlooked.

Author tries to distill the types of testing that we do into three distinct categories: Proactive, Reactive, and Passive. Each have their own time, place, purpose, focus, and audience.

The first kind of testing a team should carry out is Proactive testing: this is very intentional and deliberate, and is an active attempt to identify performance issues. This takes the form of developers assessing the performance impact of every piece of work they do as they’re doing it.

Reactive testing should be reasonably automated, and should be carried out in as live-like an environment as possible.

Reactive testing is usually done in response to an event in the development life cycle, such as a build or a release. You could use Gulp tasks that run Lighthouse against your staging environment, automated WebPageTests that run at every deployment, performance budgets that run on every build, and so on.

Passive tests to gather data over time and asses the situation: can we spot patterns? Do certain browsers or geographic locales suffer more than others? Do changes in performance correlate to changes in business metrics?

More information on tooling and charts accompanying explanations also in the article. Good read!

Blog post by German engineer Lars Lühr in which he focuses on CICD for Jekyll. Jekyll is a static web site generator written in Ruby. In this post he wants to provide a complete tutorial on how to automatically build, test, integrate and deploy a Jekyll site to a FTP server.

His setup evolves around:

• Git as preferred code version tooling
• Gitlab Git repository as central repository
• Gitlab CI Pipelines for build, test and deploy
• Web and FTP servers

For the deploy-to-FTP-part we will use GitLabs secret variables.

He then explains how to use rakefile (rake and bundle) is code written in Ruby. He defines the tasks which can be called. Also touches on GitLab CI Security preparations.

Complete configuration together with example code is available, also explanation how pipeline works, staging strategy and more. Nice one!

Madhan Ganesh post about mocking a class in JavaScript for the purpose of unit testing. The post targets developers who are coming to ES6 from environments that has features like dependency injection and interfaces.

Object is a first citizen in JavaScript land. The stunningly easy way to create an object makes this language simple to start. To create an object you start with object (and not class).

var person = {
  name: 'Velu'
};

Author then explains how to use:

• Constructor function
• Prototype as a mechanism to share a code
• ES6 class
• Mocking ES6 class

Basically to mock a method on ES6 class just get the reference of the function through class prototype and stub the same. Everything is well explained via code examples and link to the GitHub repository provided. Really useful for anybody new into ES6 JavaScript.

An article by Richard Li about service meshes such as Istio, Linkerd, and Cilium which are gaining increased visibility as companies adopt microservice architectures. Richard Li is the CEO/co-founder of Datawire, which builds open source tools for developers on Kubernetes.

The arguments for a service mesh are compelling: full-stack observability, transparent security, systems resilience, and more. ** Microservices aren’t free – they introduce new failure modes.**

The three core strategies for managing failure in a microservices architecture are proactive testing, mitigation, and rapid response.

If you have a small number of microservices or a shallow topology, consider delaying adoption of a service mesh, and evaluate alternative strategies for failure management.

If you are deploying a service mesh, be prepared to invest ongoing effort in integrating the mesh into your software development lifecycle.

This and more information about how to adopt service mesh or what to consider before adopting in the article. Excellent read!

Alex Castaño short technical post on their decision to use Elixir in production for their web site. MoodleNet empowers communities of educators to share and learn from each other to improve the quality of education.

They first did some research around languages for both frontend and backend development. After talking with people and reading a lot of information, they decided that they should use Elixir (Phoenix) for backend development.

The main points from the article boil to:

• Performance, ability to handle massive amount of requests
• Scalability, Erlang VM’s model of concurrency is great for multi-core CPU and scales easily to multiple machines
• Developer productivity & happiness
• Reliability, with almost no downtime, like having multiple levels of “supervising” processes in a system to reboot parts that have errors
• Concurrency

… and much more information in the article. Please click, to lean more!

Guide by by Alexey Klochay, developer at CircleCI, focusing on continuously deploying Clojure apps to Google App Engine. At CircleCI they use Clojure heavily, but when he wanted to use it for his side projects he realized that cloud provider he was using required too much overhead for infrastructure.

He started looking at alternatives that would give him CD right out of the box with as little configuration as possible. While Heroku was a good option, he was looking for something a bit more flexible, and ideally affordable.

Tutorial walks you through these steps explaining how:

• Set up a Google Cloud project and enable Google App Engine Flexible environment
• Create a service account and enable GAE API access
• Create the CircleCI project and add service account credentials
• Edit the project name in the CircleCI config and push it
• Gotchas

We found some interesting gotchas mentioned in the article worth mentioning: Java 8 doesn’t support cgroup-based memory limits which can lead to Docker killing the container if the memory usage surpasses the limit.

Find workaround and detailed information in this well written guide.

JBD from Google engineering team shared this guide and experiences how to migrate services to Google Cloud Functions (GFC)for golang.

The article provides reader with example of simple “hello world” to introduce the overall build and deploy experience with GFC. GCF expects an http.HandlerFunc to be the entry point.

In Go, we organize packages by responsibility. This also fits well with serverless design patterns – a function is representing one responsibility.

The article explains how:

• How to create and package dependencies
• How to organize the code
• How to chain handler (to utilize existing middlewares)
• How to (automatically) create traces for incoming HTTP requests

If you have external dependencies, you have to vendor them under the library package. This is possible by any vendoring tool. The dependency is vendored locally and function can be redeploy afterwards again.

Author recommends to create a new module for each function, provide function-specific other APIs from the same module. Common functionality lives in a separate module and vendored on the function package because GCF CLI uploads and deploys only one module at a time.

To learn more read that brief tutorial in whole!

Post by Ire Aderinokun focusing on CSS Grid Layout and about difference between grid-template and grid-auto. Mainly about the difference between grid-template-rows/columns and grid-auto-rows/columns. At face value they seemed to be doing almost the same thing.

The definitions of explicit and implicit grids can be a bit circular.

In the article you will find examples how to work with explicit and implicit grids. And also good explanation how grid-auto works. Because the structure and syntax of the grid-template-* and grid-auto-* property names have some similarities, it can be easy to think the values they accept and therefore what they achieve, are similar as well.

To summarize, the grid-template-* properties are used to create, place, and size cells for the explicit grid.

Any cell that exists in the grid that is not explicitly created by this property forms part of the implicit grid, which can be sized by the grid-auto-* properties. Good read for any frontend developer.