Nearly 30% of orders from ecommerce retailers like Wayfair get returned upon delivery

Loveseat

loveseat

139 Stories To Learn About Ai Trends

Just a Happy Day

78 Stories To Learn About Operating Systems

Loneliness and the Biography of a Living Person

257 Stories To Learn About Linux

373 Stories To Learn About Learning To Code

Earlier this morning I was looking for inspiration to work on my personal website. I stumbled upon another web developer's blog and scrolled through until I saw something that struck me as.. strange. I was hooked immediately. At the bottom of their About page, there was a small component that held a list of names that linked to other blogs, with "PREVIOUS" and "NEXT" buttons at the top. It was titled "The Claw Webring". Webrings were online communities designed to amplify a blog's SEO and shout out the author's friends and colleagues. Read more here I clicked "JOIN". It led me . here Mostly empty GitHub repo. Not a lot of detail. Okay, now I'm curious. I went back and scrolled through the list and clicked a random name off the list, curious to see what was on the other side. It led me to the personal website belonging to the author and developer that created , which I had no idea existed until now. https://codewithrockstar.com/ It's a coding language that also functions as a heavy metal song. Designed specifically to confuse recruiters who aren't familiar with the term "rockstar-dev". From their website, FizzBuzz written in Rockstar: Midnight takes your heart and your soul
While your heart is as high as your soul
Put your heart without your soul into your heart

Give back your heart


Desire is a lovestruck ladykiller
My world is nothing 
Fire is ice
Hate is water
Until my world is Desire,
Build my world up
If Midnight taking my world, Fire is nothing and Midnight taking my world, Hate is nothing
Shout "FizzBuzz!"
Take it to the top

If Midnight taking my world, Fire is nothing
Shout "Fizz!"
Take it to the top

If Midnight taking my world, Hate is nothing
Say "Buzz!"
Take it to the top

Whisper my world Esoteric are very interesting. Someone had to sit down and create these tools, out of labors of love. Everyone knows about , a language designed to be almost completely human-unreadable, but it's cool to see new examples pop up. programming languages Brainf**k As interesting as Rockstar is, the point of this story, as is the case with most journeys, is not where I ended up or what I found, but rather the journey itself. I saw an interesting component. It had a list of links. I clicked a link. I was curious to see what existed out there. I found something cool. This curiosity->exploration->discovery->share feedback loop doesn't seem to happen often on the internet anymore. But I stumbled across it today and I was very pleased to have found it. I felt like I got a glimpse into the lives of some interesting people. It was certainly more satisfying than clicking through people's Twitter or LinkedIn profiles. Internet communities and fandoms were one of the most beautiful aspects of early Internet culture. They may have dated roots in SEO and closed-off internet communities, but I think we should bring webrings back. Let me know what you think. Thanks for reading -Austin The lead image for this article was generated by HackerNoon's via the prompt "the internet". AI Image Generator

What's the Deal with Webrings?

¿Cuál es el trato con Webrings?

Quel est le problème avec les Webrings ?

वेब्रिंग्स के साथ डील क्या है?

Webrings との取引は何ですか?

Qual é o negócio com Webrings?

Thỏa thuận với Webrings là gì?

Webrings 有什么用？

