The Island Book of Records brings the early years of this iconic record label to life. A fifteen-year labour of love, the volumes will fully document the analogue era of Island. Offering a comprehensive archive of album cover design and photography ...

The Island Book of Records Volume I: 1959-68

The global feed management software market is expected to grow at a CAGR of 6.23% from 2023 to 2030, reaching a value of USD 1.9 billion by 2030. Get Free Sample PDF Copy of Latest Research on ...

Feed Management Software Market Potential Unveiled Thriving Growth and Emerging Trends Until 2030 | Channable, VersaFeed, Amelicor

From the original acoustic balladry of Vashti Bunyan to the magical modern indie folk of Big Thief, the intimate, sometimes mournful, storytelling nature of folk has quite perfectly translated into the contemporary, broadening the rock genre and the singer ...

Some Kinda Love: Performing The Music Of The Velvet Underground

Along with, Feed Management Software Market report focuses on the in-depth analysis on the key players [iRely, DataFeedWatch, 3dcart, Amelicor, Channable, Products Up, VersaFeed, etc]. We have ...

Feed Management Software Market: Future Growing Trends and Forecast from 2023 to 2030

This post was sponsored by Channable. The opinions expressed in this article are the sponsor’s own. The nature of ecommerce marketing has grown increasingly complex. Gone are the days when you ...

How To Drive More Sales: The Ultimate Multichannel Ecommerce Marketing Guide

This post was sponsored by Channable. The opinions expressed in this article are the sponsor’s own. The nature of ecommerce marketing has grown increasingly complex. Gone are the days when you could rely solely on a single channel to drive sales for your ...

The Ultimate Multichannel Ecommerce Marketing Guide: How To Drive Discoverability, Performance & Sales

PJ Harvey’s tenth studio album I Inside the Old Year Dying marks her first release in seven years, following UK number 1 album The Hope Six Demolition Project. On this album, which was recorded with long-time creative collaborators John Parish and Flood ...

I Inside the Old Year Dying

Top “ Feed Management Software Market ” Size 2023 Key players Profiled in the Report are [, iRely, DataFeedWatch, 3dcart, Amelicor, Channable, Products Up, VersaFeed, Boostmyfeed, GoDataFeed, Shoptimised,

2023 | Feed Management Software Market Size, Growth and Industry Forecast 2028

Look no further! MarketPlace Expert is an official partner of the Channable Integrator! 🤖 Our expert team at MarketPlace Expert is here to assist you every step of the way, from setting up ...

Channable integrator for Marketplaces

Channable

channable

Deep Dive into Functional Programming in Javascript

 Making List-Like Objects in Python - The Right Way

Repository: entronad/crypto-es npm: crypto-es Needs of encryption, decryption and hash are quite common in both front and back end projects. When dealing with sensitive data, functions with the name like , or may be quite often seen in your codes. MD5 Base64 AES Of all JavaScript cryptography libraries, is mostly widely used for its simple APIs and rich variety of functions. It derives in early years, and the main codebase is still on the Google Code. Although it has been migrated to npm, the last update was 3 years ago. For historical reasons, some of it’s features seem out of date for modern usages: CryptoJS It creates an unique object oriented system based on prototypal inheritance to simulate class inheritance. The files use Immediately Invoked Function Expression (IIFE) to export modules. Before ECMAScript 6, these features avoided certain defects of JavaScript while ensuring browser compatibility and out-of-the-box usage. But since the new ECMAScript standard has specified the Class and Module system to solve those defects, I would try to experimentally refactor CryptoJS in modern ECMAScript. The project is called . As an experiment, the compatibility would not be the first concern, and the only rule is to meet the latest ECMAScript standard. For example, I would only use ECMAScript Module for the module system, with out CommonJS support. With the help of Babel and loader hook, this project could satisfy any production application. And as the ECMAScript standard gets more widespread, there would be more directly usages of it. CryptoES Besides, as a refactoring project, it’s APIs is all the same as CryptoJS. Refactoring to the ECMAScript Class CryptoJS extends the JavaScript prototypal inheritance and implements an unique “base objects inheritance” system. It has functions such as extend, override, mixin, etc. which makes it like general class-based OOP languages. This is defferent in approach but the same in purpose of the ECMAScript Class. Our first step is to replace this unique inheritance system with classes, which would make the code concise. But before that, let's have a review of some key concepts of the ECMAScript Class: 1. constructor We know that in ECMAScript, class definition is a syntactic sugar of traditional JavaScript constructor. So we could get access to an instance’s class through it’s constructor field. What could we do with this knowledge? In an instance's instance methods, we could create a new instance which has the same class as the former one by expression new . this.constructor() 2. this Unlike in the traditional JavaScript prototypal inheritance, in ECMAScript Class inheritance, while creating an instance, the constructor of it’s super class will firstly called, and then the fields and methods of the super class will be added to the instance, finally the constructor of the instance will be called. This makes sure that the fields and methods defined in the sub class will override the super class’s correctly. Note that this in instance methods refers to the instance, while this in static methods refers to the class. So we could implement factory mode by calling new this() in the static methods of a class. 3. super In the class definition, with parentheses refers to super class's constructor, while super without parentheses in static methods, just like this, refers to super class. So, when overriding methods, we could call the overridden method of the super class first by expression . super() super.overridedMethod.call(this) 4. prototype & __proto__ A class is a constructor in essence, so it has a prototype field referring to its prototype object. And a class is also an object, so it has a field referring to it's super class too. Since the prototype of a class has a field referring to it's super class's prototype object, this composes a prototype chain. __proto__ __proto__ An instance’s field refers to the prototype object of it's class. __proto__ With these features, we could get the inheritance relations of both instances and classes. The commonly used version of CryptoJS nowadays is hosted on the GitHub: ，which will mainly based on. It’s “base objects” are defined in the file. brix/crypto-js CryptoES core.js The inheritance is implemented in the object named Base: Base = C_lib.Base = ( { { : { subtype = create( );
​ (overrides) {
        subtype.mixIn(overrides);
      }
​ (!subtype.hasOwnProperty( ) || .init === subtype.init) {
        subtype.init = {
        subtype.$ .init.apply( , );
      };
    }
​ subtype.init.prototype = subtype;
​ subtype.$ = ;
​ subtype;
    },
​
    create: { instance = .extend();
      instance.init.apply(instance, );
​ instance;
    },
