CodeIsGo.com

Introduction into Phoenix LiveView by Jean DerGurahian. A frequent goal of web development is to create meaningful, satisfying user experiences through robust web applications. LiveView-powered applications are stateful on the server with bidirectional communication via WebSockets, offering a vastly simplified programming model compared to JavaScript alternatives.

The best part: Using Phoenix LiveView means programmers no longer having to write JavaScript and manage complex client-side interaction development to build web apps. For organizations looking for fast, high-performing software to power their websites, Phoenix LiveView provides rich, real-time user experiences while reducing costly development processes.

Because this stateful cycle is built on Elixir, a platform made for stateful systems that can handle millions of connections, updates can be pushed to the client in a cost-effective manner. This process can’t be done over stateless HTTP.

Very interesting read together with link to Chris McCord Keynote on youtube!

Taz Brown (from Red Hat) wrote this post in which she explains how automating ACL management with Ansible’s ACL module is a smart way to strengthen your security strategy.

ACLs allow regular users to share their files and directories selectively with other users and groups. With ACLs, a user can grant others the ability to read, write, and execute files and directories without leaving those filesystem elements open.

Ansible can play nicely with ACLs, just as it does with a lot of features, utilities, APIs, etc. Ansible has an out-of-the-box ACL module that allows you to create playbooks/roles around granting a user access to a file, removing ACLs for users on a specific file, setting default ACLs for users on files, or obtaining ACLs on particular files.

You will also get an example Ansible playbook which can scale across your infrastructure to increase speed, improve efficiency, and reduce the time it takes to achieve your goals. Applying ACLs to files and users is a practice you should take seriously in your role as a DevOps engineer. Great!

An article by Martin Nally from Google about how expressing relationships is very important in APIs. The most common way that API developers express relationships is to expose database keys, or proxies for them, in the fields of the entities they expose.

However, at least for web APIs, that approach has several disadvantages over the alternative: the web link. Standardized by the Internet Engineering Task Force (IETF), you can think of a web link as a way of representing relationships on the web.

Links can appear in API resources too, and using them instead of foreign keys significantly reduces the amount of information that has to be separately documented by the API provider and learned by the user.

A link is an element in one web resource that includes a reference to another resource along with the name of the relationship between the two resources.

Source: https://cloud.google.com

The article then explains:

• Representing relationships using foreign keys
• Representing relationships using links
• Caveats with relationships using links
• What’s the best way to write links in JSON?
• What’s the difference between an attribute and a relationship?

Replacing all the database keys with links is a fairly simple change and it significantly simplifies the API and reduces the coupling of the client and the server. The server is now free to change the format of new URLs at any time without affecting clients (of course, the server must continue to honor all previously-issued URLs).

Excellent!

Kasun Indrasiri (director of Integration Architecture at WSO2 and is an author/evangelist on microservices architecture and enterprise-integration architecture) provides article full of insights into potential new use for Service Mesh. The current popular implementations of service meshes (Istio, Linkerd, Consul Connect, etc.) only cater to the request-response style synchronous communication between microservices.

There are two main architectural patterns for implementing messaging support within a service mesh; the protocol proxy sidecar, which is a proxy for all the inbound and outbound events from the consumer and producer; and the HTTP bridge sidecar which translates or transforms event-driven communication protocol to HTTP or similar protocol.

Regardless of the bridging pattern that is used, the sidecar can facilitate the implementation (and correction abstraction) of cross-functional features such as observability, throttling, tracing etc.

The article discusses in detail:

• Implementing event-driven messaging
• Protocol-proxy sidecar
• HTTP-bridge sidecar
• Key capabilities of an event-driven service mesh

Excellent read, please follow link to the original article!

Quick summary from Aniruddha Chaudhari about Stack and Queue. With stack and queue data structures, it is very easy to solve even complex programming questions.

For the sake of simplicity, author define stack and queue as the collections of the objects, just like an array in the data structure.

What is a Stack?

The stack is a data structure where the user can add a data object any time. But, the user can only remove the data which is added at last. The stack follows LIFO (Last In First Out) mechanism.

What is a Queue?

The queue is a data structure where the user can add data object at any time. But the user can only remove the data which is added first. Unlike stack, the queue follows FIFO (First In First Out) mechanism.

The article then also explains:

• When to Use Stack vs Queue?
• Difference Between Stack and Queue by their operations
• Push Operation on Stack
• POP Operation on Stack
• Enqueue operation on Queue
• Dequeue operation on Queue
• Memory Usage Comparison of Stack and Queue

… and more. Stack and queue have similarity as they stores the collection of data objects. Good read!

Process for a product team can be suffocating, or process can be liberating. And no process at all? Well that’s fun for maybe a week or two before everything starts to fall apart. Interesting read by Brian Donohue from intercom.com.

Their goal was to arrive at the minimal process that gives teams a framework to plan and structure their time, and most importantly, to prioritise and make the best tradeoffs.

Previously, they thought about building product over three timelines –- 6 weeks, 6 months and 6 years (catchily referred to as the “666 mindset”).

You should be releasing product the whole way through a cycle.

The article then explains:

• Why the 6 month timeframe didn’t work
• 6 week cycles are about execution
• Goals, not plans
• Accountability matters
• They’re not delivery cycles
• 6 weeks is the Goldilocks of timeframes – just right

Interesting how their planning and commitment timeframe is 6 weeks, but they don’t use that to artificially constrain projects. One project might be designed, built, and released in just a couple weeks, while others will span across a couple of cycles. You should be releasing product the whole way through a cycle. Sweet!

In this article you will learn all about Cross-Origin Resource Sharing, the circumstances under which it is needed, the benefits it provides, and how to configure a Node + Express application to support CORS. Written by Steve Hobbs.

Cross-Origin Resource Sharing (CORS) is a protocol that enables scripts running on a browser client to interact with resources from a different origin.

This is useful because, thanks to the same-origin policy followed by XMLHttpRequest and fetch, JavaScript can only make calls to URLs that live on the same origin as the location where the script is running.

Author then describes:

• CORS - Why Is It Needed?
• Identifying a CORS Response
• Understanding CORS Request Types
• How to Add CORS to a Nodejs Express App

You will also get code examples and learn how to alter a broken Node + Express application so that it accepted cross-origin requests, and could successfully make API calls to a backend running on a different origin. Nicely put together!

An article by Dave van Herpen who led break out session during conference on Organizational Design. The objective of the workshop was to share practical do’s and dont’s on how to drive true organizational change towards self-organizing teams, to deal with the turbulent markets these organizations find themselves in. YThis was during a highly interactive event “Fit for the Future,” enabled by CIO Platform Nederland and the DevOps Agile Skills Association (DASA).

First, their group of industry leaders identified several bottlenecks, which currently block their organizations from adopting Agile and DevOps behaviors. Their main bottlenecks included:

• Product Owners are regularly overruled or passed by business owners
• Suppliers are either not used to or not stimulated to become self-organizing
• Teams face conflicting objectives and priorities from other teams
• There is always too much focus on the Development (Dev) teams during the transformation
• DevOps teams have no time to understand the needs of regulators

… and more.

After discussing these major bottlenecks, the group also defined multiple good practices to mitigate these potential bottlenecks, such as:

• Using explicit color coding in teams, to balance different types of work and varied interests
• Invite suppliers to (big room) planning sessions
• Create value streams with clear and shared goals
• Consistently include regulatory and compliance aspects in the prioritization

… and more. to get the full list follow link to the orginal article. Well done!

Ely Lucas published series of articles focusing on developing with TypeScript and explained benefits of using TypeScript on both the client and server, shared an introduction to NestJS. Following this series you will insights how to build a simple app.

TypeScript is a powerful language that is a superset of JavaScript, with some additional features added to help build out large scale applications.

Beyond type checking, TypeScript also helps you speed up your development by providing code completion and refactoring, as well as letting you use modern JavaScript language features that might not be available in all browsers yet.

NestJS (just Nest from here on out), is a Node framework meant to build server-side applications. Not only is it a framework, but it is also a platform to meet many backend application needs, like writing APIs, building microservices, or doing real-time communications through web sockets.

Ionic Framework is an open source UI toolkit for building performant, high-quality mobile and desktop apps using web technologies (HTML, CSS, and JavaScript)

In the article you will get all the needed info for:

• Getting started with Ionic and Angular
• The Nest Project Structure
• Your First Nest Service and Controller
• Create GoSpaceRanger Ionic App

Well written article for anybody interesting in Javascript and Ionic, with link to part 2 which brings TypeORM to the project. Nice one!

Tomas Fernandez created an article so you can learn about 7 tools that you can use to set up a rock-solid continuous integration (CI) process for your PHP project. Together, these tools increase code quality, reduce development time, easily reveal errors and will generally make your life easier.

The game plan is to setup various tests for our code, without having to provision or maintain any servers.

Author chose to implement CI process with Sempahore – the continuous integration and delivery platform hosted in cloud. At the time of writing Semaphore offers first $20 every month on them (up to 1,300 service minutes).

Further in article you will find detailed information how to set up:

• Code analysis tests
• PHP Code Sniffer
• PHP Mess Detector
• PHP Unit testing: phpunit
• Browser tests: Laravel Dusk
• Security tests: Sensiolabs
• Running Continuous Integration with Semaphore

With great continuous integration tools for PHP working well together, we can focus on our code with a peace of mind that code quality is ensured. Excellent!