Let's learn about via these 5 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Haskell /Learn Repo 1. IOHK Launches ‘Marlowe Playground’ To Lower Barriers To Entry for Smart Contract Development IOHK unveils easy-to-use application-building platform that non-programmers can use to build financial smart contracts 2. What Is Haskell, Who Uses It, And Where Can You Learn To Code It Haskell language (and functional programming approach) has become more and more popular in the industry – businesses need robust and safe software solutions, and some of the problems can’t be solved without an advanced technological stack. 3. 100 Days of Code: Death of Summer on the Island of NixOS We are a hundred days deep in the Lambda Quadrant part of the galaxy, resting on a deep space Moonad, myself and my crew, my parter and my
lovematch, our infant son, and a cat. We study the properties and relations of Haskell abstract entities, enjoying meditating the pure functional programming vibe. It is deep work and we take time and turns. We also watch the second season of Star Trek Discovery and enjoy seeing the bright stars of its universe. 4. Seeing Javascript Objects as Functions Changed How I Code So you probably know that functions are objects in javascript (if not go up the prototype chain of a function to find out). But recently, I noticed that javascript objects can be treated like functions. Which leads to some pretty cool implications! 5. Functional Programming is not What Makes Haskell Great This post is substantially directed to non Haskellers. Haskell frequently appears on hackernews or /r/programming but the content is commonly evangelizing some aspect of functional programming, strong types, and purity. Thank you for checking out the 5 most read stories about Haskell on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

5 Stories To Learn About Haskell

105 Stories To Learn About Functional Programming

The Grand Inquisitor

Bertrade de Montfort had been posted off to France in charge of her mother

A bent old woman lived in the heart of London

The Religion of Atheists 

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

