CNote

cnote

Introduction Jupyter Notebook is a popular tool among data scientists and programmers for interactive data analysis, visualization, and machine learning. In this guide, we will walk you through the process of setting up Jupyter Notebook on a Windows server to enable remote access. Step 1: Install Jupyter Notebook First, you need to install Jupyter Notebook on your Windows server. You can do this using conda or pip. Here are the commands to install Jupyter Notebook: Using Conda: conda install -c conda-forge jupyterlab Using pip: pip install jupyterlab Step 2: Modify the Configuration File Generate the Jupyter Notebook configuration file by running the following command in the command prompt: jupyter notebook --generate-config Open the generated file and modify the following configurations: jupyter_notebook_config.py c.NotebookApp.ip=''  # Allow any IP to access
c.NotebookApp.password='your_generated_password'  # Set a password for authentication
c.NotebookApp.open_browser=False  # Do not open a browser when starting Jupyter Notebook
c.NotebookApp.port=your_selected_port  # Choose a port number for Jupyter Notebook Step 3: Set a Customized Password Launch IPython by running in the command prompt. and In the IPython environment, run the following commands: ipython from notebook.auth import passwd
passwd() Enter a password and confirm it. Copy the generated sha1 value. Replace the in the file with the generated sha1 value. 'your_generated_password' jupyter_notebook_config.py Step 4: Remote Access Start the Jupyter Notebook server by running in the command prompt. jupyter notebook To access Jupyter Notebook remotely, use your server's IP address along with the selected port number in a web browser. Enter the password when prompted to access the Jupyter Notebook interface. Conclusion By following these steps, you can set up and access Jupyter Notebook on a Windows server for interactive data analysis and development tasks. Enjoy using Jupyter Notebook with the flexibility of remote access! Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on or (@Luca_DataTeam). LinkedIn X Also published . here

How To Set Up Jupyter Notebook on a Windows Server

