Our AI project management software will assemble the most cost-effective and capable freelancers for your project, making it easier for anyone to hire a team of freelancers

BRIX

Judgement Day.

THE BOY GROWS UP

How to Live on Twenty-Four Hours a Day, August 2000 by Arnold Bennett is part of . You can jump to any chapter in this book . HackerNoon’s Book Blog Post series here The Desire to Exceed One’s Programme By Arnold Bennett "But," someone may remark, with the English disregard of everything except the point, "what is he driving at with his twenty-four hours a day? I have no difficulty in living on twenty-four hours a day. I do all that I want to do, and still find time to go in for newspaper competitions. Surely it is a simple affair, knowing that one has only twenty-four hours a day, to content one's self with twenty-four hours a day!" To you, my dear sir, I present my excuses and apologies. You are precisely the man that I have been wishing to meet for about forty years. Will you kindly send me your name and address, and state your charge for telling me how you do it? Instead of me talking to you, you ought to be talking to me. Please come forward. That you exist, I am convinced, and that I have not yet encountered you is my loss. Meanwhile, until you appear, I will continue to chat with my companions in distress—that innumerable band of souls who are haunted, more or less painfully, by the feeling that the years slip by, and slip by, and slip by, and that they have not yet been able to get their lives into proper working order. If we analyse that feeling, we shall perceive it to be, primarily, one of uneasiness, of expectation, of looking forward, of aspiration. It is a source of constant discomfort, for it behaves like a skeleton at the feast of all our enjoyments. We go to the theatre and laugh; but between the acts it raises a skinny finger at us. We rush violently for the last train, and while we are cooling a long age on the platform waiting for the last train, it promenades its bones up and down by our side and inquires: "O man, what hast thou done with thy youth? What art thou doing with thine age?" You may urge that this feeling of continuous looking forward, of aspiration, is part of life itself, and inseparable from life itself. True! But there are degrees. A man may desire to go to Mecca. His conscience tells him that he ought to go to Mecca. He fares forth, either by the aid of Cook's, or unassisted; he may probably never reach Mecca; he may drown before he gets to Port Said; he may perish ingloriously on the coast of the Red Sea; his desire may remain eternally frustrate. Unfulfilled aspiration may always trouble him. But he will not be tormented in the same way as the man who, desiring to reach Mecca, and harried by the desire to reach Mecca, never leaves Brixton. It is something to have left Brixton. Most of us have not left Brixton. We have not even taken a cab to Ludgate Circus and inquired from Cook's the price of a conducted tour. And our excuse to ourselves is that there are only twenty-four hours in the day. If we further analyse our vague, uneasy aspiration, we shall, I think, see that it springs from a fixed idea that we ought to do something in addition to those things which we are loyally and morally obliged to do. We are obliged, by various codes written and unwritten, to maintain ourselves and our families (if any) in health and comfort, to pay our debts, to save, to increase our prosperity by increasing our efficiency. A task sufficiently difficult! A task which very few of us achieve! A task often beyond our skill! Yet, if we succeed in it, as we sometimes do, we are not satisfied; the skeleton is still with us. And even when we realise that the task is beyond our skill, that our powers cannot cope with it, we feel that we should be less discontented if we gave to our powers, already overtaxed, something still further to do. And such is, indeed, the fact. The wish to accomplish something outside their formal programme is common to all men who in the course of evolution have risen past a certain level. Until an effort is made to satisfy that wish, the sense of uneasy waiting for something to start which has not started will remain to disturb the peace of the soul. That wish has been called by many names. It is one form of the universal desire for knowledge. And it is so strong that men whose whole lives have been given to the systematic acquirement of knowledge have been driven by it to overstep the limits of their programme in search of still more knowledge. Even Herbert Spencer, in my opinion the greatest mind that ever lived, was often forced by it into agreeable little backwaters of inquiry. I imagine that in the majority of people who are conscious of the wish to live—that is to say, people who have intellectual curiosity—the aspiration to exceed formal programmes takes a literary shape. They would like to embark on a course of reading. Decidedly the British people are becoming more and more literary. But I would point out that literature by no means comprises the whole field of knowledge, and that the disturbing thirst to improve one's self—to increase one's knowledge—may well be slaked quite apart from literature. With the various ways of slaking I shall deal later. Here I merely point out to those who have no natural sympathy with literature that literature is not the only well. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. . This book is part of the public domain. Arnold Bennett (2008). HOW TO LIVE ON TWENTY-FOUR HOURS A DAY. Urbana, Illinois: Project Gutenberg. Retrieved May 2022, from https://www.gutenberg.org/files/2274/2274-h/2274-h.htm This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever.  You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