The live streaming market is booming As an industry, live streaming is already worth billions of dollars and it’s only expected to grow. According to various projections, including one by Grand View Research, the live streaming industry is expected to climb from billion in 2021 to almost billion in 2028. That’s a projected three-fold increase over seven years! $70 $224 How to get involved in the live streaming market? With the rapid development of the live streaming industry, many technology companies have been derived to serve the live streaming industry by providing mature technologies to help users quickly build their own live streaming apps.
Here I will introduce how to quickly build your own live streaming app by using ZEGOCLOUD's ZEGOLive SDK. What features does ZEGOLive SDK provide? The ZEGOLive SDK provides all features that required by a live streaming app, such as creating and join a live stream room, co-hosting, face beautification, audio effects, virtual gifting, sending bullet-screen messages, and more. And all these features can be tried out by simply experiencing and integrating ZEGOCLOUD's . Demo App for Live Streaming The following table shows ZEGOLive SDK's features: How to use ZEGOLive SDK step 1. Create a ZEGOCLOUD account Create an account in . ZEGOCLOUD Official step 2. Create a new project Create a project in . ZEGOCLOUD Admin Console step 3. Understand the process The following diagram shows the basic process of creating a live room and a participant (user B) playing a stream published by the host (user A). step 4. Integrate the ZEGOLive SDK To integrate the SDK, do the following: Download the , and copy the folder to your project directory (create a new project if you don't have an existing project). Sample codes ZEGOLive Add the file to your project directory. Podfile pod 'ZIM'
pod 'ZegoExpressEngine' Open Terminal, run the command. install pod install step 5. Add permissions Permissions can be set as needed. Open Xcode, select the target object, and then click . Info > Custom iOS Target Properties Click the to add camera and microphone permissions. Add button (+) Privacy-Camera Usage Description Privacy-Microphone Usage Description step 6. Initialize the ZEGOLive SDK To initialize the ZEGOLive SDK, get the instance, pass the AppID of your project. RoomManager // Initialize the SDK. We recommend you call this method when the application starts.
// YOUR_APP_ID is the AppID you get from ZEGOCLOUD Admin Console. 
RoomManager.shared.initWithAppID(appID: YOUR_APP_ID) { result in
    // Callback for the result of init. 

}; To receive callbacks, set the corresponding to , or call the method to listen for and handle event callbacks as needed. delegate self addUserServiceDelegate RoomManager.shared.roomService.delegate = self
RoomManager.shared.userService.addUserServiceDelegate(self)
RoomManager.shared.messageService.delegate = self step 7. Log in To access the ZEGOLive service, you must log in first. <div class="mk-warning"> For business security, you will need to provide a token for the ZIM SDK to validate the login privilege. For details, see . Authentication For debugging, you can refer to our to generate tokens on your app client.
</div> Sample code let userInfo = UserInfo("YOUR_USER_ID", "YOUR_USER_NAME", .participant)
let token: String = "YOUR_TOKEN"
RoomManager.shared.userService.login(userInfo, token) { result in  
     // Callback for the login result. 

} step 8. Start the local video preview Before creating a live room to start live streaming, you can call the method to start the local video preview. playVideoStream // The [userID] can be used to specify which user's view you want to view. 
// To preview your own local video view, pass in your userID.
// streamView view is a view for the local video preview.
RoomManager.shared.deviceService.playVideoStream(userID, view: streamView) step 9. Create/Join a live room You become a after creating a live room, and you can take a seat and start live streaming upon creating. Host You become a after joining a live room, and you can watch the live streaming and be a to interact. Participants co-host <div class="mk-warning"> To prevent the participants from speaking directly without co-hosting, you will need to provide a Token for the RTC SDK to validate whether you have the privileges to create or join a room. For details, see . Use Tokens for authentication This Token can be the same as the Token you provided for login.
</div> To create a live room, call the method. createRoom RoomManager.shared.roomService.createRoom("YOUR_ROOM_ID", "YOUR_ROOM_NAME", token) { result in
    // Callback for the result of create a live room. 
           
} After a live room is created, to start live streaming, the host will need to call the method to speak. And the SDK automatically publishes the streams when the host takes a seat successfully. takeSeat RoomManager.shared.userService.takeSeat { result in
   // Callback for the result of take a seat. 

} To join a live room, call the method. joinRoom RoomManager.shared.roomService.joinRoom("YOUR_ROOM_ID", token) { result in
   // Callback for the result of join a live room. 

} After joining a live room, for a participant to watch the live streaming, he will need to call the method to play the host's published streams. playVideoStream // The [userID] can be used to specify which user's view you want to view. 
// You can get the userID of the host in room info. 
// streamView is the view to be displayed.
RoomManager.shared.deviceService.playVideoStream(userID, view: streamView) step 10. Send/Receive text messages To send text messages in the room, call the method. sendTextMessage RoomManager.shared.messageService.sendTextMessage("MESSAGE_CONTENT") { result in
    // The result of send messages. 
} To receive the text messages, listen for the callback . receiveTextMessage func receiveTextMessage(_ message: TextMessage) {
    // Implement the handling logic when receiving the text messages.
} step 11. Renew a Token 30 seconds before a Token expires, the SDK sends out a notification through the callback. onRoomTokenWillExpire Upon receiving this callback, you need to get a new Token from your app server first, and then pass the new token to the method. renewToken func onRoomTokenWillExpire(_ remainTimeInSecond: Int32, roomID: String?) {
   let token: String = xxxxx ///new token
   RoomManager.shared.roomService.renewToken(token, roomID: roomID)
        
} step 12. Leave a live room Before the host leaves the live room, he will need to call the to leave the seat first. And the SDK automatically stops publishing streams when the host leaves the seat successfully. leaveSeat RoomManager.shared.userService.leaveSeat { Result in
     // Callback for the result of leave a seat. 
} To leave the live room, call the method. And the SDK stops all the stream publishing and playing operations simultaneously. leaveRoom RoomManager.shared.roomService.leaveRoom { Result in
     // Callback for the result of leave a live room. 
} step 13. Log out To finish the ZEGOLive service, call the method. logout RoomManager.shared.userService.logout() If you want to learn more about live broadcast-related technologies. You can follow me or send me email Email:zegoclouddev@gmail.com Also published here.

How to Build a Live App in 10 Minutes with ZEGOCLOUD's ZEGOLive