Things To Make by Archibald Williams is part of the HackerNoon Books Series. You can jump to any chapter in this book . A SELF-LAUNCHING MODEL AEROPLANE. here XXV. A SELF-LAUNCHING MODEL AEROPLANE. By V. E. Johnson, M.A. This article deals not with a scale model—a small copy of some full-sized machine—but with one designed for actual flight; with one not specially intended to create records either of length or duration, but which, although small details must perforce be omitted, does along its main lines approximate to the “real thing.” Partly for this reason, and partly because it proves a far more interesting machine, we choose a model able to rise from the ground under its own power and make a good flight after rising, assuming the instructions which we give to have been carefully carried out. It is perhaps hardly necessary to add that such a machine can always be launched by hand when desired. Before entering into special details we may note some broad principles which must be taken into account if success is to attend our efforts. Important Points.—It is absolutely essential that the weight be kept down as much as possible. It is quite a mistake to suppose that weight necessarily means strength. On the contrary, it may actually be a cause of weakness if employed in the wrong place and in the wrong way. The heavier the machine, the more serious the damage done in the event of a bad landing. One of the best and easiest ways of ensuring lightness is to let the model be of very simple construction. Such a model is easier to build and more efficient when constructed than one of more complicated design. Weigh every part of your model as you construct it, and do not be content until all symmetrically arranged parts which should weigh the same not only look alike but do actually balance one another. (Note.—The writer always works out the various parts of his models in grammes, not ounces.) If a sufficiently strong propeller bearing weighing only half a gramme can be employed, so much the better, as you have more margin left for some other part of the model in which it would be inadvisable to cut down the weight to a very fine limit. Details.—To pass now to details, we have four distinct parts to deal with:— The framework, or fuselage. The supporting surfaces, consisting of the main plane, or aerofoil, behind, and the elevator in front. The propellers. The motor, in this case two long skeins of rubber; long, because we wish to be able to give our motor many turns, from 700 to, say, 1,000 as a limit, so that the duration of flight may be considerable. [Illustration: FIG. 129.-Sections of backbone for model aeroplane.] The Backbone.—For the backbone or central rod take a piece of pitch pine or satin walnut 52 inches long, 5/8 inch deep, and 1/2 inch broad, and plane it down carefully until it has a T-shaped section, as shown in Fig. 129, and the thickness is not anywhere more than 1/8 inch. It is quite possible to reduce the thickness to even 1/16 inch and still have a sufficient reserve of strength to withstand the pull of 28 strands of 1/16-inch rubber wound up 1,000 times; but such a course is not advisable unless you are a skilful planer and have had some experience in model-making. If you find the construction of the T-shaped rod too difficult, two courses are open— (l) To get a carpenter to do the job for you, or (2) To give the rod the triangular section shown in Fig. 129, each side of the equilateral triangle being half an inch long. [Illustration: FIG. 150—Side elevation of model aeroplane.] The top of the T or the base of the triangle, as the case may be, is used uppermost. This rod must be pierced in three places for the vertical masts employed in the bracing of the rod, trussing the main plane, and adjusting the elevator. These are spaced out in Fig. 130, which shows a side elevation of the model. Their sectional dimensions are 1/16 by 1/4 inch; their respective lengths are given in Fig. 130. Round the front edges and sharpen the rear. In Fig. 130 is shown the correct attitude or standing pose necessary to make the model rise quickly and sweep boldly up into the air without skimming the ground for some 10 to 20 yards as so many models do. E is the elevator (7 by 3 inches); A the main plane (5-1/2 by 29 inches); W the wheels; and RS the rear skid, terminating in a piece of hooked steel wire. The vertical bracing of these masts is indicated. The best material to use for the purpose is Japanese silk gut, which is very light and strong. To brace, drill a small, neat hole in the mast and rod where necessary, pass through, and tie. Do the same with each one. To return to the central mast, which must also form the chassis. This is double and opened out beneath as shown in Fig. 131, yz being a piece similar to the sides, which completes, the triangle x y z and gives the necessary rigidity. Attach this piece by first binding to its extremities two strips of aluminium, or by preference very thin tinned iron, Tl and T2. Bend to shape and bind to xy, xz as shown in Fig. 131. [Illustration: FIG. 131.—Front elevation of chassis.] [Illustration: FIG. l32.-Wheel for model aeroplane chassis.] [Illustration: FIG. 133.—Plan of model aeroplane.] The Wheels and Chassis.—WW are the two wheels on which the model runs. They are made of hollow brass curtain rings, 1 inch in diameter, such as can be bought at four a penny. For spokes, solder two strips of thin tinned iron to the rings, using as little solder as possible. (Fig. 132.) To connect these wheels with the chassis, first bind to the lower ends of xy, xz two strips of thin tinned iron, T3 and T4, after drilling in them two holes of sufficient size to allow a piece of steel wire of “bonnet pin” gauge to pass freely, but not loosely, through them. Soften the wire by making it red hot and allowing it to cool slowly, and solder one end of this wire (which must be quite straight and 5-1/4 inches long) to the centre of the cross pieces or spokes of one wheel. Pass the axle through the holes in the ends of xy, xz, and solder on the other wheel. Your chassis is then finished. The rear skid (RS in Fig. 130) is attached to the central rod by gluing, and drilling a hole through both parts and inserting a wooden peg; or the upright may be mortised in. On no account use nail, tack, or screw. Attach the vertical masts and the horizontal ones about to be described by gluing and binding lightly with thread, or by neatly glued strips of the Hart’s fabric used for the planes. Horizontal Spars, etc.—To consider now the horizontal section or part plan of the model, from which, to avoid confusion, details of most vertical parts are omitted. Referring to Fig. 133, it will be seen that we have three horizontal masts or spars—HS1, 4 inches; HS2, 6 inches; and HS3, slightly over 12 inches long. The last is well steamed, slightly curved and left to dry while confined in such a manner as to conform to the required shape. It should so remain at least twenty-four hours before being fixed to the model. All the spars are attached by glue and neat cross bindings. If the central rod be of triangular instead of T section, the join can be made more neatly. The same remarks apply to the two 9 and 10 inch struts at the propeller end of the rod, which have to withstand the pull of the rubber motor on PPl. These two pieces will have a maximum strength and minimum weight if of the T section used for the rod. If the work is done carefully, 1/4 inch each way will be sufficient. Main Plane and Elevator.—The framework of each plane is simply four strips of satin walnut or other suitable wood, 1/4 inch broad and 1/16 inch or even less in thickness for the main plane, and about 1/16 by 1/16 inch for the elevator. These strips are first glued together at the corners and left to set. The fabric (Hart’s fabric or some similar very light material) is then glued on fairly tight—that is, just sufficiently so to get rid of all creases. The main plane is then fixed flat on to the top of the central rod by gluing and cross binding at G and H. (A better but rather more difficult plan is to fasten the rectangular frame on first and then apply the fabric.) The same course is followed in dealing with the elevator, which is fixed, however, not to the rod, but to the 4-inch horizontal spar, HS1, just behind it, in such a manner as to have a slight hinge movement at the back. This operation presents no difficulty, and may be effected in a variety of ways. To set the elevator, use is made of the short vertical mast, M1. A small hole is pierced in the front side of the elevator frame at Z, and through this a piece of thin, soft iron wire is pushed, bent round the spar, and tied. The other end of the wire is taken forward and wrapped three or four times round the mast M1, which should have several notches in its front edge, to assist the setting of the elevator at different angles. Pull the wire tight, so that the elevator shall maintain a constant angle when once set. H H1 is a piece of 25 to 30 gauge wire bent as shown and fastened by binding. It passes round the front of the rod, in which a little notch should be cut, so as to be able to resist the pull of the twin rubber motors, the two skeins of which are stretched between H H1 and the hooks formed on the propeller spindles. If all these hooks are covered with cycle valve tubing the rubber will last much longer. The rubber skeins pass through two little light wire rings fastened to the underside ends of HS2. (Fig. 133.) The front skid or protector, FS, is made out of a piece of thin, round, jointless cane, some 9 inches in length, bent round as shown in Fig. 134, in which A B represents the front piece of the T-shaped rod and x y z a the cane skid; the portion x y passing on the near side of the vertical part of the T, and z a on the far side of the same. At E and F thread is bound right round the rod. Should the nose of the machine strike the ground, the loop of cane will be driven along the underside of the rod and the shock be minimized. So adjust matters that the skid slides fairly stiff. Note that the whole of the cane is on the under side of the top bar of the T. [Illustration: FIG. 134.—Front skid and attachment to backbone.] Bearings.—We have still to deal with the propellers and their bearings. The last, TN and TNl (Fig. 133), are simply two tiny pieces of tin about half a gramme in weight, bent round the propeller spar HS3 at B and B1. Take a strip of thin tin 1/4 inch wide and of sufficient length to go completely round the spar (which is 1/4 by 1/8 inch) and overlap slightly. Solder the ends together, using a minimum amount of solder. Now bore two small holes through wood and tin from rear to front, being careful to go through the centre. The hole must be just large enough to allow the propeller axle to run freely, but not loosely, in it. Primitive though such a bearing may seem, it answers admirably in practice. The wood drills out or is soon worn more than the iron, and the axle runs quite freely. The pull of the motor is thus directed through the thin curved spar at a point where the resistance is greatest—a very important matter in model aeroplane construction. To strengthen this spar further against torsional forces, run gut ties from B and Bl down to the bottom of the rear vertical skid post; and from B to B1 also pass a piece of very thin piano wire, soldered to the tin strips over a little wooden bridge, Q, like a violin bridge, on the top of the central rod, to keep it quite taut. [Illustration: FIG. 135—“Centrale” wooden propeller.] Propellers.—To turn now to the propellers. Unless the reader has already had fair experience in making model propellers, he should purchase a couple, one right-handed and one left-handed, as they have to revolve in opposite directions. It would be quite impossible to give in the compass of this article such directions as would enable a novice to make a really efficient propeller, and it must be efficient for even a decent flight with a self-launching model. The diameter of the two propellers should be about 11-1/2 to 11-3/4 inches, with a pitch angle at the extremities of about 25 to 30 degrees as a limit. The “centrale” type (Fig. 135) is to be preferred. Such propellers can be procured at Messrs. A. W. Gamage, Ltd., Holborn, E.C.; Messrs. T. W. K. Clarke and Co., Kingston-on-Thames; and elsewhere. For the particular machine which we are considering, the total weight of the two propellers, including axle and hook for holding the rubber, should not exceed 3/4 oz. This means considerable labour in cutting and sandpapering away part of the boss, which is always made much too large in propellers of this size. It is wonderful what can be done by care and patience. The writer has in more than one case reduced the weight of a propeller by more than one-half by such means, and has yet left sufficient strength. The combined axle and hook should be made as follows:—Take a piece of thin steel wire, sharpen one end, and bend it as shown at C (Fig. 136). Pass the end B through a tight-fitting hole in the centre of the small boss of the propeller, and drive C into the wood. Solder a tiny piece of 1/8-inch brass tubing to the wire axle at A, close up to the rubber hook side of the propeller, and file quite smooth. The only things now left to do are to bend the wire into the form of a hook (as shown by the dotted line), and to cover this hook, as already advised, with a piece of valve tubing to prevent fraying the rubber skeins. [Illustration: FIG. 136.—Axle and hook for propeller.] Weight.—The weight of a model with a T-shaped central rod 1/16 inch thick should be 4-1/2 oz. Probably it will be more than this—as a maximum let us fix 6 oz.—although 4-1/2 oz. is quite possible, as the writer has proved in actual practice. In any case the centre of gravity of the machine without the rubber motor should be situated 1 inch behind the front or entering edge of the main plane. When the rubber motor (14 strands of 1/16-inch rubber for each propeller, total weight 2 oz.) is in position, the centre of gravity will be further forward, in front of the main plane. The amount of rubber mentioned is for a total weight of 6-1/2 oz. If the weight of the model alone be 6 oz., you will probably have to use 16 strands, which again adds to the weight, and makes one travel in a vicious circle. Therefore I lay emphasis on the advice, Keep down the weight. The front edge of the elevator should be set about 3/8 inch higher than the back, and the model be tried first as a glider, with the rubber and propellers in position. If it glides satisfactorily, wind up the motor, say 500 turns, and launch by hand. When a good flight has been obtained, and the correct angle of the elevator has been determined, place the model on a strip of linoleum, wind up, and release the propellers. The model should rise in its own length and remain in the air (if wound up 900 turns) at least three quarters of a minute. Choose a calm day if possible. If a wind blows, let the model face the breeze. Remember that the model flies high, and select a wide open space. Do not push the model forward; just release the propellers, held one in each hand near the boss by the fingers and thumb. As a lubricant for the rubber use pure glycerine. It is advisable to employ a geared-up mechanical winder, since to make 1,800 turns with the fingers is rather fatiguing and very tedious. Simple as this model may seem in design, one built by the writer on exactly the lines given has met the most famous flying models of the day in open competition and proved successful against them. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Archibald Williams (2005). Things To Make. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/14664/pg14664-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

