CodeIsGo.com

Can’t connect to the server running in your container? Let’s see why, and how to fix it, starting with an example. By by Itamar Turner-Trauring.

This is hands on tutorial, explaining common Docker networking issues in case you are not able to connect to your Docker containers. To understand how to solve various networking issues, you need to know a minimal amount about how Docker’s networking works.

Source: https://pythonspeed.com/articles/docker-connection-refused/

In particular, this article will cover:

• Networking namespaces, and how Docker uses them
  • Networking without Docker
  • Network namespaces
• What docker run -p 5000:5000 does, and why our example above doesn’t work
  • Docker run port-forwarding (is not enough)
• How to fix your image so the server is accessible
  • The solution: listen on all interfaces

By default, containers run in their own network namespaces, with their own IP addresses. Links to more resources provided together with link to a book: Just Enough Docker Packaging. Nice one!

It may surprise you, but I was doing Personal Kanban before I created PAS. I then tried using Scrum on my life; that was closer to what I needed, but Scrum didn’t really solve my challenges either. So my “personal Scrum” evolved and became “my personal Agility” and eventually, The Personal Agility System™. By Peter Stevens.

No plan for the day survives the first call from a customer!

– Larry Pakieser

In Personal Kanban, you write your options on cards. Then look at your options, and reflect on the complexity of each task, what relationships are involved, when things are expected, etc. Fill up your “Doing” column, while respecting the work in progress (“WIP”) limit. In the examples, the WIP limit was set to three, which means that only three tasks may be in progress at a time. Other tasks have to wait until one of them is completed.

The article deals with:

• What do PAS and Personal Kanban have in common?
• Personal Agility is about you and who you want to become
• The Personal Agility Attitude
• Dealing with Distractions and Interruptions
• What are the key differences

In Personal Agility, the basic idea is to be aware of how what you are doing relates to what you care about. When deciding how to spend your time, be clear on what matters and why. The weekly “Celebrate and Choose” lets you to reflect on what you’ve accomplished – it is probably different that what you expected, but you pat yourself on the back anyway – and to choose items that serve a purpose that matters. Interesting read!

This article reviews some of the best practices when it comes to adding files to your own repositories. Resist the urge to add things in Git that will make it harder to manage; here’s what to do instead. By Seth Kenlon (Red Hat).

Know your repo - This is arguably Rule Zero for a secure Git repository. As a project maintainer, whether you started it yourself or you’ve adopted it from someone else, it’s your job to know the contents of your own repository. You might not have a memorized list of every file in your codebase, but you need to know the basic components of what you’re managing.

In addition to the usual POSIX tools, you can detect binaries using git diff. When you try to diff a binary file using the --numstat option, Git returns a null result

$ git diff --numstat /dev/null pixel.png | tee
-     -   /dev/null => pixel.png
$ git diff --numstat /dev/null file.txt | tee
5788  0   /dev/null => list.txt

The article then describes following practices:

• Know your repo
• Ban binary blobs
• Keep third-party libraries third-party
• Resist a blind git add
• Use Git ignore
• Review merge requests

Git is meant for text, whether it’s C or Python or Java written in plain text, or JSON, YAML, XML, Markdown, HTML, or something similar. Git isn’t ideal for binary files. Some great advice here!

A lean business model canvas determines your business model in a visually descriptive way. In the same way as the original Business Model Canvas, this “lean” version, ideal for startups, will help you construct your business plan more efficiently and help draft a business model for your idea or business. By wcic.tech.

Source: @wcic.tech wcic.tech/a-startups-lean-business-model-canvas/

The Lean Canvas is more suited to entrepreneurs and startups as it is more actionable by focussing on factors such as uncertainty and risk. The article describes:

• Lean business model canvas framework
• Solution
• Key metrics
• Unique value proposition (UVP) or unique selling point (USP)
• Unfair advantage
• Channels
• Customer segments
• Cost structure
• How is a lean business model canvas different to a business plan?
• Revenue streams

A lean business model canvas can be created in a day, is much more collaborative in its approach and provides structure and focus to early-stage startups. It’s a starting point on your entrepreneurship journey.

A business plan is great when you’re six months in and spoken to many people about your idea and looking towards investors. The problem with a business plan is that it can be very long and time-consuming. Great read!

Fastly (FSLY) has experienced an incredible run over the past several weeks. In this post author will spend time examining how Fastly has approached building new technologies in the past and what this might mean for their future edge compute offering. By softwarestackinvesting.com.

_Source: @fastly.com Fastly Q1 2020 Investor Deck, https://softwarestackinvesting.com/fastly-edge-compute-explained/

Since its founding, there has been something different about Fastly’s mind set. The Fastly team has a trait ingrained in their DNA to address hard technical problems with innovative and often more difficult solutions, with the goal to create a better experience for their customers. This was applied to the CDN business originally and is now manifesting in the design of a fast, compact, secure, globally distributed serverless compute platform.

The article is divided into:

• Applied to network design
• Distributed compute
• Cloud vendor competition
• Other Independents

Fastly’s solution for this distributed compute is called Compute@Edge and was announced in November 2019. “Edge compute” is really about providing a development environment for enabling large-scale, coordination-free distributed systems. These can run autonomously, anywhere outside of the origin. Providing the development platform to enable this type of distributed compute is Fastly’s vision for Compute@Edge. You will also get loads of links to further reading. Good read!

In every organization and in every industry, leaders play a critical role: managing teams, working together to make important (and sometimes difficult) decisions, and guiding an organization to move in the right direction. By Brian Eastwood.