To understand what really means, we first need to do a “match the following” exercise. Match the statements in the left column with the tech company that would have said this statement. cloud-native Statement Tech Company 1) Cloud-native is about how applications are created and deployed, not where. a) A cloud company that hasn’t broken much ground in the container world but has a popular alternative using managed services 2) Cloud-native is about using containers and Kubernetes to deploy and operate applications b) A company providing tools and/or services around DevOps processes and automation 3) Cloud-native is about utilizing fully managed auto-scale services in the public cloud c) An IT company that did amazing business in the pre-cloud era but struggling to stay relevant in the age of the cloud 4) Cloud-native is about utilizing DevOps oriented methodology to operate applications d) A powerful open-source foundation with serious marketing muscle, and that backs many container tech OSS projects If you guessed 1c, 2d, 3a, and 4b, then you are getting a fairly good idea of where this write-up is headed. In this write-up, there will be hyperbole, there will be ridicule, and there will be rhetoric. Unfortunately, all of it is quite well earned when it comes to the topic of “Cloud Native Apps”. Like many others in the tech industry, cloud-native, too, is an overused (even abused) term. The definition of cloud-native apps changes from vendor to vendor, depending on what they have to sell, and from thought leader to thought leader, depending on what they have to thought-lead (or should it be think-lead? I always get confused). Let us look at the first statement. Cloud-native is about applications are created and deployed, not . how where So, “where” is not important — may be the cloud, may not be the cloud. Then what are cloud-native apps native to really? An app running on-premises, if built using the “right architecture, processes, and culture” seems to have earned the right to be called cloud-native. It is like saying an app running on Android or Windows is “native to iOS”. I thought an app had to utilize some special characteristics and be optimized for the underlying platform to be called native to that platform. Anyway, we move along. Cloud-native apps are built using containers and orchestrated using Kubernetes When exactly did we decide that a packaging format for deployment and the use of a super complex resource orchestrator makes an application modern? Isn’t the idea to make sure that your app can accomplish what it has set out to do with the scale, availability, and reliability expected of it? Then why such specific requirements as the use of a packaging format and a sci-fi-esque-sounding technology? Anyway, by having a name (and more importantly a domain name) resonating with the term “Cloud Native”, the Cloud Native Computing Foundation ( ) has earned the SEO ranking to provide a credible-ish definition. CNCF So, we move along. Cloud-native is about utilizing fully managed auto-scale services in the public cloud No prizes for guessing the reference here is to AWS and their Lambda lovefest. It is a valid alternate narrative — focus on business logic expressed through code, don’t worry about where the code is running, how it scales, how the database is configured, how messages arrive, etc. In terms of doing justice to the “cloud-native” claim, it comes close — unprecedented scale and reduced infrastructure management have been consistent promises of the cloud since the early days. However, “short-lived pieces of code execution” suffering from things like “cold-start” (which can best be explained as a side-effect of internal implementation now unduly forced upon the customer cognition), are not suitable for all the computing people are doing. Not today at least. Let us keep going. Cloud-native is about utilizing a DevOps-oriented methodology to operate applications Automation, continuous integration, and continuous delivery/deployment are some things that come to mind when people say DevOps. These concepts are not really new and even if they were, they can be (and are being) used for delivering software that has nothing to do with the cloud — either for running or building such software. Exactly which part of makes this software cloud-native is not clear. DevOps fairy dust Even though this write-up sounds like venting, it is really meant to call out how so many of our statements (“our” being the tech industry) seem not to make sense even after one double-click. So, we should keep trying. Also published here

What Does "Building a Cloud-Native Application" Really Mean?

