BRIX

brix

Mastering the Art of Software Development: From Developer to Craftsperson

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

Refactoring CryptoJS in Modern ECMAScript

Bernard Lietaer, A Financial Justice Warrior Who Fought for Freedom of Currency

How distributed technology can help regional currencies

Money is a critical element of our modern societies: a slight change in its mechanisms can have a much broader impact than simply affecting the economy. Therefore, a better comprehension of these mechanisms will give you a better grasp on various topics ranging from Political Economy to cryptocurrencies. Lire cet article en français sur EcoCrypto.fr Money is a complex subject, even more lately if we consider all the that were progressively built on top of it: monetary creation, central banks, inflation… With this piece, we’ll go back to the basics and eventually down to cryptocurrencies: What defines a currency? Why do we need them? What types of currencies do exist? convoluted systems and protocols Buckle up for a quite an adventure in which we discard old but still prevalent tales and propose necessary new ones to make complex mechanisms crystal clear. The Tale of the Origins of Money When you hear about currencies, you often get a tale that is easy to understand and compelling; yet it’s just a tale. It goes like this: At the beginning, we were barterers, the my chicken for your corn kind of deal. Then, since bartering wasn’t efficient, we needed a more standardised mean of exchange: a good that could pass as a store of value. Precious metals were the perfect candidates — they became coins, a form of money. Yet, later on, those coins evolved once again and became paper money — still a currency, but the origin of their value shifted: while a coin gets its value from its very material (the precious metal it’s made of), the paper money needs an institution to emit it and guarantee its value one way or another. Finally, in the digital era, money evolved one more time. It’s now all “digital” — just bits, 0 and 1 located somewhere in a server and transiting almost instantly in the fiber . network We must take our time to methodically deconstruct the tale in order to dismiss it, we’ll learn quite a few things along the way: Money is not a store of value Money is not a store of value, it’s a claim upon value. [1] Let’s burn some cash to understand money better Let’s study together the example that made the distinction between the two very clear to me: let’s say I burn a $20 bill — will any value be destroyed? Thanks to the Joker for helping with the experiment Well… Simply no! What has been destroyed is my ability to claim the aforementioned value: I can’t exchange the ashes of my bill for a beer. Make it rain! Understanding the difference between a store of value and a claim upon value allows us to also understand . Indeed, money is not wealth by itself: as long as the money is not claimed (spent for goods or services), it has no contribution whatsoever to the wealth of the given country. the obsession with circulating currency Let’s go back to our previous cash burning experiment to dig deeper: when I burnt my $20 bill, it had no impact on the GDP (Gross Domestic Product) of the USA. Yet, if I start to burn millions of dollars, we might start to see affecting the GDP: since there will be less money circulating, there might be less people using it to claim value (a beer, clothes…) and therefore an impact on the real economy of the country. secondary consequences Those secondary consequences will — if burning the bills prevented me from claiming the value they carried. Hence, if I’m a multi billionaire (so let’s assume: incapable of spending all of my money), I can burn millions of dollar without having any impact on the economy: those millions would have never flowed back into the economy anyway. only happen if the cash I burnt was meant to be spent Putting a stop to the flow of money which would have changed hands without that stop is like preventing others to work to provide value; this value would have been exchanged for currency if the money was circulating freely. Counterfeit money, real value? To get over with the myth of money as a store of value, let’s consider a third and last scenario. Let’s say I print a very — everybody take it for the real one. Now I give out those bills to normal American citizens, and for the sake of the simplicity of this example, the FED doesn’t notice. well done stash of counterfeit money In that scenario, the happy citizens who got free real-like yet counterfeit bills will start spending them for goods and services — they will claim what is rightfully theirs because of their ownership of the bills, hence increasing the GDP of the country. Yet, all of this is a scam, no value was actually created: I only printed and handed out fake bills that people think legit. Money barely is the key to the gold chest. When money itself, its physical medium, still had value (such as gold or silver coins), the content of the chest was still tied to the amount written on the key. Now, we are in a system where keys are changing endlessly changing hands without ever returning to open the chest. . Our trust in our currencies is so high that the amount written on the key is sufficient and even authoritative The myth of bartering and its inefficiency Let’s go back to the first tale about the origin of money presented in the beginning of this article: was bartering really as prevalent as the story make it seems? [2] We need to place some context to answer this question. We’re talking about a world where money doesn’t exist yet; hell, the very notion of “property” is even clear yet. . Of course there were exchanges, but the “exchange protocol” was very different that what we picture behind the idea of bartering Premodern agricultural societies were largely self-sufficient: exchanges between the member of a given community followed informal systems based on relationships: the “economy” was powered by gifting and reciprocity. [3] In practical terms, rather than the kind of deal, it was more like my goat for your corn I will help you build this house because I know how to do it. Later on, you'll help me furnish this other house since you're a skilled woodworker. If you don't, it can put an end to 1/our relationship, 2/your very place in the community Note: Considering the system depicted above was informal, the “if you don’t…” part didn’t need to be stated, it was understood. In the premodern agricultural societies depicted above, barter also existed but wasn’t the main mean of exchange: it was useful to be able to exchange with people who didn’t share the kind of relationship we depicted — for exchanges between communities for instance. The distortion of the Historian’s lens There could be another reason to explain why the tale of the evolution from bartering to currency is still prevalent. . Coins stand the test of time. On the opposite, informal gift/counter-gift dynamics barely leave any traces behind them. To reconstruct the past, historians use remains found in modern times [4] Helixism was born when Reddit started to play Pokemon, together ( ) — Twitch Plays Pokemon The Origin of Ancient Helixism Moreover, the example frequently chosen to illustrate the bartering system are doubtful. We’re talking about deals, but is it realistic in the context of a premodern agricultural society? Since they were mostly auto sufficient, bartering was for goods that weren't required for the community's survival, since these were already produced within the community. goat vs corn DOWNPLAYING THE ROLE OF BANKS With the tale of the origins of money, banks look like mere intermediary. They provide more or less practical systems allowing the money to flow: it used to be ledgers, and it’s still is but now we have a clunky web interface to write/edit stuff in them. Yet, this skip . For the sake of the easy-of-comprehension of this article, I won’t dive into the depths of it in here, a quick presentation of it will have to suffice. This mechanism is called the fractional-reserve banking. the crucial role played by banks in our current monetary systems: monetary creation [5] Here is a short and (too) quick explanation — a central bank emit a monetary base allowing commercial banks to issue currency by themselves through loans. When Bob comes to Bank of America for a $10,000 loan, BA is not pulling money from its reserve to credit Bob’s account. No, what happens instead is this: the amount written in Bank of America’s ledger next to Bob’s name is increased by 10,000, and that’s pretty much it. The confidence is the banking system is preserved through mandatory reserve, corresponding to a fraction (~10%) of the loaned amount. Which leads us to our next point. [6] The myth of bits: a digital ledger is still a good old ledger Now that we are clear on monetary creation — made by bank and nothing more that an input on a ledger — let’s tackle the last myth surrounding money, the one that states that money became 0 and 1, bits stored somewhere on a server. : the good old bank ledger is still authoritative. Its authority comes from the fact that it doesn’t exist in a vacuum: it draws its authority from the whole . The way we interact with the ledger (analog or digital) doesn’t reshuffle the decks. In real life, the nature of money hasn’t changed political, societal and judiciary system that surround it With credit cards, ATMs, online banking and all the others “innovations”, it might seem like our monetary system evolved. In reality, we’re still very close to our first monetary systems and our modern currencies follow pretty much the same rules as the old ones. Innovations and changes happened mostly at the interface level: how we interact with the ledger. Most of the changes happened at the monetary creation level, it used to be much simpler and a state matter but the rest didn’t budge much. Our modern currencies share more with the Gold Franc_[7]_ (pardon my Frenchness) that we imagine. Disruption has yet to happen on currencies, what we had so far is barely a parade of facelifts. A sneak peak into the real monetary innovations We needed to lay out the groundwork in order to finally reach this point, the most interesting part: how does real monetary innovation looks like? The answer is not as simple as “Bitcoin”, it can take many forms: Change the ledgers’ governance mechanism Quick reminder: the current trust placed in our ledgers is due to: The reputation of the institutions who handle the monetary systems, be it central banks, private banks or other institutions. The political, legal and societal framework built around banks. The general public ignorance of the mechanisms governing currencies. You might think it’s not much to hold the whole monetary system afloat; don’t worry, you’re not the only one. Critics have been numerous and early; in the 80s the cypherpunk movement were already looking into alternative currencies to break free from the fiat ones. [8] Fiat currencies are intrinsically useless objects that serves a medium of exchanges. They only have value because a government maintain and guarantee it. Cypherpunk experimented with digital currencies and eventually lead us to the Bitcoin introduced by Satoshi. With Bitcoin, (“trustless”). Indeed, in short the idea is as follows: instead of trusting the banks and other institutions to maintain the ledger, why not make that ledger public (=blockchain) and rely on our peers instead? This system also requires the use of cryptography and mechanisms to reach a consensus on the public ledger (so there is only one), but that will be covered in another article. the trust in the monetary institutions is no longer required Alter the innate propriety of money What about a currency that depreciates if not used? It would help to keep it circulating. The idea is not new, it was theorised in 1916 already by Silvio Gesell and is called demurrage. [9] The idea of a currency depreciating over time might seem scary at first as it contradict our intuitive comprehension of money (“ ). We already have already established that this intuitive comprehension of money was far from the truth of the practical world. This kind of money has an evident interest for recessionary phases, as it promotes spending the money quickly and “punishes” hoarding. how can it be a store of value if its value shrink over time?” Limit what kind of items money can claim be claimed upon Without even altering the innate proprieties of money, we can change what it can be exchanged for. Local currencies are a good example of this. If they are designed carefully, this kind of currencies can help revitalize the local economy and independent businesses. Local currencies are plentiful; the Brixton Pound (B£) is one of the most well known. The team behinds it does a pretty good job to explain their thought process. [10] Conclusion I hope this article will provide you with a better understanding of money but most importantly that it sparked an interest and it makes you want to learn more about it! The actual monetary innovation has yet to happen. The good news is — pretty much anybody can do it and it’s an excellent news! now that we have cryptocurrencies, it’s much easier to create new ones It means that all the mechanisms we talked about and many more will be implemented and tested at scale. They already are: there are more than 1500 traded cryptocurrencies and easily another 10 thousands local, confidential or developed for learning purposes. You would like to mint your own coins too? Here’s a guide to get started. Soon in your wallets: the Brice paper e-Dollar coin pegged on sand Beyond what can offer, maybe here lies the most valuable contribution of Satoshi. — it’s the business of regular people too: you, me, us, and even your computer illiterate grandma should have a say. blockchain By creating Bitcoin, he paved the way and reminded the whole world that minting money isn’t reserved to states Like all changes, it sounds scary but if you think twice about it, it makes so much sense: who better than the future users themselves could design the currency the most fitted to their needs? Let me know if you liked this article and you can keep pressing 👏up to 50 claps. check out my wiki for more content like this. Don’t forget to clap it to help it spread: This article is the translation of an original (French) story. EcoCrypto.fr SOURCES: TO DIG DEEPER I would like to give a special acknowledgement to Brett Scott who tremendously helped me to understand what money is and the different mechanisms tied to it. Go check his blog, it’s worth the read! — Brett Scott for The Hectic’s Guide to Global Finance, on March the 10th 2016 Money is not a store of value. It is a claim upon value — Reynold F. Nesiba for New Economic Perspective, on September the 23rd 2013 Was money created to overcome barte r? — Gerald M.Slider for Social History on May the 30th 2008 The ties that bind: Culture and agriculture, property and propriety in the Newfoundland village fishery — Brett Scott for Medium — How We Get to Next?, on March the 30th 2016 The Future of Money Depends on Busting Fairy Tales About Its Past , Wikipedia Fractional-reserve Banking — Richard A. Werner for the International Review of Financial Analysis, in December 2014 Can banks individually create money out of nothing? — The theories and the empirical evidence , Wikipedia. Gold Franc , Wikipedia Cypherpunk — Wikipedia Demurrage (Currency) — Official website of the Britxton Pound What is the Brixton Pound?

Stories, News & Mentions about BRIX

Brix’s Stories on HackerNoon