While you might think of a leader as an experienced executive with a corner office, the reality is that successful organizations rely on employees who demonstrate strong leadership skills regardless of their job title or length of tenure.

If you are looking to enhance your leadership capacity, one important strategy for guiding your growth is to create a personal leadership development plan:

• Benefits of a personal leadership development plan
• Before the plan: conducting a self-assessment
• Elements of a personal leadership development plan
  • Core skills to master
  • Experience gaps to close
  • New relationships to build
  • Specific tasks to delegate
  • Key action items to complete
  • Critical indicators of success
• Beyond the plan: building leadership development into your role

And remember: take time to reflect. Leaders have a great deal of responsibility to juggle. Take 15 minutes every morning to assess the most important tasks for the day and 15 minutes in the evening to reflect on what went well and what could have been improved. Nice one!

Philipp Strube form Kubestack put together this article about Kubestack provisions managed Kubernetes services like AKS, EKS and GKE using Terraform but also integrates cluster services from Kustomize bases into the GitOps workflow.

Hashicorp recently announced better integration between Terraform and Kubernetes. Author took this as an opportunity to give an overview of how Terraform can be used with Kubernetes today and what to be aware of.

To be able to support different resources, Terraform requires providers that integrate the respective API. So, to create Kubernetes resources we need a Kubernetes provider. Here are our options:

• Terraform kubernetes provider (official)
• Terraform kubernetes-alpha provider
• Terraform kustomize provider

For teams that are already invested into Terraform, or teams that are looking for ways to replace kubectl in automation, Terraform’s plan/apply life-cycle has always been a promising option to automate changes to Kubernetes resources. However, the limitations of the official Kubernetes provider resulted in this not seeing significant adoption. Good read!

Setting up a new project can be a pain. Especially if you want to split it into separate folders for clarity. You might want a src folder for the project itself, a test folder for the unit and integration tests, a docs folder for documentation. By Simon Taite.

If you’re writing in F# you’ve probably long ago moved from NuGet to Paket, but the standard .NET templates still use NuGet so that has to be migrated. There’s build scripts to write too. It could be an hour or more of work before you start working on the code you actually wanted to write.

Enter MiniScaffold, a dotnet template that is for creating and publishing applications (supporting .NET Core 3.1) and libraries (supporting both .NETStandard 2.1 and .NET Framework 4.6.1

It’s designed and built to take care of the humdrum for you, it gives you:

• Clean and well separated folder structure
• Matching .gitignore file
• .editorconfig file tweaked for F# development
• Configures CI builds on Appveyor (for Windows) and TravisCI (for Linux and macOS)
• Fully configured build scripts using FAKE
• Integrated package management with Paket
• Integrated unit testing (Expecto) and code coverage reports (AltCover/ReportGenerator)
• Automatic code formatting with Fantomas

To get started, install the template and run few commands. Easy!

Each operation, even the smallest one, counts towards the performance and availability of a service. High performance and availability must be maintained without compromising the security of the system. By Paolo Insogna @nearform.com.

Keep reading to discover how the team improved the performance of JSON Web Tokens (JWT), one of the most common authentication systems, in Node.js. They created a new plugin, fast-jwt, to demonstrate and measure the Node.js performance improvements. Using flamegraphs, they compared fast-jwt on a sample Fastify server with the existing jsonwebtoken implementation. This blog post also outlines the architecture of fast-jwt, which includes caching and asynchronous support.

The article is split into:

• What is a JWT?
• Node.js implementation
• Performance of jsonwebtoken
• fast-jwt architecture
• Asynchronous support
• Caching
• Worker threads evaluation
• Performance comparison between jsonwebtoken and fast-jwt

The purpose of fast-jwt is to improve jsonwebtoken performance while keeping the same features and a similar API. To do this, authors established the following architecture principles:

• Minimise the number of external dependencies: except for the cache layer and a couple of small cryptographic utilities, fast-jwt has no external dependencies. This ensures the code is easily maintained and data flow can be followed.
• Use factory pattern and single ahead options verification: fast-jwt uses the factory pattern to create the signer, decoder and verifier functions. This ensures that all options (with the exception of the key, which might be fetched at execution time, depending on the options passed) are validated only once and only during the startup phase.
• Small public API: the public fast-jwt API consists of three factory functions (one for each operation) with a specific set of options.

Plenty of code examples thoroughly explained. Excellent job!

Welcome to tutorial no. 1 of our WebAssembly tutorial series. JavaScript has been the only programming language that the browser understands. JavaScript has stood the test of time and it has been able to deliver the performance needed by most web applications. But when it comes to 3D games, VR, AR, and image editing apps, JavaScript is not quite up to the mark since it is interpreted. Published on golangbot.bot by Naveen Ramanathan.

WebAssembly is a virtual assembly language for the browser. When we say virtual, it means that it cannot be run natively on the underlying hardware. Since the browser can be running on any architecture, it is not possible for the browser to run WebAssembly directly on the underlying hardware.

The existing JavaScript engines have support to run WebAssembly’s Virtual Assembly Code. WebAssembly is not meant to replace JavaScript. It is meant to operate hand in hand with JavaScript to take care of performance critical components of a web application. It is possible to make calls from JavaScript to WebAssembly and vice versa.

In this tutorial, we will cross compile a Go application to WebAssembly and run it on the browser. The article then describes following:

• What is WebAssembly?
• What are we developing?
• Hello World WebAssembly program cross compiled from Go
• Javascript glue
• WebServer
• Coding the JSON formatter
• Exposing a function from Go to Javascript

… and more. Plenty of code examples together with excellent explanation what is happening in the code. The source code for this tutorial is available here and there is part 2 odf this article available, too. Very insightful!