In one of my projects, I use the API of various services that provide images. My apps work with them quite well, but only until the API developers decide to change something in their API specification. In this case, I have to modify my entire app. I decided it was a good idea to separate the specifications of each service into a separate file so that when any of the APIs are changed, the rework of my app only consists of editing this configuration file. Any set of images can be represented in the form of a certain universal structure that can be used in many projects. Let's write an example of this in JSON format: dataset =
{
  "name": "My animals",
  "desc": "My animals dataset descrtiption",
  "items": [
    {"id": 0,
    "title": "My dog image",
    "thumbnail": "https://loremflickr.com/150/150/dog",
    "src": "https://loremflickr.com/1680/1050/dog"
    },
    {"id": 1,
      "title": "My cat image",
      "thumbnail": "https://loremflickr.com/150/150/cat",
      "src": "https://loremflickr.com/1680/1050/cat"
    },
    {"id": 2,
      "title": "My parrot image",
      "thumbnail": "https://loremflickr.com/150/150/parrot",
      "src": "https://loremflickr.com/1680/1050/parrot"
    }
  ]
} There is a kind of description of the dataset, and an array containing image elements with their descriptions and links to the sources of images themselves. If necessary, it will be possible to make changes to this structure, but these changes will usually be associated with some changes in our project. When we retrieve data from an image search service using the appropriate API, the results for each service will be different. For example, when using the Flickr service, the flickr.photos.search method will return results in the following format: response =
{
    "photos": {
        "page": 1,
        "pages": 89071,
        "perpage": 25,
        "total": 2226767,
        "photo": [
            {
                "id": "12312362",
                "title": "Cat",
                "description": {
                    "_content": "My favorite cat..."
                },
                "datetaken": "2015-06-05 19:23:19",
                "ownername": "User512341234",
                "latitude": "57.142993",
                "longitude": "33.699757",
                "place_id": "uQBm12323UrxpE99h",
                "url_q": "https://live.staticflickr.com/1957/45543214321_abcabcabac_q.jpg",
                "url_l": "https://live.staticflickr.com/1957/45543214321_abcabcabac_b.jpg",
            },
			...
		]
    },
    "stat": "ok"
  }
} Here the array of image elements is in the element. response.photos.photo The image url is in . response.photos.photo [index].url_l The thumbnail URL (image preview) is in . response.photos.photo [index].url_q And the description will be contained in . response.photos.photo [index].description._content Using the Pixabay API, the image search response will be as follows: response =
{
    "total": 23858,
    "totalHits": 500,
    "hits": [
        {
            "id": 736877,
            "pageURL": "https://pixabay.com/photos/tree-cat-736877/",
            "type": "photo",
            "tags": "tree, cat, silhouette",
            "previewURL": "https://cdn.pixabay.com/photo/2015/.../tree-736877_150.jpg",
            "largeImageURL": "https://pixabay.com/get/g07531348f4443b076ebc0567_1280.jpg",
        },
		...
    ]
} The array of image elements should be taken from the element. response.hits The image url is in response.hits[index].largeImageURL The thumbnail URL is in response.hits[index].previewURL The description will have to be taken from some other elements. In the examples above, I have omitted some of the fields to make it easier to understand their structure. To process responses from different services in the same way, we need to convert them to the format of our dataset. First, let's describe the classes that represent our image element and a set of images. For the image: class Item {
  constructor(object, schema) {
    this.id = getProperty(object, schema.item_id);
    this.title = getProperty(object, schema.item_title);
    this.desc = getProperty(object, schema.item_desc);
    this.thumbnail = getProperty(object, schema.item_thumbnail);
    this.src = getProperty(object, schema.item_src);
  }
} For the dataset: class Dataset {
  constructor(object, schema) {
    this.name = "";
    this.desc = "";
    schema.ds_name.forEach(e => { this.name += getProperty(object, e); });
    schema.ds_desc.forEach(e => { this.desc += getProperty(object, e); });
    this.items = getProperty(object, schema.items).map(
      i => new Item(i, schema)
    );
  }
} The constructors of these classes create objects whose structure is similar to that of our dataset. In the dataset constructor, we also call the constructor to create the items. The getProperty function allows you to get the value of an element from any object by specifying the path to it (for example, photos.photo). You can see its code later. The key point here is that we pass 2 parameters to the constructors: and . object schema is the original formatted dataset or image element that the API service returned to us. object - an object containing the mapping of object elements to elements of our dataset. schema We can put the above code in datasets.js file as a module. Let's describe the schemas for three image services (Flickr, Pixabay, Pexels): export const FLICKR_SCHEMA = {
  ds_name: ["My Flickr dataset. Page#: ", "photos.page", ", total pages: ", "photos.total"],
  ds_desc: ["Photos per page: ", "photos.perpage"],
  items: "photos.photo",
  item_id: "id",
  item_title: "title",
  item_desc: "description._content",
  item_thumbnail: "url_q",
  item_src: "url_l"
};