The Desire to Exceed One’s Programme

The Adventures of Sherlock Holmes: Chapter VII- The Adventure of the Blue Carbuncle

Since 2018, I have been working for a plant-based alternative startup [더플랜잇, The Plant Eat] as a data scientist. Here is what I learned while working on the food data team. Reminder: This is my own opinion, it doesn’t represent the company’s ideas and views regarding this topic. Here are the points that I learned during my journey: 1. Food can be modular but very dependent on mixture of compounds A single ingredient may influence your product mix regardless of the ratio of your food product. (i.e. single drop of sulfur-based ingredient may create an animal-based food like taste/aroma) 2. Food preferences may be influenced by compounds likeness or distance between the two foods. Let me quote an article titled that explains this point “Flavor network and the principles of food pairing” North American and Western European cuisines exhibit a statistically significant tendency towards recipes whose ingredients share flavor compounds. By contrast, East Asian and Southern European cuisines avoid recipes whose ingredients share flavor compounds 3. Food Data needs a lot cleaning, I mean a lot of cleaning I can’t show the specifics but the food industry does have diverse weighing systems, processes in getting numerical data, and other diverse data from the lab that is traditionally saved in numerous types of file format that depends on what kind of lab machine you are using. (i.e. BRIX, to measure the amt. of sucrose, a type of sugar) 4. Choose what kind of food characteristics you are going to concentrate on. Is it function?, taste?, nutritional?, or just the price? Although not impossible, it would be wise to concentrate on one factor at a time since each factor have a different indicator and unique condition that is required by the Food Administration or your target consumer. 5. Production is king. If you can’t scale it up then it is not feasible. Yes, you got all your product ready but if the factory doesn’t have the machinery or the skill set to create a stable product… it will cost you a lot of money and time to make it work. Always research on the factories that you are going to work with for production. 6. Patch updates isn’t isolated in the software space but very relevant in the food science space as well. R & D based Food Tech companies need the software-like “Patch Update” Thinking. Rapid updates and consumer-centric products will be easier through this method. If you have the Software “Update Patch” in Tech Space, Food Tech has a “Formulation Patch”. Formulation Patch meaning that food products would have version updates very quarter with small but significant changes. is taking this approach as well creating internal software to keep up with the fast feedback we are getting in the market today. theplanteat These are the general insights I learned so far while working for a food tech startup. Some of the insight is not included due to the sensitivity of the data. Thanks for Reading! Previously published at https://medium.com/planteat-foodtechlab/working-for-a-food-tech-start-up-year-3-84ec8cf1a366

Working at a FoodTech Startup: A Data Scientist's Insights

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

BRIX

joinbrix.com

-- employees

Since n.d.

COMPANY RANKING

BRIX

EVERGREEN INDEX #2025

Representing this company? Click here to claim and customize this page!

BRIX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

BRIX

joinbrix.com

-- employees

Since n.d.

COMPANY RANKING

BRIX

EVERGREEN INDEX #2025

RELATED COMPANIESRANK

STORIES ABOUT BRIX

Representing this company? Click here to claim and customize this page!

BRIX WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!