CodeIsGo.com

Adam Warski blog post explaining real time processing with Apache Kafka and what its’ new major feature - exactly-once semantics - really means. This announcement caused a stir in the community, with some claiming that exactly-once is not mathematically possible.

Author explains and analyses how you can construct an exactly-once pipeline in Kafka, with an emphasis on where the new features come into play, what kind of guarantees you get, and more importantly, what guarantees you don’t get.

It is possible to create a pipeline where, at each stage, the result of processing of each message will be observed exactly-once, as far as Kafka is concerned. Author then focuses on:

• Producer and its’ crucial feature is idempotency
• Pipeline stages and how atomically write data to multiple topics and partitions
• Consumer and how it can be transactional
• Side effects

Worth your time!

Amr Abdelrazik published blog post in which he compares 3 popular open source projects - Docker vs. Kubernetes vs. Apache Mesos and summarizes why what you think you know about them is probably wrong.

Instead of comparing the overlapping features of these fast-evolving technologies, author revisits each project’s original mission, architectures, and how they can complement and interact with each other.

Quite good comparison with bit more information about Apache Mesos. Author points out that container orchestration is only one example of a workload that can run on Mesos’ modular architecture, and it’s done using a specialized orchestration “framework” built on top of Mesos called Marathon. But it can also run:

• Monolithic and legacy apps
• Data services and analytics
• Containers - microservices architecture

Whatever you choose, you’ll be embracing a set of tools that makes more efficient use of server resources, simplifies application portability, and increases developer agility. You really can’t go wrong.

James Buczkowski post on hot topic of Observer pattern in JavaScript. The observer pattern, also referred to as the publish/subscribe pattern, is a design pattern where an object (called the subject or observable), will maintain a list of “dependents” called observers. Upon a state change, this subject will notify any of the observers automatically.

There are usually 3 methods involved. One method to register an observer. One to remove an observer. And finally, one that will notify the list of subscribers of the change.

If you work in the world of React, you have probably dealt with Redux to manage the state of your application.

Author then discuss polling and push as 2 main means for class when it needs to keep track of something, or better yet, know when something has happened.

Video (~50 minutes long) is also attached with good summary of the Observer pattern together with the link to a book. Plus example code. Good read.

Alagesan Palani tutorial explaining how to make your AWS instance safer by automatically generating LetsEncrypt certificates. Conveniently.

LetsEncrypt is a free certificate provider and myriads of tools and technologies available to automate its certificate generation.

In his solution, he uses HA proxy. You learn how to create Ansible inventory for a proxy server. All the tasks described assumed to have appropriate aws_access_key, aws_secret_key and region setup properly. For proving that you own domain you will be using a dns-01-based challenge, as this is pretty straightforward with AWS Route53, and the dehydrated client can automate that.

He then describes and provides playbook example code for:

• Installing LetsEncrypt/Dehydrated client
• Configuration of the client
• How to generate certificates and
• How to apply certs to HAProxy

Straight to the point tutorial. Nice.

Lars Schmidt article on developing soft skills as main driver for propelling your career. It used to be that the only way to climb a career ladder was to pick up more skills. Today, many of those ladders have fallen and shattered.

In order to move up, over, side to side, and double back when you need to, all while making your way upward, the trait you need most is adaptability, not this or that tech skill. He also advice to focus on:

• Your network is a job skill
• Hit up alumni - tap your university resources and LinkedIn
• Rethink Twitter
• Map it all out - find a person for every passion

And never stop giving. More than any technical skill, one of the best ways to advance your career from the very beginning is to start thinking of networking as part of your day job–even before you land one. Worth a read!

Queirozf.com published this straight to the point tutorial describing how to use Amazon Web Services CodePipeline to deploy and build your app automatically when it is stored on Github as a Docker-based Beanstalk application.

Roughly speaking, CI/CD amount to having an automatic pipeline that compiles, builds, tests and optionally deploys your project every time a new version is finished. This goes hand in hand with philosophies such as agile development and microservices architectures.

Tutorial then describes:

• AWS CodePipeline consisting of 3 parts
• Config files for build definition
• A file specifying where to fetch the Docker image file, which you will use on ElasticBeanstalk
• How to setup CodePipeline pipeline
• How to create a repository for your Docker images on AWS ECR
• How to configure Buildspec.yml and Dockerrun.aws.json

Article also lists other resources to help you with the task in your hands.

Nathan Peck short article and tutorial on topic of high performing nginx reverse proxy in container. The post explains the benefits of a reverse proxy, and explains how to use nginx and Amazon EC2 Container Service (Amazon ECS) to easily implement and deploy a reverse proxy for your containerized application.

Sidecar containers are a common software pattern that has been embraced by engineering organizations. A sidecar container is simply a way to move part of the core responsibility of a service out into a containerized module that is deployed alongside a core application container.

Author then describes how to use:

• Reverse proxy for security
• Reverse proxy for performance

Running a sidecar container such as nginx can bring significant benefits by making it easier to provide protection for application containers. Example code for nginx config and ecs config are provided. Good reading.

Sage Gerard wrote this interesting article about using git flow with creative writing. Randy Ingermanson’s Snowflake Method makes you start from a crude, yet complete one sentence story and iterate until you are left with a good story.

Snowflow branches behave analogously to their git-flow counterparts, with some added expectations.

• The master branch holds a project that com­piles to PDF and tells a complete story
• An elaborate (develop) branch adds detail to the story
• A concept (feature) branch introduces at least one unique, self-contained concept
• A review (release) branch holds a complete story for review. If the story is of sufficient editorial quality it may merge to master.
• A reconcile (hotfix) branch fixes pressing logical errors such as plot holes.
• A seed (support) branch addresses circumstantial concerns such as differences in story arcs or fictional universes.

Whole article is detailed and interesting read.

Although it seems like documentation should be treated like other features worked on by a Scrum team, frequently it is not. When tech writers try to integrate into engineering Scrum teams, they usually run into a host of challenges. Excellent two part article from Tom Johnson.

In series of articles author reflects on the right integration model for tech writers in software shops that follow Scrum, especially in large companies. Should tech writers try to integrate into Scrum teams just like the other members? He then goes and explore basic mechanics of following a Scrum model (attend daily standups, attend sprint planning, attend retrospectives, etc)

He also points out how tech docs and agile remains one of the hottest discussions in tech writing. Then he describes his experience in detail including:

• floating across multiple projects
• variation across project teams makes for inconsistency
• how scope doesn’t apply to doc tasks
• no co-location means you miss out on undocumented details
• Scrum seems to encourage product-centered documentation
• working in Scrum versus working with Scrum

Excellent article, highly recommended.

Sascha Grunert from quapona take on lief in a containerized world. Applications are getting larger and larger but still need to be as modular as possible. Modularity will boost companies by allowing smaller development teams and giving the possibility to reuse application parts for different kinds of products.

At quapona they call these solutions Self-Contained Systems (SCS). A SCS should work as a whole software solution for a certain problem by splitting it into single parts. One Self-Contained System could consist of:

• the storage solution (Data)
• the storage driver (Logic) and
• the application which generates the data to be stored (Interfaces)

And how this can be achieved? They’ve even built Microservice template which you can utilize to built you architecture built on well known technologies:

• Go: As main programming language
• GRPC: As an interface to another Microservice
• GoMock: As mocking framework for unit tests
• Docker: As containerization solution
• Kubernetes: As module and integration testing, container orchestration and deployment solution