export const PIXABAY_SCHEMA = {
  ds_name: ["My Pixabay dataset. Total: ", "total"],
  ds_desc: ["Total hits: ", "totalHits"],
  items: "hits",
  item_id: "id",
  item_title: "title",
  item_desc: "tags",
  item_thumbnail: "previewURL",
  item_src: "largeImageURL"
};

export const PEXELS_SCHEMA = {
  ds_name: ["My Pexels dataset. Page: ", "page"],
  ds_desc: ["Per page: ", "per_page", " Total results: ", "total_results"],
  items: "photos",
  item_id: "id",
  item_title: "photographer",
  item_desc: "url",
  item_thumbnail: "src.tiny",
  item_src: "src.original"
}; The names of the keys in the schemas correspond to the format of our dataset, and the values tell us from which elements to take for the corresponding keys. As you can see, we refer to different elements depending on the service. For ds_name and ds_desc, I used arrays, which will be concatenated into a string using forEach in the dataset constructor. Let's save our schemas in the dataschemas.js file. To test this idea, we will develop a simple web application based on the following logic: Enter search string Select an image search service Click the "Search" button Call the API of the corresponding service and get the result Call the Dataset constructor, into which we transfer the received response in JSON format, as well as the corresponding API schema The constructor returns an object of the format of our dataset Use a function to draw the resulting images into the DOM Let's sketch out the HTML structure: <!DOCTYPE html>
<html>
<head>
  <meta charset='utf-8'>
  <meta http-equiv='X-UA-Compatible' content='IE=edge'>
  <title>Image APIs Schemas</title>
  <meta name='viewport' content='width=device-width, initial-scale=1'>
  <link rel='stylesheet' type='text/css' media='screen' href='main.css'>
  <script type="module" src='main.js'></script>
</head>
<body>
  <header>
    <input id="searchText" type="text" placeholder="Input search text" value="skyline">
    <select id="sourceType">
      <option value="flickr">Flickr</option>
      <option value="pixabay">Pixabay</option>
      <option value="pexels">Pexels</option>
    </select>
    <button id="searchImages">Search Images</button></header>
  <main></main>
</body>
</html> In the HTML file, we will include our main.js script as a module. The main.css file contains the minimum style settings for the correct display of elements. Image services use personal API keys, let's put them in a separate file, api_keys.js: export const FLICKR_API_KEY = "abcdef123456789";
export const PIXABAY_API_KEY = "abcdef123456789";
export const PEXELS_API_KEY = "abcdef123456789"; Anyone can get the keys for free by registering on the corresponding service. Let's include our JS files in the main.js script and write some code to implement our logic: import { Dataset } from "./datasets.js";
import * as Schemas from "./dataschemas.js";
import * as Keys from "./api_keys.js";

let myDataset;
let flickrSearchURL = "https://api.flickr.com/services/rest/?method=flickr.photos.search&format=json&nojsoncallback=1&sort=interestingness-desc&per_page=5&page=1&extras=o_dims,url_sq,url_t,url_s,url_q,url_m,url_n,url_z,url_c,url_l,url_o,description,geo,date_upload,date_taken,owner_name&per_page=25";
let pixabaySearchURL = "https://pixabay.com/api/?image_type=photo&per_page=25";
let pexelsSearchURL = "https://api.pexels.com/v1/search?per_page=25";