A SELF-LAUNCHING MODEL AEROPLANE.

Recently, I decided to spend a bit of time exploring LÖVE in my spare time. It uses Lua as programming language. Also, it’s an open-source engine available for free on Windows, Mac, and Linux. You can also build your game for iOS/Android and even WebGL. Website: https://love2d.org/ I thought it would be easy, coming from Unity and different other languages. But it took me a bit of time to find the information or logic behind the language and engine. So I decided to write this guide to help you get kick-started and easily transitioned to LÖVE. Guide Lua Language Here are some examples of different things you may want to use: Important Links Programming language reference: Programming in Lua https://www.lua.org/pil/contents.html Package manager for Lua: LuaRocks https://luarocks.org/ Variables local x = 1 -- Only available in local scope
globalVar = 2 -- Global variable Usual Operations -- increment variable
i = i + 1

-- decrement variable
i = i - 1

-- concatenate the variable name with two strings
message = "Hello, my name is "..name.."!"

-- not equal operator (others are the same as others languages)
test = something ~= 0

-- logical operatiors: not, and, or 
test1 = not something
test2 = something and somethingelse
test3 = something or somethingelse 

-- tertiary operator (a ? b : c)
test = a and b or c Note: there is no in Lua to increment. i++ If, elseif, else if playerJumped then 
  -- Start jump animation
elseif playerCrouch then 
  -- Start crouch animation
else
  -- Play idle animation
end For Loops -- Loop over i from 0 to 20 and increment by 1 at each cycle 
for i = 0,20,1
do
  -- Do something
end : you cannot have multiple variables in the for statement. If you need multiple variables look at doing a loop instead. Note while While Loops local i = 0
while i < 20
do 
  -- Do something 
  i = i + 1
end Functions function f(argument1) 
  return something * argument1
end : all the primary types (numbers, boolean, nil, strings) are passed by values, everything else is passed by reference to the function. Note Classes and OOP There is a native way of doing it, using the official language reference: https://www.lua.org/pil/16.1.html But I found it a bit inelegantly and the function is confusing. setmetadatatable So I found another solution that simplifies the code you need to write to create classes and child classes: https://gist.github.com/paulmoore/1429475 You only need to import the file in your project, but definitely look at the examples. classes.lua But here is a quick example. -- Load the classes helper file
local classes = require "classes"

local Enemy = classes.class() -- Create a class without any parent

Enemy.count = 0

function Enemy:init(name)
    self.hp = 100
    self.name = name
  Enemy.count = Enemy.count + 1
end

-- static function
function Enemy.count()
  return Enemy.count
end

local Orc = classes.class(Enemy) -- Create an Orc who is an enemy

function Orc:init(name, weapon)
  self.super:init(name) -- call to parent constructor
    self.weapon = weapon
end

-- Instantiate some orcs 
local orcWithAxe = Orc.new("Zotor", "Axe")
local orcWithBow = Orc.new("Plead", "Bow") Notes: We use to instantiate and define in the class, which is called implicitly during the operation. new init new For static methods and variables, use the class name followed by a then the name of the element you want to access. . For object methods and attributes, use the variable name followed by a then the name of the element you want to access. : For private methods, don’t prefix the name of the function with the name of the class. Queues and Stacks For that, I made a module based on the example provided by the official language reference. https://www.lua.org/pil/11.4.html List = {}
function List.new ()
  return {first = 0, last = -1}
end

function List.count(l)
  return #table
end

function List.pushleft (list, value)
    local first = list.first - 1
    list.first = first
    list[first] = value
  end

  function List.pushright (list, value)
    local last = list.last + 1
    list.last = last
    list[last] = value
  end

  function List.popleft (list)
    local first = list.first
    if first > list.last then error("list is empty") end
    local value = list[first]
    list[first] = nil        -- to allow garbage collection
    list.first = first + 1
    return value
  end

  function List.popright (list)
    local last = list.last
    if list.first > last then error("list is empty") end
    local value = list[last]
    list[last] = nil         -- to allow garbage collection
    list.last = last - 1
    return value
  end

return List Copy that in a file in your project. Then you can use it this way: list.lua queue = List.new()
stack = List.new()

-- Enqueue values
List.pushright(queue, someValue)
List.pushright(queue, someValue)
List.pushright(queue, someValue)

-- Stack values
List.pushleft(stack, someValue)
List.pushleft(stack, someValue)
List.pushleft(stack, someValue)

-- Consume queue (FIFO)
local value1 = List.popleft(queue)
local value2 = List.popleft(queue)

-- Consume stack (LIFO)
local value3 = List.popleft(stack)
local value4 = List.popleft(stack) Arrays and Tables (structured data) Table is a specific type in Lua, it’s a bit like arrays in PHP, which can be associative or indexed. -- same initialization
local array = {}
local table = {}

-- initializing array values
for i = 0,20,1
do 
    array[i] = i
end