​
    init: {
    },
  };
}()); var ( ) function return extend ( ) function overrides // Spawn var this // Augment if // Create default initializer if 'init' this ( ) function super this arguments // Initializer's prototype is the subtype object // Reference supertype super this return ( ) function var this arguments return ( ) function In fact, the inheritance is implemented by calling the extend method of the "super object" with arguments of overriding fields and methods, and the extend method creates a new "sub object". The real instance will be returned by the create method of this "sub object", of which the init method will be called as a constructor. The disadvantage of this approach is that instances are not created with the keyword new as regular. And an instance will recursively keeps all the "ancestor objects" of its inheritance chain in the $super field, which is certainly redundant. These goals could easily achieved with the keyword extend and class constructor of ECMAScript Class, with out any extra codes or problems above. But for the consistence of the APIs, the static method create is kept, so that you could create instances with . The arguments of the create method will be passed to the real constructor by the rest operator and the argument destruction: ClassName.create() { create(...args) { (...args);
  }
} export class Base static return new this the basic purpose of Base is to provide the mixin method. In CryptoJS, the boundary between "class objects" like Base and real instance objects is fuzzy, and the mixin method could be called by "class objects": mixIn: { ( propertyName properties) { (properties.hasOwnProperty(propertyName)) { [propertyName] = properties[propertyName];
    }
  }
​ (properties.hasOwnProperty( )) { .toString = properties.toString;
  }
}, ( ) function properties for var in if this // IE won't copy toString using the loop above if 'toString' this But in both logic and fact, the mixin method should be an instance method, which just acts like : Object.assign() mixIn(properties) { .assign( , properties);
} return Object this Finally, the copying of instances. With prototypal inheritance, the CryptoJS implementation is quite odd: clone() { clone = .constructor(); .assign(clone, ); clone;
} const new this Object this return Since new could be used in any instances with out indicating it's the class name, we could do it in a more straight way: this.constructor() clone() { clone = .constructor(); .assign(clone, ); clone;
} const new this Object this return Then, by inheriting the Base class, all other core classes will have these methods. And with ECMAScript Class, the usage of methods would be more standardized. For example, in CryptoJS, some instance creating methods of Wordarray are: WordArray = C_lib.WordArray = Base.extend({ : {
    words = .words = words || [];
​ (sigBytes != ) { .sigBytes = sigBytes;
    } { .sigBytes = words.length * ;
    }
  }, : {
    ...
    return WordArray.init(words, nBytes);
  }
});

But now they are standard or static methods:

export class WordArray extends Base { (words = [], sigBytes = words.length * 4) { ();
​ .words = words; .sigBytes = sigBytes;
  }
​ random(nBytes) {
    ...
    return WordArray(words, nBytes);
  }
} var init ( ) function words, sigBytes this if undefined this else this 4 random ( ) function nBytes new constructor constructor super this this static new After this refactoring to class, we should add some extra unit test for the inheritance relations: of the sub class must refer to the super objects of sub class and super class are of right order in the prototype chain. __Proto__ class.prototype prototype objects of sub class and super class are of right order in the prototype chain. data.Obj = {
};

data.obj = data.Obj.create();

it( , () => {
  expect(data.Obj.__proto__).toBe(C.lib.Base);
});

it( , () => {
  expect(data.obj.__proto__.__proto__).toBe(C.lib.Base.prototype);
}); . . class Obj extends C lib Base 'class inheritance' 'object inheritance' WordArray and Bitwise Operations Bitwise operations are the foundation of cryptography algorithms. What ever the data type is, bitwise operation treats them as a contiguous sequence. For sack of performance, bitwise operation would better acting on a section of contiguous memory. Some languages provide ways to operate the contiguous memory, such as pointer in C++ and ArrayBuffer in ECMAScript 6. JavaScript was designed as a script language for browser at first, so there was no memory operation before. But there is still a way to get the abstraction of the bitwise sequence, which is Binary Bitwise Operators. According to the specification, in the operation with binary bitwise operators, all operands, whatever their origin types are, will be convert to 32 bits unsighed int by ToInt32(). Then they are treated as 32 bits length sequences, and the result is a 32 bits unsighed int. So, by splicing these 32 bits unsighed ints, we could simulate the operation on a contiguous memory. Based on this, CryptoJS implemented a class called WordArray, as the abstraction of the bitwise sequence. WordArray is the most important basic class of CryptoJS, and all it’s algorithms handle with WordArray objects in underlying implementation. Thus understanding WordArray is the precondition to understand it’s algorithms. The definition of WordArray is in the file: core.js Note that all codes below are of . entronad/crypto-es { (words = [], sigBytes = words.length * 4) { (); .words = words; .sigBytes = sigBytes;
  }
  
  ...
} export class WordArray extends Base constructor super this this WordArray directly inherits from Base . It has two fields: word and sigBytes. words is an array of 32 bits unsighed ints, and By splicing elements of this array in order we can get the bitwise sequence needed. In JavaScript conversion between the 32 bits unsighed int and the bit is through Binary Complement. But we don't have to get involved with that because the value of this int is meaningless. Generally the bitwise sequence is measured by bytes, or presented as hex numbers, so we just need to know that 32 bits equal to 4 bytes, or 8 hex numbers. Encoding algorithms’ subjects are strings. So the bitwise sequences are all of whole bytes, or times of 8 bits. But they are not certainly times of 32 bits. So only by the length of words we can't get the actual length of bitwise sequence, for there may be some empty tailing bytes. So we need the field sigBytes indicates the actual significant bytes length. We could create a WordArray by directly passing these two fields: wordArray = CryptoES.lib.WordArray.create([ , ], ); const 0x00010203 0x04050607 6 For convenience of pruning the words with the sigBytes, there is a clamp method in WordArray: clamp() { { words, sigBytes } = ;
​ words[sigBytes >>> ] &= << ( - (sigBytes % ) * );
  words.length = .ceil(sigBytes / );
} // Shortcuts const this // Clamp 2 0xffffffff 32 4 8 Math 4 It will remove the “insignificant bytes” of the words . In the words array, the starting elements full of significant bytes will be kept, and the tailing elements with no significant bytes will be ignored through . words.length = Math.ceil(sigBytes / 4) The middle element with both significant and insignificant bytes is a bit difficult to deal with. Firstly we should calculate the length to remove: , and left move bitwise by this length to get a 32 bits mask, then locate this middle element by (just the same as int divided by 4) , finally and it with the mask to set the insignificant bytes to 0. (32 - (sigBytes % 4) * 8) 0xffffffff sigBytes >>> 2 Locating elements by and making and with masks is widely used in CryptoJS. >>> Just like clamp, the troublesome part of concat is also to handle the middle element: concat(wordArray) { thisWords = .words; thatWords = wordArray.words; thisSigBytes = .sigBytes; thatSigBytes = wordArray.sigBytes;
​ .clamp();
​ (thisSigBytes % ) { ( i = ; i < thatSigBytes; i += ) { thatByte = (thatWords[i >>> ] >>> ( - (i % ) * )) & ;
      thisWords[(thisSigBytes + i) >>> ] |= thatByte << ( - ((thisSigBytes + i) % ) * );
    }
  } { ( i = ; i < thatSigBytes; i += ) {
      thisWords[(thisSigBytes + i) >>> ] = thatWords[i >>> ];
    }
  } .sigBytes += thatSigBytes;