window.onload = () => {

  document.querySelector("#searchImages").onclick = () => {
    let queryString = document.querySelector("#searchText").value;
    let sourceType = document.querySelector("#sourceType").value;
    let searchUrl, options, schema;

    switch ( sourceType ) {
      case 'flickr':
        searchUrl = `${flickrSearchURL}&api_key=${Keys.FLICKR_API_KEY}&text=${queryString}`;
        schema = Schemas.FLICKR_SCHEMA;
        options = {mode: "cors"};
        break;
      case 'pixabay':
        searchUrl = `${pixabaySearchURL}&key=${Keys.PIXABAY_API_KEY}&q=${queryString}`;
        schema = Schemas.PIXABAY_SCHEMA;
        options = {mode: "cors"};
        break;
      case 'pexels':
        searchUrl = `${pexelsSearchURL}&query=${queryString}`;
        schema = Schemas.PEXELS_SCHEMA;
        options = {headers: {Authorization: `${Keys.PEXELS_API_KEY}` }, mode: "cors"};
        break;
    }

    fetch(searchUrl, options)
    .then( response => response.json())
    .then( json => {
      console.log(json);
      myDataset = new Dataset(json, schema);
      myDataset.draw(document.querySelector("main"));
      console.log(myDataset);
    });
  }
  
} In the code, we have one onclick event handler on the button, which implements the algorithm described above. Depending on the selected service, we form the corresponding search URL string, call the API, and create a dataset, converted from the result using the appropriate schema. Now it's time to test our application. Let's install a web server: npm install http-server –g To start the web server, we will use the command (you can specify any other port): http-server -p 3000 This is how the page of our application looks like: Let's search on Flickr: By adding the output of the response received from the Flickr service and the resulting dataset to the developer console, we can see how the results were converted to the desired format: The same for the Pixabay service: And for the Pexels service: Thus, to add a data transformation for an additional service, you just need to add a description of the schema of this service to the dataschemas.js file and use this schema when calling the dataset constructor. If the API specification changes, simply correcting the schema description will be enough. I would like to note that this approach is applicable not only to image search services but also to any other services that are similar in type of returned results. I hope that this idea will be useful to someone developing similar applications. The source code of the project can be taken here: https://github.com/yuridanil/apimapping

Using JSON Mapping to Work with APIs of Various Image Services