-- initialization table values
table["x"] = 0
table["y"] = 0

-- or could be done at the declaration
local coords = {x=0, y=0} Cron If you want to schedule a specific action at a certain time, you want to use cron/timer. The easiest solution I found is to use the tool made by kikito: https://github.com/kikito/cron.lua local cron = require 'cron'

local function printMessage()
  print('Hello')
end

-- the following calls are equivalent:
local c1 = cron.after(5, printMessage)
local c2 = cron.after(5, print, 'Hello')

c1:update(2) -- will print nothing, the action is not done yet
c1:update(5) -- will print 'Hello' once

c1:reset() -- reset the counter to 0

-- prints 'hey' 5 times and then prints 'hello'
while not c1:update(1) do
  print('hey')
end

-- Create a periodical clock:
local c3 = cron.every(10, printMessage)

c3:update(5) -- nothing (total time: 5)
c3:update(4) -- nothing (total time: 9)
c3:update(12) -- prints 'Hello' twice (total time is now 21) LÖVE Engine Specifics OK, Lua itself requires some learning, as you’ve seen. But LÖVE too! Important Links Official documentation: LÖVE Wiki https://love2d.org/wiki/Main_Page Structure To run a game, you need a folder with at least a file . main.lua Example of minimal structure: function love.load()
    -- Run once at game initialization
end

function love.keypressed(key, scancode, isrepeat)
    -- Run each time a key on the keyboard is pressed
end

function love.mousepressed(x, y, button, istouch, presses)
    -- Run each time a mouse button is pressed, supports multi-touch too
end

function love.update(dt)
    -- Run at each frame before drawing it
    -- This is where you handle most of your game logic
end

function love.draw()
  -- Called at every frame to draw the game
end : There are other functions you may need, you can find the details here: Note https://love2d.org/wiki/love IDE I advise you to use Visual Code with the extension https://marketplace.visualstudio.com/items?itemName=SK83RJOSH.love-launcher Also, add a file at the root of your folder, with the contents: conf.lua function love.conf(t)
    t.console = true
end Now each time you press , your game will pop plus the console window which can help to debug. Alt+L Manipulate the Game Window You can change the default window display attribute during the loading of your game. Example: function love.load()
    love.window.setMode(800, 600, {resizable=true, minwidth=400, minheight=300})
end : Details https://love2d.org/wiki/love.window.setMode SVG Files I found a nice package that adds support for SVG files to LÖVE. It is called TÖVE. : Details https://github.com/poke1024/tove2d No active development since a couple of years ago, so be aware of that. But for me, it worked fine. Fixed Update If you want to make your game at a constant frame rate, it’s not possible natively. But I found that gist from Leandros: that just does the job perfectly. https://gist.github.com/Leandros/98624b9b9d9d26df18c4 You need to copy/paste the code at the end of your ua and that’s it. Constant 60FPS. main.l You can tweak the FPS if you need. ECS (Entity Component System) LÖVE is not natively using the paradigm . But if you like ECS as I do, I found a tiny ECS framework for it. It was written in 2016, pretty old already, but it’s so tiny that it did age well. ECS Here is the link: https://github.com/bakpakin/tiny-ecs If you want to use it, there’s only one file to copy to your project. tiny.lua You can find a project using it here as an example: https://github.com/bakpakin/CommandoKibbles Post Processing Screen VFX If you want to have some post-processing screen virtual effects, the easiest I found is to use moonshine: https://github.com/vrld/moonshine It contains 16 effects like glow, vignette, crt, ... That you can chain as you want and change parameters on the fly. If you want to create your own effect, you will have to start to write shaders and extend moonshine effects. Check the GitHub README to understand how to use it. Screen Shake Effect I found on the forum of LÖVE a reply from vrld that does the job: https://love2d.org/forums/viewtopic.php?p=193765#p193765 local t, shakeDuration, shakeMagnitude = 0, -1, 0
function startShake(duration, magnitude)
    t, shakeDuration, shakeMagnitude = 0, duration or 1, magnitude or 5
end

function love.update(dt)
    if t < shakeDuration then
        t = t + dt
    end
end

function love.draw()
    if t < shakeDuration then
        local dx = love.math.random(-shakeMagnitude, shakeMagnitude)
        local dy = love.math.random(-shakeMagnitude, shakeMagnitude)
        love.graphics.translate(dx, dy)
    end
end Game distribution If you want to distribute your game, your starting point is the wiki at that address: love2d.org/wiki/Game_Distribution More details on WegGL First, you need to install the tool from Davidobot: https://github.com/Davidobot/love.js npm install -g love.js Web server with proper headers Then you will need a server and a web server running on it. On my end, I use Nginx, and this is how I configured my : location location /beathoven/ {
        add_header Cross-Origin-Opener-Policy same-origin;
        add_header Cross-Origin-Embedder-Policy require-corp;
        alias /usr/share/nginx/html/beathoven/;
} Add missing mime type After several tries looking at errors in the browser, I realize also I needed to edit the file to add the definition for wasm file: /etc/nginx/mime.types application/vnd.google-earth.kmz      kmz;
    application/wasm                      wasm;
    application/x-7z-compressed           7z; Use 7zip not tar on Windows To package your game into a love file, you need to simply zip the files. And since Windows 10, Windows includes a command line utility that you can use to make zip. But it looks like it’s not supported by the WebGL build. So I switched to 7Zip using the following parameters: tar You can also use 7zip in the command line. Example of building & deploy script #!/bin/bash

tools/7za a -tzip Beathoven.zip assets/ gameobjects/ pages/ responsive/ utils/ fonts.lua main.lua -mx0
mv Beathoven.zip Beathoven.love

love.js -t Beathoven -c Beathoven.love game 

ssh server rm -rf /usr/share/nginx/html/beathoven/*

scp -r game/* server:/usr/share/nginx/html/beathoven/ Conclusion Obviously, I haven’t covered everything here, but I hope that it can give a nice introduction to help you get quickly productive with LÖVE and create some cool games! Next week I’ll share about a Rhythm game called Beathoven I decided to make while exploring the possibilities of LÖVE. Originally published . here

An Introduction to LÖVE the 2D Game Engine

Top Software Development Companies 2022 That Are Growing Fast

Abstract Passing data to a function is very important and is often used at times in writing the code. There are two ways to pass data to the function in C/C++. Pass-By-Value. Pass-By-Reference. Scope of the Article This article will provide you with a basic to intermediate level of understanding of how to pass data to the function. Covers the concepts like Call-By-Value & Call-By-Reference using code snippets in C/C++. Note For the scope of this article, we will use Call-By-Value and Pass-By-Value interchangeably similar is the case for Call-By-Reference and Pass-By-Reference. You can learn more about the differences . here Prerequisites One should have a basic understanding of C/C++. How to make Functions in C/C++ with a variable number of arguments. How to pass different parameters to the function. Now, If You Know the Prerequisites, you can move forward. Pass-By-Value Pass by value is when a function copies the actual value of an argument into a formal parameter of the function. Changes made to the parameter in the function have no effect on the argument after the function call ends. In Simpler terms, we can say that changes made to the variable passed by value to the respective function will only reflect in the particular scope of that function. Let's look at a few examples to clarify this. Example Code 1 x=x+y; } # include <bits/stdc++.h> void add ( int x, int y) { return ; int main () { int x= 5 ; int y= 6 ; add (x,y); // passing by value the parameters (x,y). cout<<x<< "\n" ; return 0 ; What do you think the value of x will be? A.) 5 B.) 11 : we have passed the parameters and with value. Meaning the add function only has a copy of their value, not the memory address. Notice one thing carefully x y So the update of has a local scope inside the add function only. After the function call ends, the value of variable will be the same as the previous, i.e., . (x=x+y) x 5 Example Code 2 } } # include <bits/stdc++.h> using namespace std; void swapValues ( int x, int y) { swap (x,y); return ; int main () { int x= 5 ; int y= 6 ; swapValues (x,y); // passing by value the parameters (x,y). cout<<x<< "\n" ; return 0 ; When to use Pass-By-Value When we want to calculate the value of a particular function without modifying the values of arguments passed. To avoid bugs caused due to memory stack issues. Pass-By-Reference Pass by reference copies the address of an argument into the formal parameter. The address is used to access the actual argument used in the call. This means the changes made to the parameter affect the passed argument. Example Code {
    swap(x,y); } { } #include<bits/stdc++.h> using namespace std ; // Taking the values of x and y with reference . void swapValues ( int & x , int & y ) return ; int main() int x= 5 ; int y= 6 ; swapValues(x,y); // passing by reference the parameters (x,y). cout<<x<< "\n" ; return 0 ; : we have taken the values of and using the ampersand operator ( ), meaning we are taking values by reference using the actual memory address of the variables. Here notice one thing carefully x y & So after the function calls end. The value of will be swapped with the value of . x y When to use Pass-By-Reference Whenever you want to store the modified value of a variable after the function call ends. If you need to update the value of some variable in a recursive function. Time Complexity The time complexity of programs using or is almost similar. pass-by-value pass-by-reference Key Points and Conclusion Both are equally important features of C/C++ pass-by-value and are mostly used over pass-by-reference. A copy of the same variable is stored in the call stack during the function call. As per the needs of the program, the choice between pass-by-value and pass-by-reference has to be made. Thank you so much for reading this! The featured image is taken from . here

Call-By-Value and Call-By-Reference

I am one of those persons who learned React before properly learning the basic concepts of javascript. Because of this, in the early days of my React journey, I didn't know which part of the code is React and which part is the vanilla js. It's important to know the basic javascript concepts to understand better which part of the puzzle is React solving. In this blog post, I will be writing about different concepts of javascript that you see yourself using very often while working with React. It's better to know these before you deep dive into learning React. Logical AND (&&) and Logical OR (||) Operators Logical AND (&&) Operator Let's say we have the following expression - where and are . b c expressions b && c This will be evaluated to the value of only if is , otherwise, it will be evaluated to the value of c b truthy b Notes: If is , then the expression is not even going to be evaluated. b falsy c This is called . shortcut evaluation This will be used quite a lot while using React. Logical OR (||) Operator Let's say we have the following expression - where and are b c expressions b || c This will be evaluated to the value of if b is , otherwise, it will be evaluated to the value of . b truthy c Note: Shortcut evaluation happens here too. If is , then the expression is not even going to be evaluated. b truthy c You will be using this also quite often while using React. Template Literals This is a new ES6 way to create strings. Let's see an example. Assume that you want to create the following type of strings: 3 blog posts were written by Bhanu Teja in a span of 2 weeks. You will be given (number of blogs), (name of the user), (time span it took) as variables. count name span Without using template literals count = user = span = result = count + + name + + span 
                     + const 3 const 'Bhanu Teja' const 2 const ' blog posts were written by ' ' in a span of ' ' weeks.' Using template literals count = name = span = result = const 3 const 'Bhanu Teja' const 2 const ` blog posts were written by in a span of weeks.` ${count} ${name} ${span} Template literals start and end with a and you can write strings of text inside them and you have to wrap the around with and backtick(`) javascript expressions ${ } Let's add another use-case to the above example. If we have just 1 blog post you have to use instead of blog post blog posts If the time span is just 1 week, you have to use instead of . week weeks Without using template literals { (count === ) { text
    } text + } result = count + + pluralize( , count)  
                     + + name
                     + + span 
                     + + pluralize( , span) + ( ) function pluralize text, count if 1 return return 's' const ' ' 'blog post' ' were written by ' ' in a span of ' ' ' 'week' '.' Using template literals { (count === ) { text
    } text + } result = ( ) function pluralize text, count if 1 return return 's' const ` were written by in a span of .` ${count} ${pluralize( , count)} 'blog post' ${name} ${span} ${pluralize( , span)} 'week' Ternary Operator This is a shorthand representation of the if-else statements. This is best explained using an example. (condition) {
    doSomething()
} {
    doSomethingElse()
} if else The above example when written using ternary operator condition ? doSomething() : doSomethingElse() Syntax condition ? expressionIfTrue : expressionIfFalse Shorthand Property Names id = name = count = user = { : id, : count, : name,
} user = {
    id, : count,
    name,
} const 2 const 'Bhanu' const 2 // This is the normal way const id blogs name // Using shorthand property names const blogs If the name of the and the name of the of the object are the same, then you can just write the variable name and omit the rest. variable property This is one of the things that I did not know when I was initially learning React, and you usually see this being used a lot in code and documentation. Object Destructuring This is a short-hand way to get the properties of an object into variables. user = { : , : , : } name = user.name blogs = user.blogs timeSpan = user.timeSpan { name, blogs, timeSpan } = user // we have a `user` variable that looks like this const name 'Bhanu Teja' blogs 3 timeSpan 2. // without using object destructuring const const const // using object destructuring const Note: The name of the destructured variables should be same as the name of the object properties. Array Destructuring This is a short-hand way to get the elements of an array into variables. name = [ , ] firstName = name[ ] lastName = name[ ] [firstName, lastName] = name // we have a `name` variable that looks like this const 'Bhanu Teja' 'P' // without using array destructuring const 0 const 1 // using array destructuring const Default Parameters You often want the function parameters to take some default values if that is not passed while calling the function. Let's see an example { a + b
}

sum( , ) sum( ) sum() ( ) function sum a = , b = 2 5 return 5 7 // a = 5, b = 7, result = 12 4 // a = 4, b = 5(default value of b), result = 9 // a = 2(default a), b = 5(default b), result = 7 So, whenever you want a parameter to take a default value, simply add a sign after the parameter and add your default value there. = Optional Chaining This is a relatively new feature of javascript. The optional chaining operator (?.) permits reading the value of a property located deep within a chain of connected objects without having to expressly validate that each reference in the chain is valid. -  Taken from MDN Docs Consider the expression a?.b This expression evaluates to if is and , otherwise, it evaluates to . a.b a not null not undefined undefined You can even chain this multiple times like a?.b?.c If is or , then this expression evaluates to a undefined null undefined Else if is undefined or , then this expression evaluates to b null undefined Else this evaluates to a.b.c Syntax: obj.val?.prop
obj.val?.[expr]
obj.arr?.[index]
obj.func?.(args) Nullish Coalescing Operator The nullish coalescing operator (??) is a logical operator that returns its right-hand side operand when its left-hand side operand is or , and otherwise returns its left-hand side operand.  -  Taken from null undefined MDN Docs Consider the expression a ?? b This evaluates to if is or , otherwise, it evaluates to b a null undefined a Spread Operator This operator spreads the values of an iterable object. Array Spread a = [ , , ] b = [ , ] .log(...a) c = [ , ...a, , ...b] .log(c) const 1 2 3 const 5 6 console // 1 2 3 // Now, if you want to have an array with values 0, 1, 2, 3, 4, 5, 6 const 0 4 console // 0 1 2 3 4 5 6 Object Spread first = { : , : } second = { : } result = {...first, ...second, : } .log(result) const a 1 b 2 const c 3 // Now to create an object {a: 1, b: 2, c: 3, d: 4} const d 4 console // {a: 1, b: 2, c: 3, d: 4} To learn more about spread operator, Check out this amazing article ES6 - Spread Operator Rest Operator The rest parameter syntax allows us to represent an indefinite number of arguments as an array.  -  Taken from MDN Docs Function Arguments { }

sum( , , , , , ) ( ) function sum a, b, ...rest // ... 1 2 3 4 5 6 // a = 1, b = 2, rest = [3, 4, 5, 6] Usage with objects user = { : , : , : ,
} {name, ...rest} = user .log(name) .log(rest) const name 'Bhanu Teja' blogs 3 span 2 const console // Bhanu Teja console // { blogs: 3, span: 2} Arrow Functions This is a new ES6 way to write functions. sum = { a + b
} { a + b
} sum = { a + b
} sum = a+ b multiplyBy2 = a * (or) multiplyBy2 = a * // without using arrow functions const ( ) function a, b return // (or) ( ) function sum a, b return // Using arrow functions const ( ) => a, b return // (or) const ( ) => a, b const ( ) => a 2 const => a 2 As you can see from the above example, converting the normal function to arrow functions can be done as follows: Remove the keyword. function Add an after the parameters. => Note If the body of the function is a simple expression you can even omit the keyword and also need not wrap it between and return { } If there is only one argument, you have the option to remove parenthesis around the arguments. There are still some more differences between arrow functions and normal functions, Checkout the following amazing articles to know more. A Simple Guide To Arrow Functions ES6 => Arrow Functions Array Methods There are so many array methods, but we frequently use some of these. I will be covering the following array methods. map filter reduce sort includes slice splice Array map() Method This method creates a new array from an existing array by calling a function for every element of the array. I always remember this as . mapping the values in an array to some other values Let's see an example. names = [
    { : , : },
    { : , : },
    { : , : },
] { name.firstName + + name.lastName
} .log(names.map(callback)) names.map( { name.firstName + + name.lastName }) names.map( ) names.map( ) names.map( ) const firstName 'Bhanu Teja' lastName 'P' firstName 'Florin' lastName 'Pop' firstName 'Brad' lastName 'Traversy' // Let's say we have to create a new array with full names. // First let's write a callback function which takes an array element as an argument. ( ) function callback name return ' ' // Now let's call .map() method on the array console // ["Bhanu Teja P", "Florin Pop", "Brad Traversy"] // You can even inline the callback function which is how most of the people write this. ( ) function name return ' ' // Let's write the same using arrow functions and template literals that we just learned earlier ( ) => name ` ` ${name.firstName} ${name.lastName} // You can even omit the parenthesis around name => name ` ` ${name.firstName} ${name.lastName} // Let's use object destructuring ( ) => {firstName, lastName} ` ` ${firstName} ${lastName} Syntax: values.map(callback) // callback takes a single array element as an argument. // values is an array Note: Calling this method will not change the original array Array filter() Method Now that we know the method, it's easy to understand other array methods. They all have a similar syntax. Array map The array filter method creates a new array with elements that satisfy some given criteria. I always remember this as the method filters out elements that do not satisfy the criteria. filter users = [
    { : , : },
    { : , : },
    { : , : },
    { : , : },
    { : , : },
] users.filter( user.posts >= ) // consider the following array of users const id 1 posts 2 id 2 posts 1 id 3 posts 5 id 4 posts 4 id 5 posts 3 // Let's say we want to have all users who have at least 3 posts. ( ) => user 3 // [{id: 3, posts: 5}, {id: 4, posts: 4}, {id: 5, posts: 3}] Syntax: values.filter(callback) // callback takes a single array element as an argument. // values is an array Note: Calling this method will not change the original array Array reduce() method The array reduce method reduces the array of values into a single value. It executes the callback function for each value of the array. Lets see the syntax of the reduce method before seeing an example. array.reduce( ( ), ) function totalValue, currentValue, currentIndex, arr initialValue values = [ , , , , ] total = ( i = ; i < values.length; i++) { value = values[i]
    total = total + value
} .log(total) initialValue = values.reduce( total + currentValue, initialValue) const 2 4 6 7 8 // Let's say that we want to have a sum of all these values. // Let's see how we do it using a traditional for loop let 0 for let 0 const console // Let's use reduce method now const 0 ( ) => total, currentValue Notes: is an optional parameter. initialValue Calling this method will not change the original array Array sort() method The callback function takes two different values as arguments. Based on the return value of the callback function, the two elements' positions are decided. If the return value is negative, then the first value is considered to be before the second value. If the return value is zero, then there will be no change in the order of the values. If the return value is positive, then the first value is considered to be after the second value. values = [ , , , , ] values.sort( { (a > b) { } (a < b) { } }) values.sort( b - a) const 4 10 2 1 55 // Let's say we want to sort this array in descending order // so if a and b are given // a should be before b if a > b // a should be after b if a < b // a and b can be at their own places if a === b ( ) => a, b if return -1 if return 1 return 0 // [55, 10, 4, 2, 1] // You can also do this as follows ( ) => a, b Note: The return value of the function is the sorted array This changes the original array If you do not pass any callback function, this sorts the values as strings and in ascending order. Array includes() Method This returns if the element is included in the array, otherwise returns . true false Syntax: array.includes(element) values = [ , , ]
values.includes( ) values.includes( ) const 2 3 4 1 // false 2 // true Note: You can pass an optional parameter specifying the start index to start the search from. array.includes(element, startIndex) Array slice() method Syntax array.slice(start, end) Array slice will return the elements in the given range. start starting index to select the elements from This is an optional parameter and by default, it takes the value of 0 You can even pass a negative number. Negative number represents the position from the end. refers to the last element of the array, refers to last but one element, and so on. -1 -2 end ending index up to where to select the elements This is an optional parameter. If this is not passed, then all elements up to the end of the array will be selected. The element at will not be selected end This also accepts a negative number as an argument and the meaning is the same as before. numbers = [ , , , , , , , ] .log(numbers.slice()) .log(numbers.slice( )) .log(numbers.slice( , )) .log(numbers.slice( )) .log(numbers.slice( )) .log(numbers.slice( , )) const 0 1 2 3 4 5 6 7 console // [0, 1, 2, 3, 4, 5, 6, 7] console 2 // [2, 3, 4, 5, 6, 7] console 2 6 // [2, 3, 4, 5] console -1 // [7] console -3 // [5, 6, 7] console -3 -1 // [5, 6] Note: This doesn't change the original array Array splice() method Syntax: array.splice(index, count, item1, ....., itemX) This method is used to add or remove elements in an array. index The index at which the elements need to be added or removed. Can be a negative value too. count The number of elements to remove. item1, ....., itemX Items that will be added at index numbers = [ , , , , , ] numbers.splice( , , , , ) .log(numbers) const 0 1 2 100 6 7 // let's say we have to convert this array to [0, 1, 2, 3, 4, 5, 6, 7] 3 1 3 4 5 console // [0, 1, 2, 3, 4, 5, 6, 7] Note: The return value of the splice method is the array of items removed. This changes the original array To know more about different array methods, check out the amazing series Javascript Array Methods Default Exports vs Named Exports You often see yourself using ES Modules imports and exports while working with React. It's important to know how to import them when they are exported as default exports vs when they are exported as named exports. Check out the following amazing articles to read about these. JavaScript Modules and how to effectively work with Export Import ES Modules Promises You also need to have a basic knowledge of what promises are and how to work them. They will be used quite often in React. Check out to know more about them. this article Basic DOM Document APIs It is also good to be familiar with basic Document Apis like , etc. If you know these, you will appreciate the similarity and differences between React APIs and Document APIs. createElement getElementById If you are working with javascript for a while now, it is most likely that you already know basic Document APIs. MDN Docs are the best place to read up on these. Document - Web APIs | MDN You might also like the following React articles that I wrote: My Review of Kent C. Dodds's EpicReact.Dev: Introduction Javascript You Need To Know For React Intro to React Raw APIs Understanding JSX Creating Custom Components Styling And Handling Forms Managing State With useState Hook How to Create a Reusable LocalStorage Hook Easily Detect Outside Click Using useRef Hook The Lifecycle of React Hooks Component Previously published at https://blog.bhanuteja.dev/epic-react-javascript-you-need-to-know-for-react

Javascript Basics For React Beginners

Audio Handling Basics: Process Audio Files In Command-Line or Python

Conceptos básicos de manejo de audio: Procesar archivos de audio en la línea de comandos o Python

The goal This article describes one of the latest trends in the container world - it’s called distroless containers. Containers are the most preferred method of deploying business applications in all business sectors, so the optimization of how companies use containers has a direct impact on their critical applications infrastructures. Our survey also shows . the domination of containers Why reduce the docker image containers’ size? Computers are faster and have more resources so maybe it’s not that important. The answer is simple: for performance and security. If you need more, here’s another reason - money. Performance Docker images are copied, transmitted, and launched by container fleet managers. It all takes time, time spent on a disk I/O and a networking I/O. And there are min spec machines which are cheap in the cloud, so fitting more containers into one machine means less machine spawns. Security Attack surface can be explained in a few words: whatever your docker image has can be attacked, and the more it has the more likely it will be attacked. It’s that simple. Usually, Linux distribution based docker images contain tons of stuff you won’t ever need, but hackers can use it to hack into your system. Money Remember your favorite cloud provider and its offer. Let’s imagine you want to pay only for a low spec machine with just 1 GB of RAM. If your image size is 500 MB then you can fit two, but if you can reduce it to 100 MB then you can fit ten containers. It really matters! Even if you are not an internet behemoth like Google or Netflix, and even if you have relatively small applications with much fewer users, the costs accumulate over time. What is a distroless image? A distroless image is a slimmed down Linux distribution image plus the application runtime, resulting in the minimum set of binary dependencies required for the application to run. Distroless images are based on Linux distributions; distroless is not a bare image (without anything). For instance, current (March 2020) Google images are based on Debian, but minimized slimmed down Debian distributions. Contents Containers are not virtual machines, you don’t need huge binaries for the OS to run your application. You don’t need ls or grep find cat or even bash in your container to run the java/go/node app. If you are used to logging into your container images and playing with bash as a root, you’re out of luck in general (highly not recommended), but with distroless it’s simply impossible. Do you really need grep, ls, or bash in your production container image? Booo, there’s no Linux shell here! It just runs Java apps on top of a slimmed down Debian instance. A typical container consists of: Distro base layer - linux distribution files (Ubuntu, CentOS, Debian) Runtime layer (JRE for Java, Python runtime, glibc for C++) Application layer - actual application binaries The optimized container looks like this: An even more optimized container looks like this (runtime optimization is a subject of another article but it’s worth noting you can also shrink Java JRE or Python runtime): Size Compare the image sizes for a second. Security It’s a recommended practice, and even more a simply obligatory practice (compliance etc.), to scan the containers for known vulnerabilities using scanners. A better signal to noise for container security scanners is one of the important reasons for distroless containers, also less files to scan and less I/O and CPU consumption for scanning as well. What does this really mean? Usually, the default distributions come with tens of security warnings and issues, which are often ignored, which is a risky strategy because among them (noise) can be a few significant security issues that can jeopardize your application security. With cleaner container images, which generate close to zero warnings and errors during the scanning process, you can clearly see things that matter, so the signal to noise ratio is much higher. Let’s scan our images using a clair-scanner. docker - --name arminc/clair- run d db db docker -p 6060:6060 --link :postgres - --name clair arminc/clair- -scan run db d local The official openjdk image and distroless image have zero detected vulnerabilities, other images have multiple detected vulnerabilities. Do it yourself Distroless images are here. Google, which seemed to start this movement, is publishing their own distroless images for Java, Python, Go and C++. Note that you do not (usually) have the package manager in a distroless base image (which can be shocking at first). Again no apt or pip, you have to install the dependencies in another way. An alternative way is to use a multi stage build, a feature from Docker which will allow us the effects (files) created by a package manager for our target of a distroless based image. So we can have both, the temporary package manager in a temporary docker image and the flattened file system resulting in a smaller image. Like everything you do yourself, the question of maintenance arises. Who, when, and how will it update your local distroless image? This has to be addressed, otherwise, without proper maintenance and base dependencies updates, it will rust very quickly and defeat the purpose of its creation. The competition Alpine Linux Alpine Linux is a very tiny linux distribution which is only 4 MB in size. Alpine musl libc and busybox lack GNU glibc support and lack of GNU glibc support means trouble. For instance, JDK doesn’t run on musl libc, there is a port called Portola, but it’s certainly not as well tested and reliable as official JDK distributions. It's hard to imagine running critical business applications on protype. Of course there is news that the new version is working or soon will be working. Alpine meant for instance, that Python containers had to download all the dependencies and as a consequence they have become bigger with the Alpine base image than without it (sic!). Additionally, Alpine Linux image contains busybox tools, apk (package manager) and other binaries you simply don’t need to run your application. Alpine with glibc? Yes, there are containers based on Alpine plus glibc libraries. Still it’s not as easy as Alpine fans would like it to be. Slim images As you could see in the example above, there are readily available ‘slim’ versions of the official images for any given language runtime, which are well worth investigating. However, they often do have a shell and command tools that are not good for container security. Sometimes they can contain excess binaries you don’t need, and they don’t have the ones you do need which can break your runtime dependencies. Minimize image size using tools Another approach is to use a standard base image (not minimized) and then use automatic tools to detect dependencies and remove files that are not needed. For example a minicon analysis existing in containers gives some hints, for instance the RUN commands and other commands that will be required, and based on that, hints are able to significantly reduce the image size of the container. The risk however is that automated dependency findings may fail and result in a runtime container unable to run your application. I endured tiresome trial and error efforts in order to fix runtime errors (file not found, dependent library missing etc.) by adding missing libraries, configuration files and environment settings. The camps Based on the research, I’ve identified the following typical answers to the problem of container size and attack surface optimization: - I don’t want to risk the stability for some MBs of storage space, it’s not worth it, I’ll use the official full images which I trust. I don’t need it and / or :slim images - it’s more adventurous, but when viable I just pick Alpine or a slim image as my base; let the others spend time on optimization. I use Alpine I use with standard runtime image - I like those Google distroless images and use them on a regular basis as an entry point for my Java/Python/Go containers. distroless I use - I am a container optimization pro, the effort is there, but it’s worth it. distroless with an optimized runtime image In which camp are you? What is the trend in your opinion? Of course it depends on the specific problem, project, etc. But there’s statistics and practice. Please identify your camp and explain why. Our experts working for the complex solutions in pharma, insurance, banking and industrial sectors share their views. Felix Hassert, Avenga, Director of Products & Hosting In the Go(lang) environment distroless images have been around for quite a while. Go usually compiles ‘almost statically’ linked fat binaries. This makes it especially easy to use distroless containers. For our Go based components in , we use multi-stage docker builds: The Go build is carried out in a image; the produced binary is copied into a scratch image afterwards. https://wao.io golang:<version> The `FROM SCRATCH` directive is not only distroless, it’s literally empty. Less of a footprint in terms of size and the attack surface isn’t even possible. In times where everyone pushes their branches early-and-often and CI/CD is in place, faster downloads and less space used in the Docker Registry is a plus on its own. But more important are the positive effects of enforced discipline: If nothing is in the base image, you have to bring everything needed deliberately. There are no hidden dependencies. Your software won’t break if lib A forces you to upgrade the base image that could come with an incompatible version of lib B. It is much easier to follow security best practices too. Without files, there is no hassle with file permissions. Just run your entrypoint with an unprivileged user id and make the root folder unwriteable. This will avoid a whole class of file system related errors. You simply cannot write to a disk without a Docker volume. There is no temptation to write logs anywhere else than to stdout/stderr. However, even for the Go software it can be tricky to run in a scratch container. For example, if you need to process HTTPS traffic, you need to bring the CA certificates yourself. Debugging can also be tricky, because you don’t have a shell to execute, but Docker allows you to start a full fledged debugging container (with shell, strace and other handy tools) and attach that to the process space of the specimen container docker -it --rm =container:<go-container> --cap- SYS_PTRACE alpine sh run --pid add That said, the distroless trend is absolutely the right direction. Vladyslav Litovka, DevOps expert On recent projects we’ve moved to using multistage builds and minified containers; mostly Alpine based but also distorless. In some cases it was forced by customer requirements (like Andriy said), and in some cases it was our decision. Anyway, project wide I can say that in most cases it’s option 1, in some option 2 and 3. Great article. Good and simple explanations. It contains the exact amount of technical details which allows us to understand the main purpose and implementation direction in just 15 minutes of a reader’s time. Andrew Petryk, Java Engineering Manager We, at , have used distroless containers in production environments for more than 3 months and are already using multi-stage builds. We weren’t there from the beginning but we were forced, by the security restrictions of our customer to do that. And it worked like a charm (of course with proper orchestration and logging management). Avenga Overall, it seems to be a trend - everything is becoming smaller. I remember the days when deploying .war to a Java Web Application Server was a several minute task where now micro-frameworks fight for sub-second startup time. We have made quite good progress there. The same goes for docker images, but the fight is for MBs rather than seconds. I can’t say that I am solidly in one of the camps Jacek mentioned above (except for camp 1 :) ) because, as it usually happens in IT, it depends on many factors. But for sure, distroless images are a thing and you definitely should give it a try. Final words Containers are everywhere and knowing how to use them efficiently is a key skill for every tech organization. We are happy to share a distroless intro and our ‘experts' opinions on the subject. If you are new to the topic, I hope you see now that distroless is worth trying, if for some time you have been a distroless fan already, you are definitely not alone. Find out what else Avenga is doing here and also check out our LinkedIn profile.

Stories, News & Mentions about CNOTE

Trending Topics

Classic

Neon Noir

Minty

Newspaper

HN StartUps