Rust error handling is nice but obligatory. Which makes it sometimes plenty of code.
Functions return values of type Result that is "enumeration". In Rust enumeration means complex value that has alternatives and that alternative is shown with a tag.
Result is defined as Ok or Err. The definition is generic, and both alternatives have
| import { createCipheriv, createDecipheriv, randomBytes } from "crypto"; | |
| const ENCRYPTION_KEY: string = process.env.ENCRYPTION_KEY || ""; // Must be 256 bits (32 characters) | |
| const IV_LENGTH: number = 16; // For AES, this is always 16 | |
| /** | |
| * Will generate valid encryption keys for use | |
| * Not used in the code below, but generate one and store it in ENV for your own purposes | |
| */ | |
| export function keyGen() { |
| package com.github.ruudud.exectest; | |
| import com.google.common.base.Stopwatch; | |
| import com.google.common.collect.ImmutableList; | |
| import com.google.common.util.concurrent.ThreadFactoryBuilder; | |
| import java.util.List; | |
| import java.util.concurrent.*; | |
| import java.util.stream.Collectors; |
ES2015, The newest iteration of JavaScript, introduces a ton of new features, types, and syntactic sugar. Those have all been explored pretty thoroughly, but the one that has the greatest implications for JavaScript are iterators; not the construct in itself but the use of the Iterator protocol.
Iterators are made possible by two new features: symbols and generators. Iterators are not necessarily a feature on their own, but rather a set of conventions around symbols and generators:
Given that JavaScript does not have interfaces, Iterable is more of a convention:
Source: A value is considered iterable if it has a method whose key is the symbol
Symbol.iteratorthat returns a so-called iterator. The iterator is an object that returns values via its methodnext(). We say: it enumerates items, one per method call.
| // SPDX-License-Identifier: MPL-2.0 | |
| // AES Encryption/Decryption with AES-256-GCM using random Initialization Vector + Salt | |
| // ---------------------------------------------------------------------------------------- | |
| // the encrypted datablock is base64 encoded for easy data exchange. | |
| // if you have the option to store data binary save consider to remove the encoding to reduce storage size | |
| // ---------------------------------------------------------------------------------------- | |
| // format of encrypted data - used by this example. not an official format | |
| // | |
| // +--------------------+-----------------------+----------------+----------------+ |
| /* | |
| * Copyright 2017 Ben D'Angelo | |
| * | |
| * MIT License | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a copy of this | |
| * software and associated documentation files (the "Software"), to deal in the Software | |
| * without restriction, including without limitation the rights to use, copy, modify, merge, | |
| * publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons | |
| * to whom the Software is furnished to do so, subject to the following conditions: |
| Latency Comparison Numbers (~2012) | |
| ---------------------------------- | |
| L1 cache reference 0.5 ns | |
| Branch mispredict 5 ns | |
| L2 cache reference 7 ns 14x L1 cache | |
| Mutex lock/unlock 25 ns | |
| Main memory reference 100 ns 20x L2 cache, 200x L1 cache | |
| Compress 1K bytes with Zippy 3,000 ns 3 us | |
| Send 1K bytes over 1 Gbps network 10,000 ns 10 us | |
| Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD |