CodeIsGo.com

TLS, or transport layer security, and its predecessor SSL, which stands for secure sockets layer, are web protocols used to protect and encrypt traffic over a computer network. By Brian Boucheron and Jeanelle Horcasitas.

A self-signed certificate will encrypt communication between your server and any clients. However, because it is not signed by any of the trusted certificate authorities included with web browsers, users cannot use the certificate to validate the identity of your server automatically. A self-signed certificate may be appropriate if you do not have a domain name associated with your server and for instances where the encrypted web interface is not user-facing. If you do have a domain name, in many cases it is better to use a CA-signed certificate. You can find out how to set up a free trusted certificate with the Let’s Encrypt project.

The article describes step by step process:

• Creating the SSL certificate
• Configuring Nginx to use SSL
• Adjusting the firewall
• Enabling the changes in Nginx
• Testing encryption
• Changing to a permanent redirect

With TLS/SSL, servers can send traffic safely between the server and clients without the possibility of the messages being intercepted by outside parties. The certificate system also assists users in verifying the identity of the sites that they are connecting with. Good read!

Few Enterprise IT departments would dare select something else than AWS, Azure or GCP as their “infra baseline”.The Big three were careful to provide similar cloud offerings, but different enough so that regardless of which one you would choose, you would be signing off for a vendor lock-in from day one. By Veselin Pizurica.

Enterprise with an open API that is based on software components and services that are compatible with all clouds. Still, many people would argue that the lock-in is not as bad as it sounds. And that’s a fair point.

When making the vendor selection, big enterprises always ask themselves questions along these lines:

• Do we care about portability?
• Do we ever consider moving from one cloud to another?
• Are we required to provide solutions across different cloud platforms?
• Is there a strategic aspect we need to consider to be able to run our solution on-prem, or on custom clouds where being agnostic is important?

If the answer on any of these questions is affirmative, enterprises still need to go over “the build vs. buy” decision. Thousands of blogs and articles were written on how to build an automation stack on top of kafka, mongo, etc.. It all sounds very simple till it isn’t. To learn more follow the link to the full article. Very interesting read!

Every single company is looking for a chance to leverage breakthrough innovation to transform the market. We get inspired by companies such as Apple, Amazon, and Tesla, all of which have utilized cutting-edge technology or business models to achieve breakthrough innovation. By Heather Bakire.

From its name, it sounds like breakthrough innovation happens by chance, a sudden breakthrough that changes everything. But breakthrough innovation hardly ever happens overnight. Instead, it’s the result of careful planning and commitment to the long haul. In order to give your company the best chance at achieving breakthrough innovation in your industry, you need to strategize on how to build an innovation framework that takes into account your company’s goals and resources.

The article then covers:

• The four types of innovation
• Building an innovation framework for breakthrough innovation
  • Identify a problem
  • Propose solutions to the problem
  • Choose the best solution
  • Scale the solution to reach breakthrough innovation

Once you have the groundbreaking solution, it’s time to make it the focus of your company. You’ll probably need to have supporting innovations to make the breakthrough. For example, the light bulb needed an electric grid for it to become a breakthrough innovation. Interesting read!

TensorFlow.js, TensorFlow’s JavaScript counterpart library for training, executing, and deploying machine learning models in the browser. In an attempt to make TensorFlow.js accessible to developers with limited or no ML experience, the library comes with several pre-trained models that work out of the box. By Juan De Dios Santos Rivera.

A pre-trained machine learning model is ready-to-use machine learning you don’t have to train. TensorFlow.js includes 14 that suit a variety of use cases.

The arrticle is split into these sections:

• Prerequisites
• Creating the app’s interface and importing the required libraries
• Predicting with the pre-trained model
• Pushing the App to GitHub
• Deploying the web application in DigitalOcean App Platform

In this tutorial, you have built and deployed a web application that uses a TensorFlow.js pre-trained model. Your Question and Answer web app takes as input a passage along with a question and uses a pre-trained BERT model to answer the question according to the passage. Good read!

The employment landscape is constantly shifting. While agricultural jobs played a big role in the 19th century, a large portion of U.S. jobs today are in administration, sales, or transportation. So how can job seekers identify the fastest growing jobs of the future? By Jenna Ross.

The article main content is:

• How is the job market shifting over the next decade?
• The top 20 fastest growing jobs
• The top 20 fastest declining jobs
• Warning: Education required

Wind turbine service technicians have the fastest growth rate, with solar photovoltaic (solar panel) installers taking the third slot. The rapid growth is driven by demand for renewable energy. However, because these are relatively small occupations, the two roles will account for about 11,000 new jobs collectively.

Eight of the top 20 declining jobs are in office and administrative support. This could be cause for concern, given this category currently makes up almost 13% of employment in the U.S.—the largest of any major category. Jobs involved in the production of goods and services, as well as sales jobs, are also seeing declines.

Nine of the top 20 fastest growing jobs are in healthcare or related fields, as the baby boomer population ages and chronic conditions are on the rise. Home health and personal care aides, who assist with routine healthcare tasks such as bathing and feeding, will account for over one million new jobs in the next decade. Very interesting.

Microservices architecture has become a popular choice for developing software applications. In a microservice architecture, the microservices often need to communicate with each other. Compared to the traditional RESTful web API, a gRPC based RPC framework can be a better alternative for microservices communication. By Pankaj.

The article then captures:

• What is microservices architecture?
• Microservices inter-process communication
• Why gRPC for microservice communication?
• Advantages of gRPC
• Faster compared to JSON based RESTful APIs
• Strong type and well-defined interface
• Stream support
• Code sample
• Implementing gRPC client and server

… and more. gRPC based RPC framework is a great choice for inter-process communication in microservices applications. Not only the gRPC services are faster compared to RESTful services but also they are strongly typed. The Protocol Buffer, a binary format for exchanging data, is used for defining gRPC APIs. The gRPC is supported in many programming languages. You can find the working code example of this article at GitHub. Good read!

The emergence of modern web and mobile applications, based on microservices exposing HTTP APIs, has highlighted the need to effectively integrate, deploy, decommission, throttle, and securing a plethora of heterogeneous web APIs. By #Proud2beCloud @towardsaws.com.

Several companies and open source initiatives have developed API gateway solutions in order to meet the above requirements and expose a coherent API format for all the microservices composing the application.

https://miro.medium.com/max/700/0*BsAiLIEAnkmionH4.png

Source: @/towardsaws.com https://towardsaws.com/how-to-integrate-legacy-api-with-aws-api-gateway-proxy-9e1c52d35bab

In the context of API Gateway, API integration is the type of action performed by the gateway in order to respond to a given API request. The integration is invoked after the validation and authorization of the request (if configured/needed). AWS API Gateway (API GW from here on) supports several types of API integrations:

• HTTP integration (HTTP/HTTP_PROXY)
• Lambda integration (AWS_PROXY)
• Other AWS Service (AWS)
• MOCK integration

In this use case, you’ll typically have many API still hosted on the monolithic infrastructure and other APIs already migrated to AWS Lambda (with the AWS_PROXY integration) and/or AWS ECS (Fargate) behind a load balancer. Nice one!

This post is a part of a series on the Chromium rendering engine. The team is responsible for the web facing APIs for video playback like MSE and WebCodecs, and the platform specific internals involved in demuxing, decoding, and rendering audio and video. By Dale Curtis.

In this article, I’ll walk you through Chromium’s video rendering architecture. While some details around extensibility are likely Chromium-specific, most of the concepts and designs discussed here apply to other rendering engines and even native playback apps.

In the beginning, video rendering was quite simple - just a for loop choosing which software decoded video frames to send to the compositor. For years this was reliable enough, but as the complexity of the web increased, the need for more performance and efficiency led to architectural changes. Many improvements required OS-specific primitives; thus, our architecture also had to become more extensible to reach all of Chromium’s platforms.

![Chromium architecture evolution]https://wd.imgix.net/image/ZDZVuXt6QqfXtxkpXcPGfnygYjd2/IMFPhRwU3MKT1lEvfzIZ.png?auto=format&w=845 “Diagram of rendering flow to different Chromium platforms, Source: https://developer.chrome.com/blog/videong/")

Source: https://developer.chrome.com/blog/videong/

Chromium’s playback architecture has changed significantly over the years. While we didn’t start with the idea of a pyramid of success as described in the first post in this series, we ultimately followed similar steps: reliability, performance, and then extensibility.

We’ve focused on how Chromium takes advantage of OS primitives to deliver best in class playback experience. Very interesting!

Tony Robalik published the story of how to build thinks with Gradle, how to use the application and distribution plugins to build the app and bundle a distribution; how to use the shadow plugin to turn it into a fat jar.

The upshot is we turn a 1.5M jar into a 12K “fat” jar, shaving 99.2% off the final binary. This project is built with Gradle 7.1.1. This is important to keep in mind, as you would need to make some code changes if you were using Gradle 6.x.

The article then covers:

• The app
• The real code
• Building an app with Gradle
• Turning the app into a distribution
• Layering on the Shadow plugin
• Layering on Proguard
• The making of a skinny-fat distribution
• Publishing our minified distribution

All the code for this is on Github. This post is meant as a minimal example of how you might build a small Kotlin app with Gradle, which also had the requirements that it should have zero dependencies, be as small as possible, and be publishable for ease of access by potential users. Good read!

Concurrency and parallelism are similar terms, but they are not the same thing. This post looks at how to speed up CPU-bound and IO-bound operations with multiprocessing, threading, and AsyncIO. Older article by Amal Shaji.

Concurrency is the ability to run multiple tasks on the CPU at the same time. Tasks can start, run, and complete in overlapping time periods. In the case of a single CPU, multiple tasks are run with the help of context switching, where the state of a process is stored so that it can be called and executed later.

Parallelism, meanwhile, is the ability to run multiple tasks at the same time across multiple CPU cores.

The article also mentions:

• IO-bound operation
  • Sync example
  • Threading example
  • concurrent.futures example
  • AsyncIO example
• CPU-bound operation
  • Sync example
  • Multiprocessing example
  • concurrent.futures example

It’s worth noting that using multiprocessing to execute the make_request function will be much slower than the threading flavor since the processes will be need to wait for the IO. The multiprocessing approach will be faster then the sync approach, though.

Similarly, using concurrency for CPU-bound tasks is not worth the effort when compared to parallelism.

That being said, using concurrency or parallelism to execute your scripts adds complexity. Your code will generally be harder to read, test, and debug, so only use them when necessary for long-running scripts. All of the code examples in this post can be found in the parallel-concurrent-examples-python repo. Good read!