​ ;
} // Shortcuts const this const const this const // Clamp excess bits this // Concat if 4 // Copy one byte at a time for let 0 1 const 2 24 4 8 0xff 2 24 4 8 else // Copy one word at a time for let 0 4 2 2 this // Chainable return this Inside CryptoJs, WordArray is both input and output of most functions, but the external users concerns mostly about the string result. So WordArray provides overriding toString method: toString(encoder = Hex) { encoder.stringify( );
} return this Because the words array is of reference type, we should create a new copy of it by slice in the clone method: clone() { clone = .clone.call( );
  clone._data = ._data.clone();
​ clone;
} const super this this return Except the constructor, the static method random provides a random WordArray of certain length. Because of JavaScript is unsafe and returns a 64 bits float, we will do some extra processing: Math.random() random(nBytes) { words = [];
​ r = { _m_w = m_w; _m_z = ; mask = ;
​ {
      _m_z = ( * (_m_z & ) + (_m_z >> )) & mask;
      _m_w = ( * (_m_w & ) + (_m_w >> )) & mask; result = ((_m_z << ) + _m_w) & mask;
      result /= ;
      result += ; result * ( .random() > ? : );
    };
  };
​ ( i = , rcache; i < nBytes; i += ) { _r = r((rcache || .random()) * );
​
    rcache = _r() * ;
    words.push((_r() * ) | );
  }
​ WordArray(words, nBytes);
} static const const ( ) => m_w let let 0x3ade68b1 const 0xffffffff return => () 0x9069 0xFFFF 0x10 0x4650 0xFFFF 0x10 let 0x10 0x100000000 0.5 return Math 0.5 1 -1 for let 0 4 const Math 0x100000000 0x3ade67b7 0x100000000 0 return new ArrayBuffer and TypedArray Since the ArrayBuffer is included to the ECMAScript, it has been used in more and more scenes, such as WebSocket, file objects, and canvas outputs. While handling with these forms of objects, we also need to encrypt, decrypt or hash them in some cases. So CryptoJS extended the WordArray creator to allow ArrayBuffer and TypedArray as input. this extension is in a individual file, and dose a lot of checks and reconstructs the WordArray creator to ensure the compatibility. We integrate this to the origin WordArray constructor and simplified the these checks: lib-typedArrays.js (words = [], sigBytes = words.length * 4) { ();
​ typedArray = words; (typedArray ) {
    typedArray = (typedArray);
  }
​ (
    typedArray || typedArray || typedArray || typedArray || typedArray || typedArray || typedArray || typedArray ) {
    typedArray = (typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
  }
​ (typedArray ) { typedArrayByteLength = typedArray.byteLength;
​ _words = []; ( i = ; i < typedArrayByteLength; i += ) {
      _words[i >>> ] |= typedArray[i] << ( - (i % ) * );
    }
​ .words = _words; .sigBytes = typedArrayByteLength;
  } { .words = words; .sigBytes = sigBytes;
  }
} constructor super let // Convert buffers to uint8 if instanceof ArrayBuffer new Uint8Array // Convert other array views to uint8 if instanceof Int8Array instanceof Uint8ClampedArray instanceof Int16Array instanceof Uint16Array instanceof Int32Array instanceof Uint32Array instanceof Float32Array instanceof Float64Array new Uint8Array // Handle Uint8Array if instanceof Uint8Array // Shortcut const // Extract bytes const for let 0 1 2 24 4 8 // Initialize this word array this this else // Else call normal init this this Then WordArray creator could recive an ArrayBuffer or TypedArray so that CryptoES algorisms could apply to them: Then WordArray creator could recive an ArrayBuffer or TypedArray so that CryptoES algorisms could apply to them: words = CryptoES.lib.WordArray.create( ( )); rst = CryptoES.AES.encrypt(words, ) const new ArrayBuffer 8 const 'Secret Passphrase' Note that ArrayBuffer could not directly passed to algorisms, you should change them to WordArray first. With this, encrypting files would be easier fileInput = .getElementById( ); file = fileInput.files[ ]; reader = FileReader();
reader.readAsArrayBuffer(file);
reader.onload = { arrayBuffer = reader.result; words = CryptoES.lib.WordArray.create(arrayBuffer); rst = CryptoES.AES.encrypt(words, )
  ...
}; const document 'fileInput' const 0 const new ( ) function const const const 'Secret Passphrase' Stay Tuned! Previous published at https://medium.com/front-end-weekly/refactoring-cryptojs-in-modern-ecmascript-1d4e1837c272

Refactoring CryptoJS in Modern ECMAScript

This blog post is actually a draft for a standard operating procedure for my software development and consulting business. I’ve come across the task of writing tests for HTTP APIs for three or four times in the last couple of months. I’ve tried multiple ways of writing automated tests and this is the method I’ve converged on. TypeScript, Jest, and supertest appear to work well together and are sufficient to implement concise tests. Background and the need for standardization Years ago most of my programming for the web was limited to PHP. Tests on those project were done by using PHPUnit and Guzzle. Later we also used for more readable tests. After Docker became popular the PHP monolith evolved into an application built with multiple programming languages. Some small services are now written in Node.js, and new data analytics code is mostly in Python. Behat At first, it seemed obvious to write API level tests in the same language as the server. But after comparing solutions for Node.js, PHP and Python it became evident that quality and approaches vary between languages. Besides variance in quality, the problem was also time lost to learning each test framework. Investing time to learn Python was worth it because we can now use Pandas and Scipy to do analytics. And Jupyter is awesome for prototyping. In contrast, learning to test HTTP APIs in each language has no value. There is also no technical reason to program a web service and accompanying tests using the same language. There are multiple benefits to having a standard procedure for a task like HTTP API tests: you write a lot of tests with the same framework. After you learn the basics you can focus on higher level problems such as organizing tests, determining what to cover and testing more complicated APIs. Each time you create a new web service, you don’t waste time on Googling phrases like “what’s the best way to test REST API?”. Because of decision to standardize this piece of my workflow, I’m saving brain bandwidth for other decisions. My standard test stack My experience with has been overwhelmingly positive for the last couple of months. Most of the time I’ve been using it on the frontend with Angular. But it performs equally well on the backend too. Available tooling and type definitions make development with Express a breeze. Autocomplete functionality in IDEs such as VS Code is superb in comparison to plain JavaScript. Type checking helps a lot especially when refactoring. It supports modern features from ES2017 such as . I used to use Karma as a testing framework but finding a good combination of plugins and writing configuration was a nightmare. is a pleasant improvement. It works out of the box and has the common APIs you might already be familiar with: . Another important ingredient for testing HTTP APIs is a way of making requests. Superagent has very good and it works well with TypeScript. I like its chainable syntax. TypeScript async/await Jest describe, it, expect documentation Example of testing a simple GET request import request = require('supertest');

const BASE_URL = 'http://my-service:3000';

describe('Hello world', () => {    it('Should say "hello world"', async() => {        const response = await request(BASE_URL)            .get('/')            .expect(200);        expect(response.text).toBe("hello world");    });}); Function groups together tests for a specific feature. Function defines a test. In this particular case the test is an asynchronous function. It could also be a normal function or a function returning a Promise. In the next four lines we see the elegance of syntax. The execution is still asynchronous but the syntax appears to be very linear. This aligns the syntax with our mental model of consecutive steps. The line asserts that the response code is indeed . And finally we also check the contents of the response. describe it async/await .expect(200) 200 POST requests Sending data with POST and PUT requests looks like this: import request = require('supertest');

const BASE_URL = 'http://my-service:3000';

describe('POST /news', () => {    it('Should save and return back the news', async() => {        const response = await request(BASE_URL)            .post('/news')            .send({'title': 'Breaking news!'})            .expect(201);

        expect(response.body).toEqual({'id': 1, 'title': 'Breaking news!'});    });}); Instead of we used and added a call to to send our JSON. get(url) post(url) send(data) Authorization and other headers Headers can be set using as seen in the following example: set('header-name', 'value') import request = require('supertest');

const BASE_URL = 'http://my-service:3000';

describe('Authorization test', () => {    it('Should respond with 401 if token invalid', async () => {        await request(BASE_URL)            .post('/admin/news')            .set('Authorization', 'Bearer invalid')            .send({})            .expect(401)            .expect('WWW-Authenticate', /^Bearer/);    });}); I’m hoping this article will help you to set up tests quicker. Complete code is available at There you will find a simple service and corresponding tests. https://gitlab.com/mdrolc/testing-http-apis Originally published at https://drola.si/post/2019-02-19-testing-http-apis on February 19, 2019.

Standardizing HTTP API testing

I was never really concerned about the size of — my thinking was that you should not care too much about the tools you need to do the job. If you need a 20 kg hammer to drive a nail, you just take it. The same story with the , it may weight a few kilobytes or a few megabytes because our imaginary hammer comes with a set of heavy nails, right? Well, maybe, in theory. node_modules node_modules Let’s drop that fancy analogy and look at real-world examples. I will examine some @angular/cli dependencies — but only because it’s quite a big library. I don’t want to make it look bad — it’s just a good representation of an average package. I installed it in the empty directory using npm@5.5.1. Npm reported “added 976 packages in 107.13s” after installation (that’s 141 megabytes on disk). Okay so cli package it’s quite a robust library and its list of dependencies is a bit too long but perhaps all of them are needed. Let’s focus at the first selected package . Quick look at its documentation and you can say that it’s some kind of utils library with a number of common methods to work with the text. So far so good — general methods, easy to reuse. common-tags Just one little flaw — in deps of we see . A bit surprising, we just need some common text functions but — hey — it’s 2017 JS for you. Oh wait, it turns out that it wants and . Fortunately it ends here and — what’s more — is also utils library, quite a big one honestly! It has so many functions inside I bet a lot of other packages will be using it! common-tags babel-runtime core-js regenerator-runtime core-js Not really. Only has it in its deps. And returning to the starting point, cli uses only 3 (trivial) methods from — , , . babel-runtime Oopsie. common-tags stripIndents stripIndent oneLine Oopsie daisy. In order to use these 3 methods needs 1826 files. And that’s just 4 of mentioned 976 installed packages. node_modules This is your dream about lightweight package collapsing The next dependency is — it downloaded in total of 8 packages and 45 files — so not so bad. And other packages use these files too, mostly .The real bummer is 6 of these 8 are dependencies of and is used only once in to paint yellow deprecation message. core-object chalk chalk chalk core-object Other random findings: few packages to tackle the topic of “querystring” some attempts for assert methods varying in complexity from to minimalistic-assert assert-plus dozens of various packages is-* of packages to “prettifyfifafiying-whatever” errors and console prints a lot hundreds of polyfills/shims or reimplementation of native methods of course previous asserts sit in next to full node_modules lodash … and some partial methods from as separate deps lodash And, by random, I mean just picking some packages and brief searching for similar ones which was often really easy because the packages had similar names. Some of the found duplicates Let’s stop here. I bet other dependencies are . necessary and well thought That is nothing new for JS devs, it has been like that for a while now and this situation shouldn’t be accepted— size of is a topic of jokes and removal of packages like “left pad” is the cause of disasters. node_modules So how can it be fixed? By creating the Standard Library. proper means that it should be complete, containing a variety of common functions to operate on text, numbers, collections and a lot of functions, so that during 99.99% of the time you won’t need any other library. Is that fantasy? I don’t think so. Taking as the base some of the mentioned utils libraries and merging it with others would be a great start. Proper There is only one problem and that’s not even a technical problem — creating such a package would need someone to take a position of the leader. I think rather about absolute power than democracy — if you want to know how democracy handles this problem look again at your node_modules. It needs a powerful leader because it needs a solid plan, not just months of discussions. We already have all packages implemented, we just need to glue it together in a logical way. Right now, in pursuit of reusability and “keeping it DRY” typical directory ended up being completely WET. Just because we thought that dozen of packages with overlapping functionalities were better than one well planned library. node_modules Which is the bigger number, five or one? One army, a real army, united behind one leader with one purpose. Just a small note about jQuery — not so long ago, jQuery was in almost every project. Why? There were a number of solid reasons: It provides a set to commonly used functions in a convenient to use form. jQuery methods were easily chainable with each other (as result of being developed by one organization). It was widely known by everyone, so joining a project was easy, as there was no extra learning curve. Although some people complained about the size of jQuery it was mostly irrelevant as it was often loaded from CDN — so the for 90% of time it was already present on user’s computer. The last point is very important — it really doesn’t matter how big some library is if you don’t need to download it. I think about — it really has tons of functions that can replace a lot of unnecessary dependencies. With its modular structure and lack of dependencies is a great library to choose if you need something that is missing in JavaScript. lodash Picking some smaller library only because of its size is the same level of evil that you do when with some premature optimization practices — ending up with no performance gain and the confusing code. Same here — smaller, unorganized packages leads to redundancy, incompatibility and overall much bigger size. node_modules On the vertical axis is a size in KB, on horizontal individual packages At the beginning I said that I don’t care about the size of and this is partly true — I don’t care so much about space it takes, but I do care about the number of files. In case of @angular/cli almost 70% of disk space is the 20 biggest packages ( works everywhere!). node_modules Pareto principle What’s more — if you take a look at WinDirStat’s report below you will see that a lot of packages contain big files (for example sourcemaps, these are green). And in terms of copying files computers works better in case of a few big files than thousands of tiny ones. The node_modules report from WinDirStat. Packages in the right bottom corner can have only fractions of Planck length A large number of packages has one more drawback —the potential version incompatibility. Let’s assume each package has two versions 1.0 and 2.0. In the worst scenario some packages may need 1.0 and the others 2.0. The more packages are in our app, the more possible combinations you get. Resolving those combinations takes time, CPU and space to keep every occurrence of the old version needed by some equally old package. Epilogue This is the world we live in. The worst thing is that “it kinda works” so it’s not going to change anytime soon. Creating JS Standard Library would help but a real change is needed in developers mindset. So if you can remember one thing from my looong article, let it be “use lodash”. And if you can, take also “use popular packages that already are used by others”. Programming is not an Individuality Contest so choose tested, war-seasoned libraries and do not increase JavaScript entropy. Mandatory joke, I almost forgot about it

What’s really wrong with node_modules and why this is your fault

Consider the following scenario where a UI component in your web app depends on a certain resource on the back-end, but the data that makes up this resource must be aggregated from several different sources — perhaps from some micro-services through asynchronous calls. In this scenario, let’s say that we expect the UI to display an initial loading screen, which will then turn into a real-time progress status to report what’s going on in the back-end. If everything goes well, it finally renders the desired component when the aggregated data is received. My SignalR/.NET Core-based library, , provides me with the means to set up an asynchronous, real-time communication with a component that this scenario requires; however, in lieu of conventional imperative style, I want to make it declarative and reusable; something similar to a Promise object — but a component instead — that in effect schedules the display of another component for a value that has not been received. dotNetify React Basic Promise Here’s the initial design of the component: <Promise ="MyComponentVM">{resp => <MyComponent {...resp} /></Promise> viewModel By using this declarative style, the intent can be expressed succintly: when the Promise component is rendered, it will initiate a request to the back-end to get the data required to render and to render it when the response is received. MyComponent With dotNetify, hydrating the component is done through establishing a real-time connection with a rich view model on the back-end. We can make the view model stateful so it can keep track on those multiple asynchronous calls needed to build the response payload, and send it to our front-end when it’s complete. Promise with Progress To allow for progress reporting, we’ll make the component to accept more properties: <Promise ="MyComponentVM" ={resp => resp.Result} ={resp => <ProgressComponent steps={resp.Steps} />}{resp => <MyComponent {...resp} /></Promise> viewModel isResolved while The property receives a function used for deciding when to render (when the response contains ), and the property receives a function that renders . The fact that I can just pass a component to another component like this is a really cool feature. With React, your components are first-class citizens. isResolved MyComponent Result while ProgressComponent To summarize: when it’s rendered, the Promise component will establish a real-time connection with view model, which will, over a period of time, send multiple response payloads consisting of completed progress steps and finally, the result. The component will render the passed-in to show the completed steps so far while waiting for the final payload. And when it’s received, it switches to render and fulfill its promise. MyComponentVM ProgressComponent MyComponent View Model The back-end view model is written in C# and runs on multi-platform ASP.NET Core. It inherits from dotNetify’s base class, which gives it the API to designate which property has changed, and the API to push the changed properties to the front-end. For example, the snippet below will push the value of property to the front-end component: BaseVM Result (nameof(Result)); (); Changed PushUpdates We will use technology to combine multiple asynchronous data requests into a single data stream that the view model can subscribe to. The provided API allows us to receive completed requests one by one ( ), and gets notified when all responses are received ( ). ReactiveX OnNext OnCompleted Promise Implementation Here‘s the rudimentary implementation of the Promise component: You can easily continue to make this more robust, by adding mechanism to show an error message component when there’s network error, or problem with the back-end requests themselves. Check out a working demo of this at , under folder. https://github.com/dsuryd/dotnetify-react-demo Promise Even though this Promise component is not chainable, the need for chaining, which usually involves data aggregation or transformation, is effectively negated by having that logic done inside the back-end view model. Summary Fetching data from multiple, asynchronous sources for your web app is always a challenge and can bloat your front-end code with concerns that are really not UI-specific. The technique shown here brings significant advantages: programming Declarative way of incorporating promises keeps your code concise, reusable, and easy to read. Pushing data aggregation/transformation to the back-end makes your front-end clean, leaner, and encourages separation of concerns. Built-in asynchronous, real-time communication allows more robust user interaction, like true progress reporting, and opens up for more creative approach.

Designing Real-time Promise Component with React + .NET Core

Analogies to help understand Eve Welcome to Part IV of my VI-part series about , an exciting and fascinating new programming language. Eve How Eve unifies your entire programming stack I. When logic programming meets CQRS II. Throwing off our scope chains III. Smalltalk and protein programming IV. The rock-solid foundation for Eve’s big vision V. Why Eve will be perfect for realtime apps VI. Smalltalk with stateless APIs One of Eve’s influences is , an innovative programming language developed at Xerox PARC and released in 1980. In Smalltalk, a running program consists of objects, each with their own independently-programmed behavior, passing messages to one another. Smalltalk Wikipedia explains that a Smalltalk object can do exactly three things: 1. Hold state (references to other objects). 2. Receive a message from itself or another object. 3. In the course of processing a message, send messages to itself or another object. From 30,000 feet, Eve looks like Smalltalk because both kinds of programs are made out of self-contained chunks of code that can be dropped into a program, even while the program is running, which is called . live programming But once you zoom in and look at what the specific blocks are doing, the similarity breaks down: Smalltalk objects persist state between messages in lexical scope chains, while Eve blocks can only persist state between timesteps by writing to global databases. Instead of comparing Eve blocks to Smalltalk objects, it’s more accurate to compare them to , those blocks of server-side application-layer code that handle client requests to API endpoints. API handlers More precisely, Eve is similar to so-called “stateless” API handlers (ones that don't persist in-memory state between requests). Stateless API handlers are only allowed to do the following: Read from a request buffer Manipulate local variables Manipulate database data Write to a response buffer #2 and #3 are Eve’s bread and butter, and #1 and #4 are equivalent to manipulating the database (a subset of #3). So Eve is like Smalltalk with stateless APIs instead of objects. @request Protein programming Recall from biology class that are stateless API handlers running in your cells. They get called to do interesting jobs like catalyze chemical reactions and transport molecules. When they finish the job, they don’t persist any state; they reset back to their original configuration. proteins Have you ever wondered how cells their little API handlers? Check out Sean Johnson’s answer for : call Biology Stack Exchange “How does a protein reach its substrate within the cell?” The protein doesn’t move towards anything. It just randomly diffuses (bounces around) in the cell until it sticks to something. The particular chemical structure (the shape) of the protein and whatever it hits will determine how tightly they stick together and whether or not a chemical reaction occurs. […] that shows how proteins with a very specific shape bouncing around randomly can assemble into a complex structure. Here’s a cool video Now that we know the basic rules of “protein programming”, we can get some insight about Eve by looking at places where it’s similar to protein programming but different from mainstream programming: 1. Live programming We’ve seen that Smalltalk and Eve are “live programming” systems whose blocks of code can change without restarting the program. Similarly, a cell’s set of proteins can change at runtime without needing to restart the cell. This is a special case of live programming called “life”. 2. No single point of failure Any individual protein can get messed up and fail to do its job. But when a cell is deployed in an organism, it can’t afford to go offline for any reason. Luckily, no single protein failure can corrupt the cell’s state that much, so the vast majority of other cellular processes don’t care when single proteins fail. Furthermore, error-checking and redundancy can be layered in, in the form of other proteins. 3. Programming without order In , glucose is broken down in a series of reactions in order to eventually create , the “energy currency” of a cell. The whole process happens in the cell’s cytoplasm, a.k.a. that liquid where all the proteins bounce around like crazy. Glycolysis ATP Glycolysis is a “metabolic pathway”, but the individual proteins don’t encode the fact that they’re part of anything larger — each one only encodes the logic for when to run and the state modifications it makes when it runs. The proteins just happen to be chainable in such a way that one’s output can be the next one’s input. In a cell, that timeless input-output chain structure ends up being mapped into an actual chain of events running in time; it’s just that the timing isn’t explicit in the proteins. Eve calls itself “programming without order” because its blocks of code don’t explicitly represent the order of their execution pathways, just like proteins don’t explicitly encode the glycolysis pathway. In a distributed system like a cell or database, implicitly ordered processes are more robust than ones that try to coordinate their timing explicitly. For example, during glycolysis, if one protein’s output gets gobbled up by some other cellular process, the metabolic pathway automatically knows not to keep running. And if that intermediate output later reappears, the metabolic pathway knows how to pick up where it left off. 4. Code triggered by data Whenever there’s a glucose molecule hanging out in the cytoplasm, that’s when the first glycolysis protein calls itself in (a “hexokinase” in case you were wondering). is a mainstream paradigm, but a glucose molecule hanging around is just ordinary data; it’s not an event. A glycolysis protein is a case of code triggered by data, just like an Eve block. Event-driven programming By the way, it looks like biologists have independently discovered the value of . Compare: literate programming Blackboard systems “Protein programming” is my own term for a process that emerges out of stateless-API-like components. Another apt metaphor-term for this is : blackboard system A group of specialists […] all watch the blackboard, looking for an opportunity to apply their expertise to the developing solution. When someone writes something on the blackboard that allows another specialist to apply their expertise, the second specialist records their contribution on the blackboard, hopefully enabling other specialists to then apply their expertise. This process of adding contributions to the blackboard continues until the problem has been solved. Notable prior art for blackboard systems includes and . tuple spaces Linda **Next post:** The rock solid foundation for Eve’s big vision V.

Smalltalk and protein programming

jQuery was created in a far away 2006. At the time it was a huge time saver for many developers. Solving a lot of nasty crossbrowser issues, jQuery was a de-facto library in every new project. Today browsers become smarter every day and the need of jQuery slowly fading. Many people tell it’s a good time to throw the library away claiming there is no place for jQuery in our modern world. I think different and the article is about to tell you why. jQuery costs size I divide all the web page files in four categories: Critical content — the first 100vh of the website (Must be delivered ASAP. E.g. the first screen on our awesome ) https://phoenix-startup.com 💜 Main content — all the text, styles, pictures, videos user has come to see. Scripts — all your animations, forms submission and other pretty interactions. User possibly will use any of them. Other — ads, analytics, tracking. User doesn’t need any of it. A typical website or webapp scripts (logic) is the 3rd category files. This means user will need it after getting all the html, css and maybe some pictures. Let me explain it a bit: after getting the page user will spend some time watching your content (text, pictues) decising what to do, where to click or where to scroll. That means plus of background work .And, yeah. You can’t promise your jQuery-less code will perform much faster 😉 187ms* doesn’t make any sense As a bonus a GUI tool to create your own build of jQuery: http://projects.jga.me/jquery-builder/ And the last but not the least. Try to fix your main loading speed and performance issues before starting to blame jQuery. Have a look on Google Chrome Dev Tools metrics, discover your server ping, optimize images (and automate it), kill unnecessary libraries etc. Bad For Newbies Many people say it’s a bad decision to start learning web development craft with jQuery. They say beginners would not understand the stuff enough. deep My position is opposite. I’m sure it’s a-w-e-s-o-m-e to reach cool results (well, results!) fast at the beginning. It highly motivates you and gives a faith to complete learning. any It’s obvious for me that after becoming a bit stronger one will definitely dig deeper and learn everything he needs about web api and all the other cool JavaScript things. Reinventing the Wheel Yes it’s possible to create all the things from scratch. don’t forget to: Simply Make it perfect like John Resig done. Keep an eye on updating your stuff. Think about dependency injection and modular loading. Crossbrowser compatibility https://twitter.com/jeresig/status/590199945174634497 Make it chainable. Teach it every new team member. Many of jQuery’s functionality has already been redone in offering sweet vanilla snippets. Like this: http://youmightnotneedjquery.com jQuery $(el).fadeIn(); Vanilla JavaScript (IE10+) el.classList.add('show');el.classList.remove('hide');

.show {  transition: opacity 400ms;}.hide {  opacity: 0;} But if you give it a tiny think you will notice than jQuery’s .fadeIn() is far more complicated and flexible: It not simply increases opacity to 1, it an element with a proper display: {value}; displays It offers callbacking. The vanilla variant should have used something like . this It offers chaining. Please don’t be blind and choose carefully. Chaining One do something like this: can’t Vanilla JavaScript let body = document.querySelector(‘body’); body.classList.add(‘state-success’).classList.remove(‘state-error’); // TypeError: body.classList.add(...) is undefined Personally I adore jQuery for providing an ability to chain my code out of the box: jQuery let form = $('#js-form');             //get the form form.removeClass('state-error')       //remove red color.addClass('state-success')        //add green color.find('.js-success-message-text') //get the success text.fadeIn()                     //show the success text. //get the form again.find('.js-error-message-text')   //get the error text.fadeOut()                    //hide the error text end() Plugins During the last 10 years jQuery community has grown really big. And so does the jQuery plugins list: You will find a collection of nice ready-to-use plugins there. https://plugins.jquery.com huge Conclusion jQuery did an incredible epic work in the past. But things do change. Today JavaScript rises tremendously fast and Babel makes all those features accessible right now, most browsers tend to update itself immediately, wasm is coming, AI invades the world… Nevertheless, ol’ good jQuery is still usable and really helpful in some cases. It’s early to bury the library. too Think. * It will take about 47ms to download jQuery 2.1.1 (28.87KB gzipped) on average mobile networks (5Mbps) and 140 ms to initiate jQuery 2.1.1 on Chrome 50 LG Nexus 5.

You Might Need jQuery

How we treat 'dirty' jobs reveals something about us—both IRL and online. This past summer, I got sidetracked by a hidden pattern. At every event and co-living space I went to, the same weakest link kept surfacing: tasks people ignore or simply don’t want to do (ie cleaning) ˙◠˙ Even the smallest cleaning task, when overlooked, impacted everyone’s experience. It’s not just about physical spaces, this avoidance shows up in the digital world too. Avoidance in Decentralized Systems If you consider yourself a systems thinker, chances are you’ve mastered ✩₊_˚._⋆_mental gymnastics_✩₊_˚._⋆. Acrobatic moves to bend the mind and avoid the uncomfortable. This complex reasoning often leads to avoiding essential tasks. DAOs (decentralized autonomous organizations) promise shared governance and community-driven decision-making. Think of them as socio-technical experiments, revealing how we engage with governance. In practice, however, people neglect their roles in maintaining the system. Voting or contributing to governance, like cleaning, is often overlooked. When this happens, the responsibility falls on a few, undermining the promise of DAOs. While many DAOs still struggle with this, there are people experimenting with solutions as decentralized governance evolves. But hey, what’s more exciting than voting? ✿ Shitcoins and Shitposting ✿ It’s funny how silly, low-value, human-made content floods digital spaces and physically seeps into brains. Meanwhile, machine-driven blockchain mining quietly powers the foundation that keeps everything running. Blockchain mining is labor-intensive, requiring machines to perform millions of calculations to validate transactions. Miners are rewarded for tasks that few would willingly do due to high energy consumption and hardware demands. By outsourcing this ‘dirty work’ to machines and distributing it across a decentralized network, the system remains resilient. As the industry evolves, solutions like Ethereum’s shift from PoW to PoS show how digital systems can handle their ‘dirty work’ to ensure sustainability. Maybe there’s a lesson in that for us? Creative Glory Versus Essential Labor This viral quote implies that creative work is superior to cleaning, and most people agree without hesitation. It’s an ominous reflection on society. Are essential laborious tasks truly beneath human dignity? I recently volunteered to oversee the cleaning of the busiest toilets at a 500-person event. What was supposed to be a simple oversight role turned into me doing the actual cleaning—because no one showed up. Watching people avoid helping was comedic (and it was heartwarming when a few legends pitched in ⋆𐙚₊˚⊹♡). I channeled Mike Rowe's energy from Dirty Jobs. https://www.youtube.com/watch?v=w0Ogf6zWuMM&embedable=true It revealed a deeper truth: we don’t value the work that keeps things running. In many countries, it’s completely normal for families to have a domestic worker. The idea of cleaning is confusingly unholy in these places. Cleanliness has long been seen as sacred across cultures and philosophies. Zoroastrianism, a religion over 3,000 years old, views physical cleanliness as a reflection of cosmic order, tying mundane tasks to a higher spiritual purpose. Fast forward to 20th-century architect Le Corbusier, who believed that well-organized, clean spaces were essential for human creativity and productivity. Despite the vast time gap, these perspectives remind us that cleanliness supports the larger systems we rely on. [~ Note: keep an eye out in shared spaces like co-working, festivals, and clubs, sometimes there are creative and fun solutions to toilets and cleaning ~] ღ꧁ღ Sacred Tasks in Shared Systems ⊱ꕥ As our lives become more networked, the energy we share in digital spaces carries the same weight as in the physical. Just as physical hygiene prevents decay, digital hygiene—through clear communication, ethical data use, and mindful online habits—prevents the breakdown of trust in shared systems. Network spirituality connects the visible and invisible structures we rely on. Much like viewing cleanliness as cosmic order or valuing organized spaces for creativity and productivity. The smallest tasks keep our systems healthy. Cleaning and Decomposing Are Natural Cycles in Every Living System Seek to uncover these overlooked tasks in your blindspots. Turn them into something intentional and fun, much like nature’s quiet alchemy—foundational for building healthier systems. TL;DR Cleanliness, physical or digital, is key to healthy systems and communities.
Blockchain mining demonstrates how rewarding essential work sustains networks.
We can look to examples that make these tasks fun, even sacred. Much love, Dayvan ღ꧁ღ╭⊱ꕥ PS. If you want to support my work, I’m raising funds for a new project on Gitcoin! Alternatively, you can donate to dayvan.eth (I’ll make sure to send many blessings your way) ₊˚⊹♡ And get in touch here if you want to collaborate. Originally posted on Substack; subscribe here. How we treat 'dirty' jobs reveals something about us—both IRL and online. This past summer, I got sidetracked by a hidden pattern. At every event and co-living space I went to, the same weakest link kept surfacing: tasks people ignore or simply don’t want to do (ie cleaning) ˙◠˙ tasks people ignore or simply don’t want to do (ie cleaning) ˙◠˙ Even the smallest cleaning task, when overlooked, impacted everyone’s experience. It’s not just about physical spaces, this avoidance shows up in the digital world too. Avoidance in Decentralized Systems If you consider yourself a systems thinker, chances are you’ve mastered ✩₊_˚._⋆_mental gymnastics_✩₊_˚._⋆. Acrobatic moves to bend the mind and avoid the uncomfortable. This complex reasoning often leads to avoiding essential tasks. DAOs (decentralized autonomous organizations) promise shared governance and community-driven decision-making. Think of them as socio-technical experiments, revealing how we engage with governance. In practice, however, people neglect their roles in maintaining the system. Voting or contributing to governance, like cleaning, is often overlooked. When this happens, the responsibility falls on a few, undermining the promise of DAOs. While many DAOs still struggle with this, there are people experimenting with solutions as decentralized governance evolves. But hey, what’s more exciting than voting? ✿ Shitcoins and Shitposting ✿ ✿ Shitcoins and Shitposting ✿ It’s funny how silly, low-value, human-made content floods digital spaces and physically seeps into brains. Meanwhile, machine-driven blockchain mining quietly powers the foundation that keeps everything running. Blockchain mining is labor-intensive, requiring machines to perform millions of calculations to validate transactions. Miners are rewarded for tasks that few would willingly do due to high energy consumption and hardware demands. By outsourcing this ‘dirty work’ to machines and distributing it across a decentralized network, the system remains resilient. As the industry evolves, solutions like Ethereum’s shift from PoW to PoS show how digital systems can handle their ‘dirty work’ to ensure sustainability. Maybe there’s a lesson in that for us? Creative Glory Versus Essential Labor Creative Glory Versus Essential Labor This viral quote implies that creative work is superior to cleaning, and most people agree without hesitation. It’s an ominous reflection on society. Are essential laborious tasks truly beneath human dignity? I recently volunteered to oversee the cleaning of the busiest toilets at a 500-person event. What was supposed to be a simple oversight role turned into me doing the actual cleaning—because no one showed up. Watching people avoid helping was comedic (and it was heartwarming when a few legends pitched in ⋆𐙚₊˚⊹♡). I channeled Mike Rowe's energy from Dirty Jobs. https://www.youtube.com/watch?v=w0Ogf6zWuMM&embedable=true https://www.youtube.com/watch?v=w0Ogf6zWuMM&embedable=true It revealed a deeper truth: we don’t value the work that keeps things running . In many countries, it’s completely normal for families to have a domestic worker. The idea of cleaning is confusingly unholy in these places. we don’t value the work that keeps things running Cleanliness has long been seen as sacred across cultures and philosophies. Zoroastrianism, a religion over 3,000 years old, views physical cleanliness as a reflection of cosmic order, tying mundane tasks to a higher spiritual purpose. Fast forward to 20th-century architect Le Corbusier, who believed that well-organized, clean spaces were essential for human creativity and productivity. Despite the vast time gap, these perspectives remind us that cleanliness supports the larger systems we rely on. [~ Note: keep an eye out in shared spaces like co-working, festivals, and clubs, sometimes there are creative and fun solutions to toilets and cleaning ~] ღ꧁ღ Sacred Tasks in Shared Systems ⊱ꕥ ღ꧁ღ Sacred Tasks in Shared Systems ⊱ꕥ As our lives become more networked, the energy we share in digital spaces carries the same weight as in the physical. Just as physical hygiene prevents decay, digital hygiene—through clear communication, ethical data use, and mindful online habits—prevents the breakdown of trust in shared systems. Network spirituality connects the visible and invisible structures we rely on. Much like viewing cleanliness as cosmic order or valuing organized spaces for creativity and productivity. The smallest tasks keep our systems healthy. Network spirituality Network spirituality Cleaning and Decomposing Are Natural Cycles in Every Living System Cleaning and Decomposing Are Natural Cycles in Every Living System Seek to uncover these overlooked tasks in your blindspots. Turn them into something intentional and fun, much like nature’s quiet alchemy—foundational for building healthier systems. TL;DR TL;DR Cleanliness, physical or digital, is key to healthy systems and communities. Blockchain mining demonstrates how rewarding essential work sustains networks. We can look to examples that make these tasks fun, even sacred. Cleanliness, physical or digital, is key to healthy systems and communities. Blockchain mining demonstrates how rewarding essential work sustains networks. We can look to examples that make these tasks fun, even sacred. Much love, Dayvan ღ꧁ღ╭⊱ꕥ PS. If you want to support my work, I’m raising funds for a new project on Gitcoin ! Alternatively, you can donate to dayvan.eth (I’ll make sure to send many blessings your way) ₊˚⊹♡ And get in touch here if you want to collaborate. I’m raising funds for a new project on Gitcoin I’m raising funds for a new project on Gitcoin dayvan.eth get in touch here get in touch here Originally posted on Substac k; subscribe here . Originally posted on Substac subscribe here

Stories, News & Mentions about CHANNABLE

Channable’s Stories on HackerNoon

Channable's News & Mentions