Building a from-scratch server or using a lightweight framework is empowering. With that power comes responsibility, specifically the responsibility to securely store user’s passwords. Not understanding the security implications of password storage can lead to devastating breaches and leaks. If you are building an application and need to store user credentials, learn about hash functions. Can I Store Passwords In Plain Text? To demonstrate the potential dangers, let us assume we DON’T hash passwords on a fake example website, . Inevitably when a hacker or disgruntled employee obtains access to database, they will download all the usernames and passwords: LoveMatchingToday LoveMatchingToday’s user.one@gmail.com – somePa$$wordHere user.two@hotmail.com – otherPlainTextPass Now the attacker can go to other websites, and because a majority of people reuse passwords on different websites, they can hack other systems. Solution – Hashing . Because hashes are one-way, the attacker can’t re-create the plaintext password from the hash. Now the attacker would find something like this in the database: A hash function (or more specifically in our case, a key derivation function ) deterministically creates a strong key from a password user.one@gmail.com – cab864878af008fbc550087940ffacdb79a7f82201725e3350e25d6cfbdd4255 user.two@hotmail.com – 42a7fd2b639d18b3aba5db8504d4530f1f1ab58ab9615414b7629d6ec5c157b8 They won’t be able to use the hash to log in on other systems because they don’t have access to the original password. In Python, is a strong key derivation function that can be used in production systems: Bcrypt <code style="box-sizing: border-box; font-family: Consolas, &quot;Andale Mono WT&quot;, &quot;Andale Mono&quot;, &quot;Lucida Console&quot;, &quot;Lucida Sans Typewriter&quot;, &quot;DejaVu Sans Mono&quot;, &quot;Bitstream Vera Sans Mono&quot;, &quot;Liberation Mono&quot;, &quot;Nimbus Mono L&quot;, Monaco, &quot;Courier New&quot;, Courier, monospace; color: rgb(255, 255 , 255 ); background-color: transparent; border: 0 px; padding: 0 px; font-size: 0.85 em; border-radius: 3 px;">import bcrypt bcrypt.hashpw('userPlainTextPassword'.encode(), bcrypt.gensalt())</code> Rainbow Tables and Salts You may have wondered in the above code snippet what the function does. If we were to hash passwords without salts, an attacker could do a attack in order to find the original plain text. gensalt() rainbow table A salt is a random string of data hashed alongside a password to keep the hash result unique. each time a new password is saved, and the salt is stored alongside the hashed result so that it can be used again for comparison. so that developers don’t need to do the extra work. Salts should be recreated Libraries like bcrypt are smart enough to store the salt IN the resulting string For example, let’s say that wisened up and started hashing passwords, but didn’t include unique salts. An attacker could have a precomputed table of hashes: LoveMatchingToday aab864878af008fbc550087940ffacdb79a7f82201725e3350e25d6cfbdd425f = password123 afg3683232297323f2f0087940ffacdb79a7f8284723732350e25d6cfbdd4cccc = shadowTheHedgehog1234 They could then check each hash they find and see if a hash matches an entry in their table. If so, they can effectively “reverse” the hash and learn the original plaintext. For this reason, we need to salt passwords. Luckily Bcrypt handles salting automagically. For the sake of learning, however, let’s assume they didn’t. If they didn’t, our pseudocode would look something like this: salt = creatRandomSalt()
hashedPassword = hash(newPassword.concat(salt))
database.save(hashedPassword, salt) hashedPassword, salt = database.GetUserCredentals()
passwordInput = userInput
if hash(passwordInput.concat(salt)) == hashedPassword:
  login() failure() <code style="box-sizing: border-box; font-family: Consolas, ;Andale Mono WT ;, ;Andale Mono ;, ;Lucida Console ;, ;Lucida Sans Typewriter ;, ;DejaVu Sans Mono ;, ;Bitstream Vera Sans Mono ;, ;Liberation Mono ;, ;Nimbus Mono L ;, Monaco, ;Courier New ;, Courier, monospace; color: rgb( , , ); background-color: transparent; border: px; padding: px; font-size: em; border-radius: px;"> &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot 255 255 255 0 0 0.85 3 # Save new password # Check password else: </code> However, since Bcrypt stores the salt automatically with the hashed result in the “ ” format, we can just use the following code: {salt}{hashed} import bcrypt hashAndSalt = bcrypt.hashpw(password.encode(), bcrypt.gensalt()) valid = bcrypt.checkpw(password.encode(), hashAndSalt) <code style="box-sizing: border-box; font-family: Consolas, ;Andale Mono WT ;, ;Andale Mono ;, ;Lucida Console ;, ;Lucida Sans Typewriter ;, ;DejaVu Sans Mono ;, ;Bitstream Vera Sans Mono ;, ;Liberation Mono ;, ;Nimbus Mono L ;, Monaco, ;Courier New ;, Courier, monospace; color: rgb( , , ); background-color: transparent; border: px; padding: px; font-size: em; border-radius: px;"> &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot &quot 255 255 255 0 0 0.85 3 # password = userInput # save in data base "hashAndSalt" # To check: # password = userInput </code> Thanks For Reading If you have questions hit me up on twitter! Lane on Twitter: @wagslane Lane on Dev.to: wagslane Download Qvault: https://qvault.io Previously published at https://qvault.io/2020/01/29/hashing-passwords-python-cryptography-examples/

Stories, News & Mentions about LOVESEAT

Loveseat’s Stories on HackerNoon