Northern Californians are paying more per unit of electricity than almost anywhere in the country. Here’s what’s going on.

Why is my PG&E bill so high? Here are answers to questions about the rate hike

On Thursday, Feb. 22, PG&amp;E Corporation announced its Q4 and Full-Year 2023 earnings, which are detailed in this news release

Top 10 Things to Know About PG&E’s Recent Earnings - PGE Currents

<strong>PGE</strong>’s exploration of a plan to clear trees and other foliage in the park came to light last week after WW reported on a phone survey asking respondents how they would feel if Oregon’s largest utility cut trees on 3 acres of land above Linnton on Highway 30.

Forest Park Conservancy “Deeply Concerned” About PGE’s Power Line Plans in Forest Preserve

Consumer groups, politicians, labor organizations and advocacy organizations have teamed up to combat fast-rising increases in PG&E monthly bills.

Groups team up to combat fast-rising PG&E electric and gas bills

Winter is just around the corner and Pacific Gas and Electric Company (PG&E) is offering to help customers free of charge to prepare their gas appliances for safe use during

PG&E offering free gas appliance checks, pilot relights

Pacific Gas and Electric Co. is poised to hit customers with a major hike to monthly bills in January, an increase that comes amid an unprecedented rise in utility rates for Californians over the last decade.

PG&E utility bills are about to soar in California. Here are the details

Pacific Gas & Electric Co. residential electricity ... He attributed the high costs to PG&E’s spending on the aforementioned factors. Campbell suggested that selling more electricity could potentially alleviate the pressure on rates, provided that ...

PG&E Hits Residents with Electricity Prices Over Double the National Average

— The first option would increase bills for the average residential customer who receives combined electric and gas services from PG&E by $31.13 a month. Electric bills would jump by $22.37 a month while natural gas bills would increase by $8.76 a month.

PG&E customers face higher monthly bills as state panel preps ruling

A recent parolee convicted of murder is accused of a stabbing spree in Northern California that left one man dead and two others — including a Pacific Gas and Electric employee ... horrible crime,” Alfred said. The PG&E employee was attacked ...

Murder parolee accused in California stabbing spree that killed 1, hurt 2 including PG&E worker

Pacific Gas and Electric Company (PG&E) has reached a historic milestone in its commitment to decarbonize its natural gas system and expand on

PG&E Takes Historic Steps Toward Decarbonization as Company Announces New Production Pilot and Procurement of Renewable Natural Gas

PG&E

Introduction As LLM technologies gain more mainstream adoption and the ecosystem begins to mature, organizations are beginning to recognize the limits and costs of using LLM technologies. Many enterprises, originally enthusiastic about the application of , have abandoned centralized initiatives, pursuing instead a strategy of encouraging decentralized efforts to incorporate services like ChatGPT and Claude into their workflows. LLM technologies There are several reasons for this phenomenon. Lack of LLM expertise, MLOps requirements, and reliance on specialized GPU infrastructure are all barriers to implementing large-scale AI initiatives. Of these, however, the thorniest issue is the reliance on GPUs. In this article, we will discuss the specific difficulties posed by GPU reliance, explore a potential solution, and look at an exciting example from one of the trailblazing companies working in this area. GPU Availability as Limitations to LLMs Most publicly available and highly performant models, such as GPT-4, Llama 2, and Claude, all rely on highly specialized GPU infrastructure. GPT-4, one of the largest models commercially available, famously runs on a cluster of 8 A100 GPUs. Llama 2’s 70B model, which is much smaller, still requires at least an A40 GPU to run at a reasonable speed. This level of GPU requirement practically forecloses the possibility of running these models locally - a A100 GPU, assuming you can find a seller, costs close to $25,000. Once you obtain the GPUs, you need specialized skills to set up and maintain the servers. Very few organizations would be willing to incur such an outlay to experiment with LLM technologies. To solve this problem, several startups and cloud providers have developed extensive PaaS offerings. Some services like Replicate, which I have used in past articles and projects, allow users to rent GPU servers and pay for compute time used. Other providers, like OpenAI and Anthropic, offer their models as a per-token API, further abstracting away infrastructural complexities. However, these services require data to be sent to an external network, which makes using these services a non-starter for privacy-conscious organizations. Additionally, many of these services suffer from shortages during demand spikes as GPU usage overtakes availability, making them unreliable options for production-critical workloads. Additionally, GPU time, no matter how they are charged for, is expensive for large compute tasks - the companies that own and operate these GPUs need a return on their investment, after all. While these costs are nearly negligible for experimental use cases, commercial use cases often require embedding large contexts, fine-tuning, or multi-shot examples. These costs represent a significant barrier to adoption, especially for organizations with large datasets or those that lack the financial resources of large U.S. firms. In a previous article, we explored parameter compression as one strategy to reduce dependence on GPUs. In today’s article, we will explore another exciting technique called quantization. Before we dive into the exploration, however, we might want to learn a little bit about quantization first. Quantization (Optional Reading) In this section, we will briefly go over the basics of quantization. However, if you’re simply looking for a way to run powerful LLMs locally on your computer, you can feel free to skip this section for now and come back later. LLMWare, the company whose technology we will be using today, has built some amazing tools that let you get started with quantized models without having to get into the nitty-gritty behind it all. C/C++ implementations What is Quantization? Quantization is a technique that seeks to reduce the computational and memory requirements of running an LLM by using lower-precision numerical types. Many popular open-source models, such as Llama, Falcon, and Alpaca, use PyTorch as the underlying framework. By default, PyTorch models use 32-bit floating points, meaning a single parameter takes up 32 “bits” in the GPU memory. Quantization aims to replace these parameters with 16-bit floating points, 8-bit integers, or even 4-bit integers. Successful quantization leads to dramatic improvements in computational speed and reductions in memory usage, meaning large models become runnable on lower-end GPUs, embedded graphic chips, or even CPUs. This idea has been around for a while - PyTorch itself has added support for 16-bit floating points and model compilations as the technology matured, but progress has been slow due to early design decisions in the PyTorch framework. Does Quantization Degrade Performance? At this point, it’s natural to wonder, wouldn’t this severely degrade the accuracy of the model? The short answer is yes, but only if you do it carelessly. Every optimization comes with inherent trade-offs, but with some specialized techniques, researchers have been able to squeeze incredibly stable performance out of highly quantized models. While we won’t go into extreme technical detail, let’s go over the broad strokes of the most common strategies being used right now. If you want to learn more, you can find out more about it in a from HuggingFace. guide Calibrated Quantization During the quantization process, a calibration dataset is run through the model. The value of each parameter is recorded, and the range is used to determine how the parameters get quantized. Assuming the calibration dataset is representative of the inputs that the model will encounter, this results in improved accuracy of the resulting model. Quantization-Aware Whereas Calibrated Quantization happens after training, Quantization-Aware Training tries to optimize the model during training. While the model is training, the activations are put through a “fake quantization,” simulating errors that will likely be introduced by the quantization process. The model is then able to adapt to the errors, resulting in a more robust model that can specifically adapt to the potential distortions. Llama.cpp and GGUF While PyTorch quantization and optimizations have been long blocked by framework design, two recent open-source technologies broke through these barriers and made quantization technologies much more accessible to the general public. Let’s briefly cover them below. Llama.cpp Llama.cpp was a project by Georgi Gerganov to port the Llama model into C/C++. This got rid of the complexity introduced by PyTorch, and the native implementation allowed quantization to be implemented directly. Therefore, the resulting model could run with up to 4-bit integer quantization, allowing high-parameter-count Llama models to be run without a specialized GPU. The project has since been extended by the community to include a roster of open-source models, including popular ones like Falcon and Mistral. GGUF GGUF is Llama.cpp’s file format for storing and transferring model information. Quantized models are stored in this format so that they can be loaded and run by the end-user. GGUF is the successor format to GGML and aims to improve on GGML by providing more extensibility, backward compatibility, and stability while still allowing for rapid development. The development of a universal file format opened the door for the open-source community to extend the Llama.cpp to optimize other models, and innovators like TheBloke and LLMWare have been working over the last several months to miniaturize popular open-source models. LLMWare’s Quantized Dragon Model In today’s example, we will be using open-source libraries and quantized models provided by LLMWare, which provides convenient tools for quickly building specialized RAG workflows. Who is LLMWare? LLMWare, a generative AI company specializing in the legal and financial industries, has been actively involved in the quantization community. As I’ve written before, their focus on privacy-conscious sectors makes them a natural candidate for experimenting with and innovating in miniaturization technologies. Previously, I wrote about their RAG-optimized BLING models that squeeze incredible performance out of 1 to 3 billion parameter models for specialized tasks like contract review and financial analysis. While most open-source models with such parameter counts tend to be only useful for toy problems, LLMWare is able to generate production-ready performance out of these models by training them for narrowly targeted tasks. These miniaturized models are then able to run without an external GPU, allowing for increased privacy and scalability. What is Dragon? Dragon is a collection of LLMs that can be thought of as more powerful versions of their BLING cousins. The original intent of Dragon was to train a higher parameter model using the same instruction fine-tuning techniques, providing an option to users that need more performance and have access to lower-end GPUs. The added parameter count resulted in more powerful models that could leverage larger context windows and generate more complex outputs, but required the user to have more specialized hardware, such as a GPU-embedded laptop or a cloud compute container with a GPU attached. However, they still represented an improvement over the extremely large models, which would require waiting for access to scarce A40 or A100 GPUs. Quantized Dragon, the Best of Both Worlds Given the above, it is easy to see why quantization gave a significant boost to LLMWare’s suite of AI tools. With quantization, a user could run Dragon-tier models on the same environment as BLING models, allowing for much more powerful analysis on commodity computers. Over the course of the last month, LLMWare has published quantized versions of several Dragon models. Today, we will evaluate LLMWare’s Dragon model built on top of Llama with a legal analysis RAG problem and compare it with a similar BLING model. Interested reachers can also explore other models - a Mistral-based model and a Yi-Based model are available from LLMWare at the time of this writing. Additionally, has made running inferences on Llama.cpp models a breeze with their tight integrations with the ctransformers library, which allows gguf models to be swapped seamlessly with PyTorch based models. LLMWare We will use a Macbook Air with M1 Chip for this experiment, meaning we will only be using widely available hardware for this exercise. Testing Out Quantized Dragon Remember that in my previous article, we built a RAG application focused on legislation search. We used vector search to quickly search through several large legislations, found sections relevant to our question about Qualified Opportunity Zone Partnership Interest, and ran the question through a BLING model. In today’s article, we will run the same question through LLMWare’s quantized Dragon model and determine if it performs better than BLING models. In order to focus on model comparison and to reduce the amount of prior knowledge required, we will do a lot of the PDF parsing and vector search manually. This has the added benefit of making the problem artificially harder for the model - LLMWare’s default embedding search chunks the source material to about 1000 tokens, but handling the parsing manually allows us to bump the context up to around 3000 tokens. This will help us clearly demonstrate the difference between the Dragon and BLING models. However, you should be able to easily integrate with the rest of the LLMWare’s ecosystem if you want to leverage their tools by following the setup steps from my last article on LLMWare. In fact, if you simply replace the name of the BLING models with the quantized Dragon model from this article, everything should run seamlessly. Without further ado, let’s get started! First, let’s import the required dependencies: import sklearn
import sklearn.metrics # for cosine similarity
from llmware.prompts import Prompt
import time
import os
from openai import OpenAI
from PyPDF2 import PdfReader 

client = OpenAI() # the library now loads the key automatically as an environment variable. We can now load the PDF. In the previous example, we loaded several large legislations, but for today, we will only focus on the PDF version of the Tax Cuts and Jobs Act of 2017. reader = PdfReader([path to PDF of tax cuts and jobs act]) Now we can generate the embeddings for each page: embeddings = []
for pg in reader.pages:
    text = pg.extract_text() 
    embeddings.append(client.embeddings.create(
        input=text,
        model="text-embedding-ada-002"
    ).data[0].embedding) Let’s also generate the embeddings for the question we’re going to ask: question = 'What is a qualified opportunity zone partnership interest?'
q_embed = client.embeddings.create(
        input=question,
        model="text-embedding-ada-002"
    ).data[0].embedding With the embedding in hand, we can perform a vector search. Because our search space is small, we can just do this manually. cos_sim = [(idx, sklearn.metrics.pairwise.cosine_similarity([e], [q_embed])[0][0]) for idx, e in enumerate(embeddings)] Now we can take the most relevant page (which is index 132 or page 133 if you want to verify the results): most_relevant = sorted(cos_sim, key=lambda x: x[1], reverse=True)[0][0] And with that, we have come to the most crucial step. We will instantiate an LLMWare Prompter object with the quantized Llama Dragon model. The Prompter class is key here because it handles the prompt engineering for us and makes sure that our prompt is consistent with the structure of Dragon’s training data. The prompt class also automatically handles the llamacpp binding, so you can use the quantized Dragon model exactly like other models. model_name = "llmware/dragon-llama-7b-gguf"
prompter = Prompt().load_model(model_name)

response = prompter.prompt_main(question, context='\n\n'.join([reader.pages[132].extract_text()]), 
                                prompt_name="default_with_context", temperature=0.3) Wait a little while, and you should see the function call return. Now print the results: print(response['llm_response']) And you should see something like the following: • A capital or profits interest acquired by the qualified opportunity fund after December 31, 2017, from the partnership solely in exchange for cash;
•As of the time such interest was acquired, the partnership was a qualified opportunity zone business (or, in the case of a new partnership, it was being organized for purposes of being a qualified opportunity zone business);
•During substantially all of the qualified opportunity fund's holding period for such interest, the partnership qualified as a qualified opportunity zone business. This is quite a good answer! For comparison, let’s see how a BLING model would perform on the same problem. One of the issues we can expect is that the large context size can “overwhelm” a lower-parameter model and lead to a less informative answer. In my previous experiments, the sheared llama 2.7b was one of the best performers for this problem, so I decided to use that as the representative of the BLING models. model_name_2 = "llmware/bling-sheared-llama-2.7b-0.1"
prompter2 = Prompt().load_model(model_name_2)

response = prompter2.prompt_main(question, context='\n\n'.join([reader.pages[132].extract_text()]), 
                                prompt_name="default_with_context", temperature=0.3) After some processing, you should see something like this. A qualified opportunity zone partnership interest is a capital or profits interest in a domestic partnership if such interest is acquired by the qualified opportunity fund after December 31, 2017, from the partnership solely in exchange for cash. The response is still good but misses some of the details captured by the Dragon model. Specifically, the answer misses the holding period requirement and the new business case. This conforms to our expectations about the lower-parameter models’ difficulty with processing larger contexts. Interested readers can extend this experiment by using even lower parameter models or increasing the size of the given context. You should see the effect become increasingly more pronounced, after which the model will give a short, garbled answer. From this experiment, it should be clear that quantized Dragon models are able to outperform lower-parameter models for their intended use cases without noticeably compromising the model’s accuracy. And with that, we have used a quantized model to solve a real-world use case and learned about its performance characteristics in the process! Conclusion Today, we explored the exciting field of LLM quantization and looked at how companies like LLMWare are taking advantage of these developments to enhance their specialized language models. As I’ve argued before, miniaturization represents one of the most promising paths to the widespread adoption of AI technologies. By combining specialization, fine-tuning, and quantization, innovators in the AI space can create scalable and performant models that solve real-world problems. You can find LLMWare’s RAG framework on and their DRAGON and BLING models on LLMWare’s . Github Hugging Face repository By the way, I am working on an exciting project that seeks to use language AI and miniaturization to revolutionize education in the developing world. We’re working with incredible activists and educators worldwide, and we’re working to bridge the global digital divide. If you’d like to learn more about my project or simply want to talk about exciting developments in the LLM space, please do not hesitate to reach out to me on either or . Github LinkedIn

Run Llama Without a GPU! Quantized LLM with LLMWare and Quantized Dragon

একটি GPU ছাড়া লামা চালান! এলএলএমওয়্যার এবং কোয়ান্টাইজড ড্রাগনের সাথে কোয়ান্টাইজড এলএলএম

Führen Sie Llama ohne GPU aus! Quantisiertes LLM mit LLMWare und Quantized Dragon

¡Ejecute Llama sin GPU! LLM cuantificado con LLMWare y Quantized Dragon

Exécutez Llama sans GPU ! LLM quantifié avec LLMWare et Quantized Dragon

बिना जीपीयू के लामा चलाएं! एलएलएमवेयर और क्वांटाइज्ड ड्रैगन के साथ क्वांटाइज्ड एलएलएम

GPU なしで Llama を実行しましょう! LLMWare と Quantized Dragon を使用した Quantized LLM

GPU 없이 Llama를 실행해보세요! LLMWare 및 Quantized Dragon을 사용한 양자화 LLM

Execute o Llama sem GPU! LLM Quantizado com LLMWare e Dragão Quantizado

Запустите Llama без графического процессора! Квантованный LLM с LLMWare и Quantized Dragon

Lama'yı GPU olmadan çalıştırın! LLMWare ve Quantized Dragon ile Quantized LLM

Chạy Llama mà không cần GPU! LLM lượng tử hóa với LLMWare và Quantized Dragon

无需 GPU 即可运行 Llama！使用 LLMWare 和 Quantized Dragon 进行量化 LLM

Caching is a strategy that can help you conserve resources and improve performance. When you have an oft-run expensive query with a result that seldom changes, caching is an ideal solution. By caching the result of that query, you can return the cached result when necessary. The result is the same, but you save the need to run the expensive query. Everybody wins. In this article, we will walk through the use of Salesforce Functions to cache expensive queries. For instance, we want to query for some value across a large number of records, and the page requiring this query is often loaded. However, the result will not change from one query execution to the next. Introduction to the Problem In our demo, the example query will be “ .” We imagine a use case in which there’s a page that our sales team loads often, and part of the page shows the total number of companies in our Salesforce org that match this condition. the number of companies with more than 10,000 employees Ideally, the expensive query is not run every time the page loads, but instead, we would implement a caching mechanism. To solve this, we will: Leverage to sync our list of companies from Salesforce to (or use a table already in Postgres). Heroku Connect Heroku Postgres Create a to query Postgres and return that count. Salesforce Function Store the resulting value in for a specified amount of time. Heroku Redis Use a Salesforce Function to check for the value in Redis. If the value exists in Redis, then return it. If not, then run the query and store the result in Redis. The data flow looks like this: Of course, Apex does have a for facilitating caching for certain use cases. For our use case—and for demo purposes—we’ll explore this caching solution that uses Salesforce Functions. Platform Cache API Before we proceed, let’s briefly introduce each of the pieces in our system. : A feature of Salesforce that allows you to run some code (JavaScript or Java are currently the supported languages) that is still in the secure area of your Salesforce org, but is . This allows you to offload workloads that are heavy or may cause you to exceed limits. Salesforce Function not running on your org : A tool within the Salesforce family for bidirectional data syncing between your Salesforce org and . Similar to Salesforce Functions, you can leverage this tool without impacting your Salesforce limits. Heroku Connect Heroku Postgres : A fully managed instance of (a relational database) on Heroku. Heroku Postgres PostgreSQL : A fully managed instance of (an in-memory key-value store) on Heroku. Heroku Redis Redis Prerequisites To use all of the above components, you must have the following pieces in place: A Heroku account A created, with and add-ons attached Heroku app Postgres Redis A Salesforce org with Functions enabled A local Salesforce Functions development environment [Optional] syncing to Postgres (a sample dataset is provided) Heroku Connect With the prerequisites in place, we can start connecting them. First, we’ll walk through connecting the environments. Then, we’ll look at the code needed to make the magic happen. Accessing Heroku Data Services from a Salesforce Function With your accounts and access in place, we can move forward with the Function itself. Let’s assume that you are starting a fresh project and have an empty Postgres database. If you are new to Functions, then we recommend going through this basic process to get a feel for things before you involve additional parts. If you already have a Salesforce project or are syncing the data via Heroku Connect, then you can modify the following commands to suit your needs. First, create a Salesforce DX project to give your function a home. sfdx force:project:create -n MyDataProj Next, navigate to the project directory and run the following command to create a fresh JavaScript function. sf generate function -n yourfunction -l javascript This will create a folder with a Node.js application template. /functions Next, associate your Salesforce Function and your Heroku environments by adding your Heroku user as a collaborator to your Function’s compute environment: sf env compute collaborator add --heroku-user <yourherokuaccount@email.com> The environments can now share Heroku data services. Next, you will need to obtain the name of the compute environment so that you can attach the datastores to it. sf env list To attach the Heroku datastores, you also need the names of the add-ons. You can get the name of the add-ons with the following command: heroku addons -a <yourherokuapp> The output will look similar to the following. The “name” of each add-on is shown in purple (for example, ). postgresql-closed-46065 With the names of the compute environment and your add-ons, run the following commands to attach Postgres and Redis to your compute environment: heroku addons:attach <your-heroku-postgres-name> --app <your-compute-environment-name>

heroku addons:attach <your-heroku-redis-name> --app <your-compute-environment-name> Now that we have connected our Salesforce Function environment with our Heroku datastores, we can write our Salesforce Function code. Implementing the Salesforce Function Before we begin writing the JavaScript for this Salesforce Function, let's set up our local development environment with the necessary libraries. In the deployed environment, our Function will get the data connection information from environment variables. For our local environment, we will use the node package to read a file named with this information. We can create that file with the following command: dotenv .env heroku config -a <yourherokuapp> --shell > .env Next, let’s install the packages we need to interact with Postgres and Redis, along with dotenv: npm install dotenv pg redis Our project setup is done. Let’s write our function code. Connect to Heroku Postgres and Redis Let’s start by adding the code that allows us to read and store data in Heroku Postgres and Heroku Redis. (Note: The has some helpful documentation on connecting to and from Node.js.) Heroku Devcenter Postgres Redis Our function code will live in the file of the folder in our project (for example, ). We open that file and add the following lines to the top. These lines will import the modules we just installed. index.js functions MyDataProj/functions/index.js import "dotenv/config";
import pg from "pg";
const { Client } = pg;
import { createClient } from 'redis'; The main part of the function is the section that is being exported. The value returned from this block will be returned to the caller of the function. export default async function (event, context, logger) {

} To keep our code clean and modular, let’s first write several helper functions at the bottom of the file. We need functions that we can call to manage our connection to Postgres and Redis. Under (and outside of) the exported function, we add the following two helper functions: /* Helper functions */

// Connect to PostgreSQL
async function pgConnect() {
   const DATABASE_URL = process.env.DATABASE_URL;
   if (!DATABASE_URL) {
     throw new Error("DATABASE_URL is not set");
   }
    const client = new Client({
     connectionString: DATABASE_URL,
     ssl: {
       rejectUnauthorized: false
     }
   });
    await client.connect();
   return client;
 }

// Connect to Redis
async function redisConnect() {
   const REDIS_URL = process.env.REDIS_URL;
   if (!REDIS_URL) {
     throw new Error("REDIS_URL is not set");
   }
    const redis = createClient({
       url: process.env.REDIS_URL,
       socket: {
           tls: true,
           rejectUnauthorized: false
       }
       });
    await redis.connect();
   redis.on('error', err => {
       console.log('Error ' + err);
   });
   return redis;
 } Load in a sample dataset To keep our example simple, let’s load a small dataset into Postgres. We can create a table called “company” by running the database commands found in the following . gist Download the contents of that gist to a file called . To run the database commands from the Heroku CLI, do the following: company.sql heroku pg:psql -a <yourherokuapp>

DATABASE=> \i /path/to/company.sql You can verify that your sample dataset has been loaded by running the following query: DATABASE=> select * from company; Write the Main Function We’re all set up! Now, we just have a little bit of code to write for our actual function. The code for our function is available as a and looks like this. You can copy this into your file. gist index.js We’ll step through and explain each section of the code. export default async function (event, context, logger) {
   logger.info(`Invoking Datafunction with payload ${JSON.stringify(event.data || {})}`);

   const redis = await redisConnect();
   let cached = {};

   // Check Redis for cached entry first
   let big_biz_count = await redis.get(`big_biz`);

    if (big_biz_count) {
       // If cached entry found, return it and be done.
       logger.info(`Found cache entry = ${big_biz_count}`);
       cached = "true"
       redis.quit();

       return { big_biz_count, cached }
   }  else {
      // If cached entry not found, then:
      // 1. Run the Postgres query
      // 2. Store the result in Redis
      // 3. Return the result and be done
       logger.info(`did not find in cache, returned ${big_biz_count}`);
       cached = "false"
       const pg = await pgConnect();
       const { rows } = await pg.query('SELECT COUNT(*) FROM company WHERE employees>10000;');
       big_biz_count = rows[0].count.toString();

       redis.set(`big_biz`, big_biz_count, {
         EX: 30, // seconds to keep before expiring
         NX: true
       });

       // Close the connections   
       redis.quit();
       pg.end();

       // Return the value from Postgres, now stored in Redis
       return { big_biz_count, cached }
   }
} An Explanation of the Code As mentioned at the beginning of this article, we want to find out how many companies have more than 10,000 employees and return that number. We want to cache the number because it is an “expensive query”. In our example, the table is small, so it is not that expensive. However, it represents an “expensive query” that we may want to run in real life. You get the idea. Let’s walk through the main sections of our function code. Connect to Redis and see if the value is there. const redis = await redisConnect();
  let cached = {};
  let big_biz_count = await redis.get(`big_biz`); If the value is there, meaning it has been cached, then we can return the cached value and be done. if (big_biz_count) {
    cached = "true"
    redis.quit();
    return { big_biz_count, cached } If no cached value was found, then we have no choice but to run the query on our Postgres database. }  else {
    cached = "false"
    const pg = await pgConnect();
    const { rows } = await pg.query('SELECT COUNT(*) FROM company WHERE employees>10000;');
    big_biz_count = rows[0].count.toString(); Then, we store the value returned from our query in Redis. redis.set(`big_biz`, big_biz_count, {
      EX: 30, // seconds to keep before expiring
      NX: true
    }); Finally, we close our datastore connections, and we return the query result. redis.quit();
    pg.end();
    return { big_biz_count, cached } You might prefer to refactor the code a little bit or add some error handling. However, at this most basic level, that’s all there is to it. Test the Function Now that we have a Salesforce Function, we can test it locally. First, we start up the function server. sf run function start Then, we invoke the Function with a payload from another terminal. sf run function -l http://localhost:8080 -p '{"payloadID": "info"}' When you invoke the function against the test database for the first time, you should see the following output because there was no value in the cache: After this first run, however, the value is stored in our Heroku Redis instance. A subsequent run of the Salesforce Function returns the same value, but this time, is true. cached When we added the value to Redis, we set the cache expiration to 10 seconds. This makes it easier to test. However, in a real-world environment, the lifespan of your cache values should make sense for your business use case. For example, if the result changes after a nightly run of a report, then you could set the cache value to expire every 24 hours. Better yet, you can create another Salesforce Function that updates the cache with the new value as soon as the report finishes. The entire contents of index.js can be downloaded . here Conclusion We did it. Caching is an excellent strategy for reducing resource load while providing faster responses. With Salesforce Functions, we can connect our Salesforce orgs to Heroku datastores (such as Postgres and Redis) and build mechanisms for caching. Salesforce Functions allow us to perform tasks that might ordinarily be load-heavy, cause timeouts, or exceed other limits imposed by Salesforce. Caching is just one use case, but it can yield tremendous benefits, and it’s easy to implement. Now, go have fun with it! Photo by on Nate Grant Unsplash

Salesforce Functions for Caching Expensive Queries

TL;DR: DAFI Protocol teamed up with Polygen to introduce dPGEN rewards so token holders can help improve the overall health of the network while gaining access to funding new projects, capital raises, seed pools, and more. New protocols launched on the decentralized launchpad can now plug and play DAFI’s Staking 2.0 economic engine. Founders and developers alike have a golden opportunity to synchronize the relationship between token reward distribution methods and the self-healing capabilities of the network relying on DAFI’s technology. announced a strategic partnership with . The goal is to enable new decentralized applications launching on the permissionless launchpad to integrate DAFI’s Staking 2.0 protocol from the get-go. DAFI Protocol Polygen Polygen is also adopting synthetic dTokens rewards to serve as an example for emerging projects of what can be accomplished with an elastic token distribution model. Reinventing Every Protocol Rewards Polygen is a decentralized launchpad where entrepreneurs and cryptocurrency enthusiasts can raise capital for their projects without intermediaries and gatekeepers. Unlike DAO Maker, BSCPad, and Polkastarter, every single step is recorded on-chain to provide transparency and create trust in a fully permissionless environment. The platform can be thought of as the Uniswap of launchpads as Polygen provides unparalleled and democratized access for projects to distribute tokens and raise liquidity. PGEN, the platform's native token, was created to play a vital role in the world's first truly decentralized launchpad. Users can lock their PGEN tokens to gain access to project raises, seed pools, and more. Through a fixed tier system based on the number of PGEN tokens staked, holders can increase their chances of participating in an IDO while earning dPGEN rewards. To make this possible, Polygen roughly 550,000 DAFI in the open market to begin the integration of the state-of-the-art rewards distribution module. purchased The one-time integration fee would not only benefit PGEN holders but also users in DAFI’s when these 550,000 DAFI tokens are redistributed. Super Staking The introduction of synthetic dPGEN tokens in the Polygen ecosystem changes the dynamics of how network users are incentivized, fostering long-term commitment. The goal is to motivate PGEN holders to improve the overall health and growth of the blockchain while they fund innovation. Polygen's CEO Mike Hepburn believes in the power that DAFI's Staking 2.0 technology has to convert demand volatility into rewards and make circulating supply reactive to market conditions. For this reason, projects that raise capital on the decentralized launchpad will have the ability to plug and play DAFI's token incentives economic engine. Snapshot of Polygen’s staking platform powered by DAFI. Protocol founders will have the golden opportunity to synchronize the relationship between token reward distribution methods and the self-healing capabilities of the network to the point where market fit is reached, and demand-side users' needs are met through organic financial incentives. "We understand that ​​the majority of decentralized networks follow a pre-determined token issuance schedule to entice network growth during the early phases of development. As the world's first truly decentralized launchpad, Polygen needed a mechanism to help new projects eliminate opportunistic actors from accumulating tokens without real care to improve the network. DAFI's technology appears to hold the answers to strengthening new protocols through a more robust and elastic distribution model," said Hepburn. DAFI Protocol's founder Zain Rana believes that the partnership with Polygen can help reshape the ideas of tomorrow as developers will be able to determine which factors in their network are reflective of staking rewards. "During the earliest phases of development, founders may wish to bolster the qualities that attribute to the utility of the token. So they may incorporate factors such as price, transaction volume, staking or liquidity provisioning volume into their rewards distribution models as the key indicators. In the latter phases, projects can program the staking rewards parameters by selecting factors more geared toward product utility, such as supply-side or demand-side traction," affirmed Rana. Also published on: https://blog.dafiprotocol.io/dafi-protocol-partners-with-polygen-enabling-new-projects-to-integrate-staking-2-0-2a9dee2e3bfa

DAFI Protocol's Collaboration With Polygen Allows New Projects to Use Staking 2.0

Solution To Value Agregation

Top 20 Growth Hacking Agencies A list including the Locations, Core Services and Top Clients for 20 Growth Hacking Agencies. During the early , growth hacking began to spread its wings. At that time, the number of startups was on the rise and growth hacking was their spell of success. Unlike traditional marketing companies, growth hacking agencies don’t believe in guessing game. The writer of puts it as: 2010s Growth Hacker Marketing, Ryan Holiday “A growth hacker is someone who has thrown out the playbook of traditional marketing and replaced it with only what is testable, trackable, and scalable.” Many companies have now started to use such agencies to increase their key business metrics. Today all sizes of businesses from startup to enterprises need fast growth to stay in the competition. Here, growth hacking agencies could play a significant role. Growth hacking agencies work on goal and performance metrics. Here are a few companies that you should explore if you are looking to grow your business quickly. The list below is compiled based on the factors: Core Team, Experience, Clients, Cost, Services and Case Studies: Voxturr : is one of the fastest growing Growth Hacking Agencies. The team and advisory board have over 150+ years of combined experience in Growth Marketing, B2B Marketing, Content Marketing, Paid Advertising, and Media Buying. Voxturr specializes in services like Marketplace Marketing, Product Launches, E-Commerce Marketing, B2B Lead Generation, App Download Campaigns, Marketing Automation, and several other new-age marketing services. About the company Voxturr Voxturr’s clientele ranges from early-age startups to large enterprise. Some of their clients include IBM, Dell, NTT, America’s Best Value Inn, Bookingace.com, Sodexo and more. : Marketplace Marketing, Digital Product Launch, App Launch, App Download Campaigns, B2B Campaigns, UI/UX and Convert Rate Optimization, Marketing Automation, Investor Campaigns, Social Media Automation, SEO, Content Marketing, Advance Analytics, Email Marketing, Performance Marketing, UX for Growth, Inbound Marketing, Engineering as Marketing, Social Media Strategy, Marketing Consultation, Social Media Strategy and Placement, Website DesignLocation: San Francisco,USA and Gurgaon,India Core Services : IBM, Dell, NTT, Sodexo, America’s Best Value Inn, Silicon Valley Insurance Accelerator, Workly, Bookingace.com, SpeakingHerbs Top Clients GrowthRocks : GrowthRocks is a growth hacking marketing agency that helps startups and well-established companies to achieve rapid and sustainable growth. GrowthRocks has expanded its market into 16 countries, with having offices in Athens and London. Their team has developed a VC-backed startup called Viral Loops which is a SaaS platform for referral marketing with a 40% growth rate. About Company : Convert Rate Optimization, SEO Strategy, Content Marketing and Strategy, Actionable Analytics, Email Marketing, Performance Marketing, UX for Growth, Inbound Marketing, Engineering as Marketing, Outreaching Strategy, Referral, and Viral Marketing, Social Media Strategy, Social Selling, GDPR Compliance Services : Athens, Greece and London, England Location : Avocarrot, Ismood, Hammam, Viral Loops, Vision Mobile, Sophia Suites, Ticketing Hub, Nannuka, GE Healthcare, Parenting Hugs, Concentric, Nestle, Live True, Nokia, Congress Rental Network, Get Qurious Top Clients NoGood - NoGood is a team of growth hackers, engineers, and creatives who were tired of the “no-good” marketing fluff. About Company They specialize in B2B, SaaS, and eCommerce growth marketing and data analytics and have worked with clients such as IBM, P&G, American Express, Heineken, Southern Marsh, Harver, Ford, and Workzone. - SEO, Facebook Advertising, PPC, Content Marketing, Conversion Rate Optimization, Video Marketing Services - Brooklyn, USA Location - Facebook Ads, Hubspot, Google Ads, Hotjar, Shopify, Salesforce Clients Cro Metrics - Cro Metrics help companies grow through strategic and data-driven experimentation. They run A/B testing to help gain a competitive business advantage. Cro Metrics works with their clients on developing their overall growth strategy, while providing marketing, product, design, and engineering expertise to both growing startups and enterprise businesses. About Company - Website Optimization, Research & Analytics Services - Facebook, 99 Designs, Stella & Dot, Trulia, Metromile, Tory Burch, Doordash, Zendesk, Outdoor Voices, Viking, Unicef USA, Hired, Weight Watchers, Hint, Taulia, Mail Chimp, Earnest, General Assembly, Ad Council, Ultra Mobile, Goodbed, Tuft & Needle, Box, Bio Lite, New Pig, ExecRank, Giving Assistant, Seavees, Sierra Club, Smartling, Rickshaw Bagworks, Vector, GreenSky, Pebble, The Met, Imperva Incapsula, Freshdirect, Tintri, Brooklinen, Healthy Paws, Appboy, Leankit, LendUp, AliMed, Fuzebox, Coldwell Banker, Greats, Regent, Infusionsoft, The Penny Hoarder, Alexis Bittar, Borrowell, Tree Hut, Proxibid, Zwift, Crexi, Alteryx, Jewish National Fund, Blurb, Freedom, Puppy Spot, Pgerduty, Udemy, Uship, Aritzia, RightNow Media, Lending Club, Good Eggs, Airbnb for Work, Honeylove, Best Egg, Pantheon, National Bankcard Clients - San Francisco, USA Location BAMF Media : BAMF Media helps young startups, SMBs and Fortune 500 companies to achieve their growth goals. They extensively use various time marketing strategies to provide the best ROI to their clients. About Company Their client roster includes TEDx and Mindvalley to name a couple. In addition, they manage a community of marketer and founders that has over 23,000 members. : Growth Strategy, B2B Hacking, Campaign Management, Email Marketing, Instagram Growth Hacking, LinkedIn Influencing, Social Media Marketing, Web Development Services : Venice, USA Location : Forbes, Mashable, HuffPost, Entrepreneur, BuzzFeed Clients The Growth Agency : The Growth Agency consists of a senior team of marketers with 10 years of experience. They are a data-driven company who work on the principle of a lean startup. They conduct experiments, analyze data, and scale up the work. About Company They create growth plans based on their client’s business KPIs and consider themselves an extension of their clients’ marketing teams. Some even consider them their CMO’s right hand. : Marketing Automation, Lead Generation, Growth Hacking, Growth Strategy, and Inbound Marketing. Services : Antwerp,Belgium and Birkirkara,Malta Location : SipWell, WDP Clients Rockboost : Rockboost’s specialty is helping companies in rapid growth by using a data-driven approach. Their secret sauce is using their framework and growth hacking education and software. About Company They have helped in building an award-winning app called HAVI Connect. : Growth Hacking Education, Consulting and Software Services : Rotterdam, Netherlands Location : Jumbo, 24kitchen, Hello print, Middlepoint, Duravermeer Clients Woodridge Growth : Woodridge Growth is New York City’s most prominent growth marketing agency. They drive results for billion-dollar companies and Fortune 500 companies and various startups. They develop and execute different strategies to provide ever-improving and more comprehensive services to their clients. About Company They differentiate itself from traditional marketing agencies. They are relentlessly focused on solving their client’s most pressing marketing challenges, and they maintain a fast-paced culture of experimentation that allows discovering new ways. : Customer Acquisition, Growth Strategies, A/B Testing, Social Media Advertising, App Store Optimization, Audience Targeting, Copywriting, Multi-Channel Acquisition, Funnel Optimization Services : New York City, USA Location : Goldman Sachs, FanDuel, Jet.com, NYU Clients Bammboo : This firm combines creativity with data and strategy with practice. They believe that only real innovation can help the world progress. So, they help organizations in validating new propositions and scale their business. About Company : Growth hacking for SME, Corporates, and ScaleUps Services : Amsterdam, Netherlands Location : Swivle Cloud Solutions, ABN AMRO, Flora Holland, Rabobank, Heppee Clients Growth Media - This firm reviews the existing marketing or advertising campaigns of various firms and provides valuable suggestions. They have successfully helped different TV print businesses and digital marketing strategies. They also offer individual advertising plans for multiple startups. About Company : Digital Marketing, TV, Print, Creative Solutions Services : Ottawa, Ontario Location : FastCompany, Bloomberg, Quora, Github, Lifehacker Clients Deviate Labs : Deviate Labs is a growth hacking consulting agency that has worked with companies ranging from bootstrapped startups to billion-dollar enterprises across every conceivable industry. Their clients include venture-backed startups like Dollar Shave Club, a half dozen companies featured on ABC’s reality TV show Shark Tank, a multi-billion dollar Korean conglomerate, and a world-renowned tattoo artist. About Company Deviate Labs is known for creatively cross-pollinating marketing tactics across industries and swiping emerging growth tactics from small startups and deploying them across large enterprises. They take help of a widely-adopted growth hacking framework, the Sales Flywheel. The Sales Flywheel was first introduced in the book, “Growth Hacking: Silicon Valley’s Best Kept Secret,”. The book was co-authored by Deviate Labs’ co-founders Raymond Fong and Chad Riddersen. : Go-to-market Strategies, Product Launch Plans, On-site Growth Hacking Presentations, Private Growth Hacking Training Sessions, Growth Financing use-of-proceeds Preparation, Marketing Allocation Analysis,Advertising Tactic Audits, Creative Growth Hacking Campaign Ideation, Marketing org Chart Optimizations /Retargeting, Celebrity Endorsements, Pay-per-Click Advertising (on a variety of exchanges), On-site Search Engine Optimization, Off-site Search Engine Optimization, Email Marketing, Content Marketing, Display Advertising, PPV Advertising, Direct ad buys, Co-marketing, App Store Optimization, A/B Split Testing, Advertising Analytics, Grassroots Digitally-focused PR, Facebook Advertising, Social Media Strategy, Investor Marketing, Conversion focused Design, Grey-hat SEO, Direct Mail, Sponsorship Strategies, Pre-roll Video Services : Los Angeles, USA Location : Talkroute, Tipping Development, Alexander Marine USA, Lollaland, FollowUpThen, ABC Roofing Co., J. Harrington Construction Clients TrueUp : TrueUp provides extensive research in various social media opportunities like Google AdWords, Facebook, Instagram, Youtube, LinkedIn, Bing, and App Store Ads. Their paid acquisition, conversion optimization, and data experts have delivered the lowest customer acquisition costs and highest conversion rates. About Company They transform the performance marketing strategy into a growth engine and provide the lowest CPAs simultaneously. TrueUp combines the collective power of data, psychology, and UX to quickly identify and validate the best conversion opportunities. They offer full agency service which includes Account Management, Graphic Design, Copywriting, and Data Analytics in addition to Front and Backend Programming. : Paid Customer Acquisition, Conversion Rate Optimization, Full Agency Service Services : London, England Location : Telefonica, Three Mobile, MoonPig Clients Ladder : Ladder believes in the iterative way of thinking, building experiments, and validation by testing..They think that a scientific approach to advertising allows us to make better decisions. They use strategy and combine it with analytics to provide creative marketing solutions. About Company : Growth Strategist, Data Science and Automated Audits, SEO, Conversion Optimization Services — New York, USA Location : Fitjoy, Los Angeles Times, facebook, Charitybuzz, Gotenna Clients Bell Curve : Bell Curve is a growth agency that offers hands-on training for Growth Hacking. They have worked with various companies with revenues from zero to millions. They’re well known for the most popular guide on growth. In addition, they’ve given talks at Google and Y Combinator. About Company : Growth Hacking Agency, Training and School for Practical Implementation. Services : San Francisco, USA Location : Envoy, Streak, Perfect Keto, Clearbit, Outschool, Lamda Labs Clients Rainmakers : Rainmakers helps various enterprise companies create ethical and compliant workplaces. They develop interactive training modules to change the monotonous experience into a learning one. About Company WorkSafe, their flagship solution helps these companies comply with the PoSH law. They have completely transformed the compliance training industry in India’s leading corporates and MNCs. They help corporates in building a safer workplace for women and a corruption-free environment. They sometimes use ‘short-films’ to create a more exceptional experience. They believe that the transformative nature of online learning can provide quality education to the society. : PoSH Online Training, PoSH Compliance, ​PoSH Audit, ​​Policy Vetting, ​IC Orientation, Awareness Workshop Services : Juhu Tara Road, Juhu, India Location : HP, IOCL, COWI, Fluke, L&T, Tektronix Clients Kickass Growth : Kickass Growth is a creative growth marketing agency that works extensively with both small and large businesses. No two projects or budgets are the same, so they offer different price packages. About Company : SEO, Content and Social Media Marketing, Advertising, Email Marketing Services : Belgrade, Serbia Location : Platformax, SupremeTracks, Zeqr, ucraft Clients The Growth Revolution : The Growth Revolution is a growth hacking agency that provides the services of Experiential Marketing, Venture Validation, and Provision of a Growth Head, if required. They have helped various corporate giants like ING & Colruyt to reinvent their marketing departments and realize their growth potential. About Company : Interactive Marketing Plan, New Venture Validation, Evidence-based Marketing, Experimentation for new ways of Marketing. Services : Antwerp, Belgium Location : Playmobil, Wolters Kluwer, Total, Bpost, Sony music, ING bank Clients We Are Off The Record : We Are Off The Record is a digital growth agency working out of Amsterdam. They help in shaping value propositions, kickstarting products, validating early user adoption, and build scalable businesses using historically robust frameworks and tools. They try to work in conjunction with founders and management teams to provide faster results and help them in adopting a growth mindset from the start. About Company : Branding & Positioning, Customer Development, Acquisition & Lead Generation, Onboarding & Activation, Funnel Optimization, Metrics and Analytics, Growth Process. Services : Amsterdam, Netherlands Location : Recruitz.io, Fixico, Temper, InnerCircle Clients Rebelhack : Rebelhack was founded in 2015 by three friends to help nurture great ideas by using data analysis and modeling. They believe in becoming a valuable component to the growth and success of businesses from the beginning, so they use agile Growth Marketing strategies and tactics to help in growing startups. About Company :Acquisition, SEO, Product optimisation, Funnel automation, Data intelligence Services : London, England Location : Geniac, MindCandy, SuperCarers, Hubble, Claudi and Fin, Bubble Clients Growth Masters : Growth Masters help their clients work smarter than their competitors. and to achieve this goal they help their clients in establishing web services like Backend Development, Social Media Marketing, and Reputation Management. About Company : Web Services, Web Design, Press Releases, SEO, Social Media Marketing, Consultant Financing, Reputation Management Services : Sunnyvale, California Location : BotList, Nomad App, Hoverpin Clients These companies are among top growth hacking agencies. If you have any additions, feel free to comment! <a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a>

Top 20 Growth Hacking Agencies — 2019

Predicting the likelihood of a customer to make repeat purchases using logistic regression

By Ledgerback, in collaboration with Joshua Sagisi How the Brooklyn Microgrid is attempting to localize the energy industry by combining blockchain and microgrid technology The energy industry is an industry that can reap many benefits from blockchain technology. In the energy industry, blockchain has many applications such as carbon emissions accounting, peer-to-peer (P2P) energy trading (synonymous with local energy trading), incentivizing renewable energy production (e.g., Solarcoin), and improving “smart” meters [3][4][5] . For this piece, we shall discuss P2P energy trading, the two major technologies that can make it possible, blockchain and microgrids, and the Brooklyn Microgrid, a P2P energy trading microgrid project in Brooklyn, New York. P2P Energy Trading P2P energy trading is just as the name entails, the trading of energy from one person or entity (producer) to another person or entity (consumer), without the use of an intermediary. Renewable Energy Production/Consumption In the majority of the United States, energy consumers have very few options for energy generation other than the public utility chosen by the state to provide energy to residents. However, with the rise of photovoltaic (PV) solar panels (hereinafter “solar panels”) in the last 50 years, and solar energy costs rapidly becoming cheaper in the past 10 years, everyday consumers finally have the opportunity to become energy producers themselves by affixing solar panels to their homes (hereinafter “homeowners”) (residential solar roofs may also be referred to as a distributed energy resource) [10]. In so doing, these homeowners have had the chance to capitalize on net-metering policies (which unfortunately have been hit hard by the public utilities). Net-metering policies allow homeowners to earn net-metering credits whenever they produce more energy than they consume in a month, which can then be counted against the next monthly bill [2]. Generally, the excess energy is sent back to the public utility, and the public utility credits the homeowner [2][6]. net-metering credits = energy produced minus energy consumed. In addition to net-metering credits, homeowners may also acquire Renewable Energy Credits (RECs), the legal proof a person has the right to the non-power attributes to renewable electricity generation, and are obtained when one megawatt per hour (MWh) of power is generated from a renewable energy source and delivered to the electricity grid [1]. Depending on the agreement between the homeowner and the public utility, the homeowner may also have to sell their RECs to the public utility [7]. Public Utility Monopolies But, why is it that energy-producing homeowners can only provide their renewable energy to the public utility, instead of other homeowners who do not have solar panels but still want to consume renewable energy? Why can’t homeowners sell their renewable energy directly to other consumers? The major reason why homeowners cannot sell to each other is that states have provided a legal monopoly over furnishing energy to consumers to the public utility [8][9]. The general reasoning behind states providing legal protection for public utilities is that the energy industry is one that leads to natural monopolies, such that large infrastructure and capital costs make it nearly impossible for any company to enter the market, and even then, to sufficiently provide energy to consumers [8][9]. This may have been true 100 years ago, but is not necessarily true today given the advancements in renewable energy and battery technology [8][9]. Demand for P2P Energy Trading There are many consumers who would like to have the ability to produce and consume (“prosum[e/ption]”) renewable energy, but unfortunately cannot afford it [11]. Rather than requiring consumers to set up a solar roof, or purchasing a mixed energy plan from their public utlity that includes renewable energy (though, you must be wary of the utility taking the RECs), consumers should have the option to purchase renewable energy from their solar-powered neighbors [11] [12]. The current system unfortunately requires the public utility to play the role of middleman, i.e., third party intermediary, between prosumers and consumers who want renewable energy [8][9][11][12]. There is little to no reason why (except for legal monopolies) P2P energy trading could not work in the United States if it can be implemented in other countries such as Australia, where the City of Fremantle is trialing Power Ledger’s P2P energy trading network [13]. To make a P2P energy trading network work, a blockchain is necessary, but can become even more powerful when combined with a microgrid. Blockchain and Microgrids Blockchain First up is our favorite topic, blockchain. Blockchain is an immutable and irreversible digital public ledger which allows a distributed network of computers to verify the authenticity of transactions without the need for a central authority [14]. When applied in the energy context, blockchain can provide a secure, transparent and decentralized ledger of all energy-production and -consumption data and transactions thereof. In addition, blockchain can automate P2P energy trading through smart-contracts. Smart-contracts (do not confuse with legal contracts) are self-executing programs, stored on a blockchain, that facilitate the exchange of value (can be anything) between parties based on agreed-upon terms [15]. Smart-contracts can automate energy trading by providing an automated marketplace where consumers can bid amongst each other to purchase renewable energy [15][16]. Microgrid Second up, the microgrid. The traditional grid connects “homes, businesses and other buildings to central power sources … [b]ut this interconnectedness means that when part of the grid needs to be repaired, everyone is affected” [18]. A microgrid is “a group of interconnected loads and distributed energy resources within clearly defined electrical boundaries [acting] as a single controllable entity with respect to the grid. A microgrid can connect and disconnect from the grid [enabling it] to operate [with the grid] or island-mode [on its own]” [17]. A microgrid is a “local energy grid with control capability, which means it can disconnect from the traditional grid and operate autonomously” [17][18]. The distinction between a mcirogrid and the traditional grid is that a microgrid is an autonomous entity that is connected to the traditional grid, but may disconnect and “operate autonomously” [17][18]. You can also think of a microgrid like a cat, and the traditional grid as a human. Cats can depend on humans for food and shelter, but cats do not need to depend on humans for survival. A community may choose to use a microgrid for various reasons including: backup “in case of emergencies”; cutting costs; connecting “to a local resource that is too small or unreliable for traditional grid use”; becoming “energy independent”; and they are “more environmentally friendly” [17][18]. The Brooklyn Microgrid Brooklyn Microgrid Logomark.^^^ The Brooklyn Microgrid (BMG) is a benefit corporation under New York Law, owned by LO3 Energy, and started in 2015 with the goal of creating self-sustaining microgrids [18]. Exergy Infographic.^^^ BMG plans to implement a virtual, local energy trading marketplace, powered by Exergy, a blockchain platform specifically developed for energy transactions [18]. BMG’s approach to P2P energy trading can provide certain benefits to the Brooklyn community. , BMG consumers will have greater choice over their energy providers, and prosumers will gain access to a bigger consumer base [16][19]. First , BMG will make Brooklyn more sustainable by incentivizing local homeowners and businesses to install rooftop solar, thereby reducing the amount of greenhouse gas emissions in the area [16][19]. Second , BMG will make Brookly more energy resilient as the microgrid can operate autonomously from the traditional grid, especially in the event of a weather incident such as Hurricane Sandy [17][18][20]. Third , the use of Exergy’s blockchain will streamline transactions and provide transparency to grow the local energy marketplace [16][19]. Fourth BGM promotes decentralization because no longer are members relying on a centralized figure, the public utility, for buying and selling energy, instead, members can directly transact with fellow members in buying and selling renewable energy. Additionally, BMG promotes transparency because prosumers and consumers know where there is energy is coming from, and that they have consumed renewable energy, which may not be the case for consumers who sign Power Purchase Agreements (PPAs) or Solar Services Agreements (SSAs) with solar providers such as SolarCity [21]. actually Brooklyn Microgrid’s Current Status BMG is currently working on developing community microgrids in the “Gowanus and Park Slope neighborhoods of Brooklyn.” The BMG is “launching a ‘simulated’ energy marketplace in early 2019, prior to launching the[ir] live marketplace” [16][19]. Anyone in the area can participate in the simulated marketplace by downloading the BMG mobile app and registering as a consumer or prosumer (energy-producing user) [16][19]. If you are prosumer, you are required to install TransActive Grid Element Generation (TAG-e G2) and smart meter at your home or business [16][19]. TAG-e G2 is a device connecting the smart meter installed at the home or business to the local energy marketplace via WiFi or ethernet connection, i.e., data is being sent across the internet [16][19]. For more information, please visit BMG’s official website. Conclusion Blockchain is ripe for adoption in the energy industry, especially in regards to P2P energy trading. P2P energy trading is just as the name entails, the trading of energy from one person or entity (producer) to another person or entity (consumer), without the use of an intermediary. To make P2P energy trading a viable alternative to the current system, there is a need for new regulatory measures to eliminate legal monopolies and a blockchain implementation that may be combined with a microgrid [8][9][11][12][17][18][19][20]. However, we recommend combining a blockchain implementation with a microgrid to fully realize the blockchain’s power in this area. Thankfully for us, companies like the Brooklyn Microgrid are taking on the task of making P2P energy trading a possibility, not only for Brooklyn, but everywhere else in the world to show that blockchain and microgrids can make communities cleaner and more energy resilient. We want your Feedback! Let us know your thoughts on this article by leaving a reply or sending us a message. Your feedback is always much appreciated and we cannot improve without it.^^ Greyscail Blockchain Review Greyscail Blockchain Review is a community-driven, decentralized network of researchers and writers passionate about emerging technologies, communities and ideas. In particular, we want to review blockchain applications so readers can see how blockchain can be implemented in many different industries, fields, initiatives and programs. If you are passionate about blockchain and emerging technologies, communities and ideas in general, please do not hesitate to write us a message to collaborate on a work or how we can improve our process.^^ Find our more at www.ledgerback.coop. Notes ^^= Send us a message or leave a reply if you believe a correction is warranted. ^^^ = Use of logos, logomarks, or any other marks is solely for normative use and is in no way shape or form an endorsement by such companies of the views expressed herein, or of Greyscail Blockchain Review. The companies mentioned in this article and Greyscail Blockchain Review have no relationship, nor should one be implied from the contents of this article. References [1] Renewable Energy Certificates (RECs), Environmental Protection Agency (EPA), last accessed Mar. 20, 2019. https://www.epa.gov/greenpower/renewable-energy-certificates-recs, Renewable Energy Certificates (RECs) | US EPA [2] What is an SREC? Net metering credits explained, EnergySage, , Apr. 11, 2017. https://news.energysage.com/net-metering-and-srecs-explained/ 2019 Net Metering Credits and SRECs Explained | EnergySage [3] Stephen Lacy, How Peer-to-Peer Energy Trading on the Blockchain Might Work, GreenTechMedia, Apr. 03, 2018. https://www.greentechmedia.com/articles/read/how-peer-to-peer-energy-trading-on-the-blockchain-might-work, How Peer-to-Peer Energy Trading on the Blockchain Might Work [4] Smart meters: a guide, United Kingdom (UK) Government, Jan. 22, 2013 (Published), Jan. 4, 2018 (Updated). https://www.gov.uk/guidance/smart-meters-how-they-work, Smart meters: a guide [5] Solarcoin, Solarcoin, last accessed Mar. 20, 2019. https://solarcoin.org/, SolarCoin [6] Net Metering Guide, Mass.gov, https://www.mass.gov/guides/net-metering-guide Net Metering Guide [7] and Jaineel Aga, Bottom Line on Renewable Energy Certificates, World Resources Institute, Nov. 2008. Chris Lau https://www.wri.org/publication/bottom-line-renewable-energy-certificates, Bottom Line on Renewable Energy Certificates [8] End monopoly protections to fix PG&E and other utilities, The Orange County Register, Mar. 16, 2019,12:00 PM (Published), Mar. 16, 2019, 12:01 PM(Updated) Adam B. Summers, https://www.ocregister.com/2019/03/16/end-monopoly-protections-to-fix-pge-and-other-utilities/, End monopoly protections to fix PG&E and other utilities [9] Steve Corneli and Steve Kihm, Will distributed energy end the utility natural monopoly?, Electric Policy, Jun. 29, 2016 https://emp.lbl.gov/sites/all/files/Corneli_29June2016.pdf, <a href="https://medium.com/media/07f6dae6c1714466783417aa6a36a5e0/href">https://medium.com/media/07f6dae6c1714466783417aa6a36a5e0/href</a> [10] David Martin, Powering the future… thanks to your neighbor’s renewable energy, Renewable Energy World, Mar. 19, 2019. https://www.renewableenergyworld.com/articles/2019/03/powering-the-future-thanks-to-your-neighbors-renewable-energy.html, Powering the future... thanks to your neighbor's renewable energy [11] Ben Schiller, You Don’t Need An Energy Company When You Can Buy Power From Your Friends: Utility companies are getting disrupted as people sell each other their energy, without the middleman, FastCompany, Mar. 16, 2015, . https://www.fastcompany.com/3040833/you-dont-need-an-energy-company-when-you-can-buy-power-from-your-friend You Don't Need An Energy Company When You Can Buy Power From Your Friends [12] Julia Franz, A new way to go local: Buy solar energy from your neighbors, Public Radio International (PRI), Jul. 28, 2017, 8:00 AM EDT. https://www.pri.org/stories/2017-07-28/new-way-go-local-buy-solar-energy-your-neighbors, A new way to go local: Buy solar energy from your neighbors [13] Australia: Power Ledger’s Blockchain Energy Platform Goes Live in Fremantle, Cryptocurrency News Network (CNN), Aug. 12, 2018. Mark Emem, https://www.ccn.com/australia-power-ledgers-blockchain-energy-platform-goes-live-in-fremantle, Australia: Power Ledger's Blockchain Energy Platform Goes Live in Fremantle [14] Mark E. Burge, , 7 Hastings L.J. 1493, 1529 (2016) (“within a small margin of error”). Apple Pay, Bitcoin, and Consumers: The ABCs of Future Public Payments Law [15] Steven White, What is a Smart Contract?, Invest in Blockchain, Mar. 21, 2018. https://www.investinblockchain.com/what-is-a-smart-contract/, What is a Smart Contract? [16] Brooklyn Microgrid 101, Brooklyn Microgrid, last accessed Mar. 20, 2019. https://www.brooklyn.energy/bmg-101 , BMG 101 | Brooklyn Microgrid | Community Powered Energy [17] Microgrid Definitions, Microgrids at Berkley Lab, last accessed Mar. 20, 2019. https://building-microgrid.lbl.gov/microgrid-definitions, Microgrid Definitions | Building Microgrid [18] Allison Lantero, How Microgrids Work, Department of Energy (DOE), Jun. 17, 2014. https://www.energy.gov/articles/how-microgrids-work, How Microgrids Work [19] Brooklyn Microgrid, Brooklyn Microgrid, last accessed Mar. 20, 2019. http://brooklynmicrogrid.com/, Brooklyn Microgrid | Community Powered Energy [20] Leon Kaye, Brooklyn Microgrid Seeks to Disrupt NYC’s Power Monopoly, TRIPLE PUNDIT, Mar. 16, 2016. https://www.triplepundit.com/story/2019/brooklyn-microgrid-seeks-disrupt-nycs-power-monopoly/27411, Brooklyn Microgrid Seeks to Disrupt NYC's Power Monopoly [21] Tim McDonnell, The Solar Loophole Utilities Can Use to Game Energy Credits, WIRED, Jan. 20, 2016, 02:53 PM. https://www.wired.com/2016/01/the-solar-loophole-utilities-can-use-to-game-emissions/, The Solar Loophole Utilities Can Use to Game Energy Credits

Trading Energy: Will Blockchain disrupt the energy industry?

How the Alibaba tech team uses deep learning to help online marketplaces drive strong business results through the creation of quality outfit displays Maintaining success in online retail is a constant struggle that requires retailers to determine the best method of presenting their products to customers. One method is to make an attractive poster for the item, which previously required a great deal of human labor. Another way is suggesting item combinations — especially for clothes and accessories — in a bid to encourage customers to make an extra purchase. Alibaba’s Dida AI assistant combines both of these strategies. Dida is modeled after Alibaba’s famous poster designing AI engine, Lu Ban. Like Lu Ban, Dida uses graphical algorithms to collate data and train itself to generate targeted, high-quality images of popular item combinations. While mainly used for generating personalized outfit combinations for online fashion retail, Dida’s use has now expanded to other areas, such as copywriting for product description. So, how does Dida work? Technically Dida is not a single entity but a combination of multiple platforms and algorithms, including front-end operations, algorithm, image mosaic, and personalized launch platforms. First, operators select items on the front end and designate items to be combined using deep image processing and combination algorithms. When one or several items trigger a combination request to create a combination, Dida searches for additional items that are a good match and follow specific operating rules. Next, descriptive titles are generated based on information from the triggering and returned items. Finally, the items are synthesized and displayed in a visually flattering way using smart typography. The images of the item combinations are then generated, personalized, and pushed to users with recommendation algorithms. As of February 2017, Dida’s algorithms have been launched across a variety of Alibaba’s eCommerce platforms, including Taobao and Tmall. For major promotional events, Dida aids operators in generating millions of combinations for a wide range of products and it is utilized by hundreds of thousands of Alibaba design experts. Alibaba is already recognizing positive results from trials on several of its pages, including iFashion, Mobile Taobao Primary Focus, and YouHaoHuo. Images from a backend outfit display on Dida The next section briefly summarizes the top three benefits of using the Dida platform, and the rest of this article discusses the technical foundations of the Dida platform and the success stories of iFashion, Mobile Taobao Primary Focus, and YouHaoHuo. Dida’s Benefits in a Nutshell 1. Content production Dida utilizes a deep learning network to collate extensive collections of information from users, products, and operations knowledge. When input to help with content creation, the Dida AI engine performs at the same level of quality as an experienced design expert. The graphical algorithms generated by Dida are then applied across multiple business areas. 2. Platform enabling Dida combines graphical algorithms and platform establishment to allow operators to select items from the Dida platform and generate item combinations and personalized launches in a one-stop management process. 3. Improved efficiency The average design expert produces thousands of item combinations daily. The Dida platform generates millions of item combinations per hour, which is a massive improvement in efficiency. Dida also combines algorithms to expand the overall size of the information pool and enhance personalization. Technical Foundations of Dida When used for online fashion retail, Dida generates outfit combinations and descriptions, which requires designing graphical and textual algorithm frames. All bottom layer data is shared, including pictures and titles for items, operational input data, and various other information. Dida utilizes this information to generate outfits and then generates descriptions for each one. First, a picture combination algorithm uses Convolutional Neural Networks (CNN) to pre-process images. Next, two combination logic algorithms are run using the Deep Semantic Similarity Model (DSSM): - Long Short-Term Memory (LSTM)-based sequencing outfit production. - Deep Aggregated Network (DAN)-based non-sequencing outfit production. The generated outfits are imported into Context-aware Pointer-Generator Networks (CPGN) to generate text descriptions for each outfit. The final result includes text and graphs that provide holistic descriptions of each combination. The relevant image and textual algorithms are introduced in the following sections. Image Algorithms This section includes all relevant preparation and processes for the use of image algorithms in this scenario. Data Alibaba’s training data was initially sourced from Polyvore, a website that stores massive amounts of user-submitted item combination examples that are further delineated based on factors such as user likes and comments. When Taobao’s internal businesses practices were firmly established, Alibaba created an in-house database using hundreds of thousands of high-quality outfit combinations obtained from veteran Taobao experts. Characterization First, items must be characterized. Images are the most intuitive in terms of delivering information. Alibaba uses Lu Ban’s library of millions of white-background images to generate image characteristics for items in a specific item pool. This is accomplished using the inception v3 model of CNN. The process is as follows: 1. The pre-trained model is fine-tuned using the category as a label, and the vector expression of the penultimate layer is extracted and used as the image representation of the item. 2. Vector expressions for all images with category constraints are organized into clusters using K-means clustering. Some optimizations have been done on K-means clustering which ensure centralized and balanced distribution, making it ideal for use in this scenario. Optimized K-means clustering uses differences in category relationships and combinations and the distributed quantity of items for various categories as determiners. An individual category can include a variety of different clusters. This step ensures every item ends up in a cluster. 3. The model is fine-tuned again using inception v3, with the clusters generated in Step 2 being used as labels. High-dimension vector expressions are also extracted. These vector expressions are used as the final characteristics for images. Model I: LSTM-based sequencing outfit combination production 1. High-dimension vectors are obtained using CNN, and the vectors of side information are embedding- and stacking-transformed as the input layer of the model. 2. Input vectors are divided into two routes after the first MLP layer. One route leads to the LSTM network for sequence learning, and the other leads to the DSSM network for vector alignment. The details of both are below. LSTM network Generating combinations is a sequential process. Each item generated for an outfit is considered a sequential step. Starting from the first item, each new item must be correlated with previously-generated items. This is possible due to the LSTM network’s intrinsic sequential relationships. LSTM, an extension of Recurrent Neural Network (RNN), includes function gates that allow it to capture long-term dependency effectively. For this scenario, S represents an outfit, xt represents the CNN characteristic representation of the item, and S=x1,x2,…,xN represents an outfit sequence. According to the maximum likelihood estimate (MLE), the main aim was to maximize the expectation of: DSSM network A DSSM network approach is adopted due to the expectation that items in one outfit combination should have closer distances in vector space. Positive samples come from online logs and quality outfits. The most-clicked and highest-quality outfits from veteran Alibaba experts are collected from the online log and divided into pairs to serve as positive examples for the DSSM network. Outfits receiving a low number of clicks are used as negative examples. As shown in the figure, vector expressions for items pass through MLP before entering LSTM. When LSTM generates an item X, X is subjected to MLP transformation, and its distance from other items that have not yet entered LSTM is calculated. Positive examples of other items are denoted as Y+ and negative examples as Y−. Short distances between positive examples and long distances between negative ones are the ideal situation. Therefore, loss is expressed as: where the sim function uses cosine similarity, θ stands for parameters, and the goal is to maximize Δ. Mini-batch SGD is used to optimize θ on GPU. Model II: DAN-based non-sequencing outfit production The launch of the first version based on the LSTM Model proved satisfactory. However, subsequent studies indicated DAN as a superior model. The only changes made to the previously described structure is the replacement of the LSTM module. The DAN model achieved lower loss and better output. The core function of DAN is considering outfits as a combination mode rather than a sequencing mode. Take outfits consisting of tops and pants as an example. Two sequences of training data are required to train the LSTM network: Tops + pants and pants + tops. For DAN, tops and pants are input into the network as combinations without sequential differences. An outfit’s training data is input into DAN after passing through CNN and side-information embedding. Vectors are changed to a non-linear layer first, and then they enter the pooling layer. Trials of this process using sum-pooling and max-pooling have found the former is the better option. The entire DAN-based process is outlined in the following figure. Compared to LSTM, DAN achieves lower loss during training. Another advantage of DAN is that it only requires combination data, rather than full permutations, to construct training data. Less training data shortens training time and makes a periodical iteration model possible. Context graph-based prediction process Outfits tend to be defined differently based on the operator. Women’s clothing sellers often view top+bottom+shoes or dress+accessories+bag as complete outfits. One-piece dresses and jeans never appear in the same outfit. From the perspective of a seller of household goods, the absence of either a bed, a nightstand, lamps, or wallpaper can make a bedroom combination incomplete. In practice, operators often factor in the usage scenario and additional restrictions based on style and season. The main difficulty in this scenario is creating combination algorithms that meet the needs of operators. Alibaba designed a context graph to address this issue. A context graph is a set of structured operation rules, including constraints on category, style, season, and more. In the outfit combination prediction stage, all items and their side-information undergo embedding, stacking and full connections before they are stored in an item pool. Take DAN as an example: when an activity sends requests, all triggered items undergo DAN. Without considering constraints, the MLP output is used to search the item pool for similar items to obtain the next item. According to the context graph, when constraints are factored into the similarity search, results are filtered so that only items that meet operation rules end up in the candidate set. Next, TopK is picked out of the candidate set. Whenever an outfit is generated, all satisfied combination constraints are re-calculated using the algorithms to promote the generation of the next item and a new candidate set. The context graph is packed into the model, making outfit combination prediction a fully real-time process. It also ensures a high yield rate, as every generated outfit meets the input conditions of operators, reducing the cost of manual filtering. Textual algorithms This section describes all relevant preparation and processes for the use of textual algorithms in this scenario Data Veteran design experts have created hundreds of thousands of self-determined outfits. Descriptions of these outfits are collated and used as training data. Training data inputs include item titles and outfit tags. Words are used as the basic unit. CPGN model Operational inputs are added based on PGN to establish strong connections between copywriting, items, and operational requirements. This new approach is named CPGN, and its algorithm structure is as follows: The entire frame comprises an encoder-decoder structure. First, the original data (x1, x2, …, xn) and operational inputs (z1, z2, …, zn) are encoded. Every individual word from the original data goes through a single layer of a bi-directional LSTM network, and the hidden state is denoted as hi. Operational input can be a complete sentence or keywords. In the former case, LSTM processing is still adopted. In the latter case, embedding is applied directly to keywords, which are denoted as ri. In scenarios where i represents the i-th input, and t represents the number of decoding steps, the attention distribution (at) and context vectors (ht∗ and rt∗) are denoted as follows: where η is a multi-layer MLP with tanh being its activation function, and st represents the decoder status at the t-th step. The attention distribution is viewed as the probability for each encoded source word to generate the decode, where ht∗ and rt∗ are weighted sums of attention and the expression of the information obtained from source statements. The probability distribution of the next word across the dictionary can be derived on this basis: where g is a two-layer MLP. In this way, the probability of the generated section is derived. To balance pointing and the generator, parameter pgen∈[0,1] is designed, which is a probability soft-switch associated with the current decoder status st, context vectors ht∗, rt∗, and decoder input yt−1. pgen allows the next word to be generated from the dictionary or copied from the input. Assuming the predicted probability of each word in the dictionary is Pvocab(w), then: where σ is a sigmoid function. The current P(w) contains the entire dictionary, including words that were not previously in the dictionary but appeared in inputs. This helps to solve problems with OOV. In the training stage, assuming the t-th target word is wt∗, loss can be denoted as: Finally, a coverage algorithm was introduced to tackle repeat words. As all algorithms are launched directly online, Alibaba added a regular expression layer following duplicate removal in the algorithm to eliminate loopholes. Dida Case Studies This section looks at some successful case studies of Dida in iFashion outfits, Mobile Taobao Primary Focus, and YouHaoHuo. iFashion outfit iFashion is a Taobao page that uses an outfit combination-centric scenario. iFashion maintains high-performance requirements for graphical algorithms, both in terms of content quality and visual effect. Alibaba periodically uses Dida to produce matching outfits and text descriptions for iFashion selections. This represents a huge addition to the outfit pool, which previously relied solely on contributions from veteran experts. Outfits generated via algorithm are mixed together with outfits from veteran experts in waterfalls and then displayed to users in personalized pushes. Creating outfits via algorithm provides significant benefits, including decreased costs, positive feedback, and high conversion rates. Mobile Taobao Primary Focus Mobile Taobao Primary Focus is a Taobao banner with strong operational demands. Every image is linked to an event page that displays copywriting for the event and images of the products being sold. In personalized launches, Alibaba’s recommended algorithms displayed personalized contents for every user based on their behavior. Before Dida, identical copywriting was used for all item combinations, even if the images were personalized. In this scenario, Dida’s graphical algorithms were used to create multi-item combinations for the garment industry. The resulting outfit combinations were high-quality and enriched the imagery and presentation in the primary focus area. Alibaba has also tested using textual algorithms for copywriting across multiple industries. When using a conventional approach, operators often use a very bland, general style. For example: · Primary copywriting: Sports party · Secondary copywriting: Choice brands, large discount · Benefits: Rush for big value coupons. This style of copywriting is boring and easily ignored by consumers. In contrast, Dida generates copywriting that is far more interesting and engaging: For this example, Alibaba’s model uses item titles, descriptions, and attributes (information about yoga bricks) as the input data. Operational inputs are individual benefit keywords or tags (quality choices, big brands, sales promotions). The final copywriting consists of: · Primary copywriting: Quality choices for yoga bricks (a combination of words extracted from item titles and operational inputs) · Secondary copywriting: Big brands, big discounts, spend-and-get-back (derived from words extracted from operational inputs). In comparison, smart copywriting is customized for specific items and events and describes products in a way that is interesting and highlights their benefits and associated sales events. The graphs and text combinations generated for Primary Focus resulted in double-digit percentage increases in CTR and UCTR. YouHaoHuo(有好货) YouHaoHuo is a Taobao page that is highly popular among consumers due to its flagship concept, “Haohuo,” which refers to the sale of quality items. Many of the YouHaoHuo product titles designed by veteran experts are too long to be fully displayed on the current page layout. The resulting truncation leads to unclear item descriptions and prevents users from viewing the full information for items. Alibaba used Dida copywriting algorithms to re-extract key information from titles and limited the length, helping users to make better decisions. (Original article by Chen Wen陈雯) Alibaba Tech First hand and in-depth information about Alibaba’s latest technology → Facebook: . Twitter: . “Alibaba Tech” “AlibabaTech”

Finding the Perfect Outfit with Alibaba’s Dida AI Assistant

Rails 5 Imgur Clone Welcome to the second and final part of the Rails 5 Imgur clone, in this part, we will build the image uploading, manage configurations and then deploy to Heroku. Be sure to check out the first part if you haven’t already. here First, signup and verify a new cloudinary account by going , it’s my referral link to cloudinary which will give me little bit extra space. here Let’s start by adding few more variables to our cloudinary configuration at config/initializers/cloudinary.rb Remember, the has to exactly in that folder, if you open the you’ll see in the comments written it says the config has to be there, it’s just how rails configuration works. cloudinary.rb config/application.rb Make sure your looks something like this. cloudinary.rb . . [ ] . [ ] . [ ] . . Cloudinary config do | | config config cloud_name = ENV 'CLOUDINARY_CLOUD_NAME' config api_key = ENV 'CLOUDINARY_API_KEY' config api_secret = ENV 'CLOUDINARY_API_SECRET' config cdn_subdomain = true config enhance_image_tag = trueend Go to cloudinary dashboard and you will the variables which we will use. The inclusion of increases image serving performance by getting the best cdn location and adds more functions to the built in rails method. Cloud name, API Key, API Secret cdn_subdomain enhance_image_tag image_tag Okay, here we are dynamically setting environment variables to our application. It will pick up variables for production and development environments. You really don’t wanna hard code this as it is not safe and wise to publicize your keys and other info as these are highly sensitive. This style is highly recommended for any of your rails project not just this. It’s just really a damn good practice. You might think its just a home project but if you work at a company this is really serious so, it’s better to practice from now. Secondly, and this is the most important step, setting up your variables in your environment. We are going to use the gem. Add this to your and run in your terminal to install the gem and then restart your server. dotenv Gemfile bundle gem 'dotenv-rails', groups: [:development, :test] This is by far the best, easiest and simple solution and works perfectly. Now go to project’s root directory and create a file called .env We are going to set our variables like this. export CLOUDINARY_CLOUD_NAME=export CLOUDINARY_API_KEY=export CLOUDINARY_API_SECRET= Just put the variables as it is without any quotes. And then add to your so that it doesn’t get pushed to your GitHub repo. We are going to add Heroku cloudinary add-on and set the variable in the production environment in their way. .env .gitignore Alright, our configuration part is done for now. If you wanna further know about the gem then go to their and read more. dotenv github page Finally, we are going to add code to our controller for uploading and saving images to the database. Go to your controller at and add to your & method like this. pics_controller.rb new create .**newend def @pic = Pic new def @pic = Pic**. ( . ( ). ( )) . create new params require :pic permit :image @pic saveredirect_to @picend What we are doing here is basically creating an called @ and adding the method to our model which we will use it in all over our project. Later, in the create method we are allowing it to add to the database, then save it and take it to that pic page after it’s been saved to our database. instance variable pic new Pic Now, create a & in directory new.html.erb _form.html.erb app/views/pics/ In your add this code. _form.html.erb <%= <%= <%= <%= <% <%= ** .submit %>**<% form_for @pic do | | %> f .label :image do %> f .hidden_field :image_cache %> f .file_field :image %> f end %> f end %> So, here we are creating a form for a pic to be added to our database and then we are going to display it in the web. Now, we going to implement the show page and controller. In your add this following code pics_controller.rb . ( [ ]) def @pic = Pic show find params :id end Here we are pulling the data from database by their id Create a new file in directory and this simple line to display the image to the public show.html.erb app/views/pics/ <%= image_tag(@pic.image.url, width: '100%', crop: "scale")  %> We are also scaling the image to fit in the display so, that it looks beautiful. Great, your image is displayed now we are going to display all the images to our index/ home page. Open add this following code to controller to get all the images from the database pics_controller.rb index . def @pics = Pic index allend In your add this to loop through all the images and display it to the index page. index.html.erb <% <%=  **image_tag( .image.url, width: '100%', crop: "scale")  %>**<% @pics.each do | | %> pic pic end %> Now, we are going to prettify our app a little by adding simple bootstrap css and a navigation. Go to , it’s a bootstrap material design flavor which I really like, you could use this or anything else you like. Grab the link add it to the of your right below the csrf meta tags bootstrap head application.html.erb <link rel="stylesheet" href="https://bootswatch.com/paper/bootstrap.min.css"> Now, create a named inside the directory, and add the navigation to our header partial _header.html.erb app/views/layouts/ <%= <%= <nav class="navbar navbar-default"><div class="container-fluid"><div class="navbar-header"> link_to 'Rimgur', root_path, class: 'navbar-brand' %> link_to 'New Post', new_pic_path, class: 'navbar-brand' %></div></div></nav> And then render the header to our main application page. Add this to your on top application.html.erb yield <%= render 'layouts/header' %> Now, as a final step we are going to take our app live by deploying it to heroku. For our application to work on production, we need to do some modification to our Move the to group and add for P** ** for Gemfile. gem ‘sqlite’ development pg ostgreSQL production. **group :development dogem 'sqlite3'end group :production dogem 'pg'end** Then do this following to install the gems bundle gem install bundler Git add and commit all of your files. git add .; git commit -m ‘project finished’ Create a new git repo in your account and our codebase to it. Follow the instructions on the screen to do . git remote add and push Now, we are ready to take it live. Create a new account for FREE and verify it. Then, create a new heroku app in your terminal and push it. heroku heroku create git push heroku master We are going to have migrate our schema to production for our app to work. We can do it like this. heroku run rails db:migrate Do to open the app in browser. heroku open Okay, now you are going to do the most important step for our image uploading to work. heroku addons:create cloudinary:starter Remember, we set up the environment variables for for machine, now we are going to do it for our production. cloudinary development Go to your heroku dashboard, then to your app, and then to the cloudinary dashboard to get our configurations. Now, in your terminal do this following to add the config variables. heroku config:set CLOUDINARY_CLOUD_NAME= heroku config:set CLOUDINARY_API_KEY= heroku config:set CLOUDINARY_API_SECRET= Try uploading a pic in your app and then check the cloudinary dashboard that it’s been added. Congratulations, you have successfully built a fully functional web app. Feel free to play around with it and make it more awesome. Here is the link to my github . All the code is hosted here for your reference. repo Thank you for reading it, hope you enjoyed it and will use this knowledge to build something awesome. Subscribe me if you would like to receive future posts to your inbox. LIKE & SHARE if you have liked my post. Please comment below any feedbacks, suggestions or requests. Also please visit my website .

Rails 5 Imgur Clone Tutorial…Part 2

PICO-8 Two weeks ago, I became intrigued with the idea of doing some form of real-time lighting on the , a tiny fantasy console. I figured that I would fiddle with it for a while and decide it’s impossible on the puny simulated CPU, but this turned out to be wrong — proved to be a pretty beefy machine after all! Working on this was so fun that I couldn’t stop pushing it, adding new features and optimizing the engine behind it until I got to this point: PICO-8 PICO-8 I’ve been working on this for quite a while and happily tweeting about it, slowly turning this engine into a . However, I recently got it to run at 60 FPS and started getting some disturbing responses. game And I’m all out of fairy dust. Determined to prove I’m not a witch, I decided to release the magic incan… code as a , along with these totally scientific and completely non-esoteric explanations of how it all works. cartridge Some things in here will be very specific to the engine, while other techniques will hopefully be more general and applicable to any piece of PICO-8 code you would like to heavily optimize. I tried to keep the post accessible, but I had to assume some familiarity with and , just to keep the already ballooning word count to a reasonable level. hexadecimal notation bitwise operations When all you have is a palette, everything is a nail In modern games, lighting is done on the GPU by shaders that have a 24-bit colorspace to work with and the horsepower to do gazillions of calculations per pixel. On the PICO-8, things are a bit more quaint — anything that has to do with manipulating color will usually boil down to one thing: mapping the 16 colors to different ones. This is the way to do basic fades, and a lighting effect is just a more complicated fade. Instead of uniformly moving all pixels towards black the same amount, we pick that amount based on light level. a palette effect Palette: The Darkening So, we know the basis of our effect will be setting up a few palettes — one for each lighting level we will support. For , palette #1 is basically a palette that does nothing, since it represents “fully-lit”. Then, we have a number of intermediate palettes, with colors in each getting successively darker. The last palette will be for totally unlit regions — a palette that maps every single color to black. Dank Tombs I’ve chosen to have six lighting levels, including full brightness and pitch black. Every lighting level added is a significant performance hit — so six was chosen as kind of a sweet spot. The palettes are kept in sprite memory and read from them during initialization— that way they’re convenient to edit, and it’s easy to eyeball what color should go where for it all to work. The palettes (left-side for lighting, right side for fades) Options, options When it comes to using these palettes, there are basically two choices: For each thing to be drawn, set the right palette first (based on how it is lit), then draw it. Draw everything fully lit first, then manipulate pixels on the screen to apply the lighting effect. The former option seems more attractive at first, since that’s exactly what PICO-8 supports out of the box through the function. The problem with that idea is that light level changes happen in the middle of objects — so either we couldn’t make it look quite right (supporting only one light level per object), or we’d have to draw each object multiple times with a masking/clipping setup reaching byzantine levels of complexity. Let’s not even think what would be needed to handle backgrounds — is definitely not going to work when lighting changes once every tile. pal() map() We are left with the second option, which is refreshingly simple in comparison. We draw everything first just as we would normally, having the full comfort of using and for their intended purposes. Once we’re done with that, we manipulate each pixel on the screen to apply the right palette. map() spr() Before and after applying the filter On dividing, conquering, and getting sidetracked a few paragraphs in Before we dive into coding, it’s worth taking a moment to consider how our filter is going to work. As a core concept, it will be a series of concentric discs centered on the light — each disc applying a darker lighting level as we go away from the center. Writing code that does this in one fell swoop is kind of daunting, but every complex task can be broken down into simple ones. In graphics there is a standard approach to handling complex shapes — breaking them down into . Drawing a horizontal line is simple, so we can concentrate on implementing whatever effect we want within a tight loop. Meanwhile, the complex calculations involved into figuring out where exactly to draw the lines can be done in a separate place. programming horizontal lines This is how the engine works, and part 1 of this series will concentrate on fading a single horizontal line as fast as possible, leaving the gruesome details of how to put them together for future posts. I’ll be using mostly pseudo-code here — for actual, final code, look up the function in the cartridge. fl_blend() If you want it done well, do it yourself Before I went into an aside on general programming principles for three full paragraphs, we decided that we’re going to apply our effect drawing everything onto the screen. after The problem with this approach is that built-in PICO-8 support for palettes cannot help us. If we had a function that worked like but copied data from screen memory, we could use that — but alas, there is no such thing. Woe us. spr() This means that we have to do all the work manually. Palettes just replace pixels of one color with a new color, so the straightforward way to apply one is something like that: local pixel = pget(x, y)local mapped_pixel = palette[pixel]pset(x, y, mapped_pixel) for each x, y we want to change: That is very simple, and like most trivial algorithms, it’s dog slow. Applying an effect this way to more than a 32x32 region already makes us drop frames. That’s because and have a lot of extra work to do: they have to clip the coordinates, apply the camera position, and they also have to deal with one extra thing — which I will now explain in more detail, as it will also be the idea behind our solution to the problem. pset() pget() Going off the deep end: PICO-8 screen memory PICO-8 simulates an old fashioned computing system. Our pixels don’t live somewhere in an anonymous screen buffer texture on a separate GPU card accessed via a 200MB driver. Instead, they are just chilling at address 0x6000 in our simulated , waiting to be directly manipulated. RAM Since PICO-8 only has 16 colors available and 16*16=256, the designers of our imaginary hardware made the clever decision of storing two pixels in each memory byte. Each screen line is 64 bytes long, and each of those bytes stores two pixels as follows: byte = (left pixel) + 16 * (right pixel). It looks like this: How it all fits (artist’s impression) This means has its work cut out for it — not only does it handle clipping/camera/palette, it actually has to go into the right byte and only manipulate half of it. That’s part of why it’s simulated to be quite slow, and why it would be slow if PICO-8 was real silicon. pset() Peeking and looking up Fortunately, we can avoid all the extra work does — we can just go mad scientist on that thing and manipulate screen memory directly! This is made easy thanks to the uber-fast and functions. pset() peek() poke() If we think about it carefully, there is no reason our filter has to work one pixel at a time. A palette is basically a 16-entry table that says: for color X, use color Y instead. We can cook up a similar table, but one with 256 entries. That way each entry can handle an entire byte containing two pixels (like the representing the red-yellow pair in the image above) and apply the palette to both at the same time, returning a new byte with two new colors. A8 This is a very general technique called a look-up table, and various effects can be sped up by precalculating the results and just looking them up in the table at runtime. Once we prepare our look-up table during initialization, based on our palettes in sprite memory, a first sketch of a solution would be something like this: local start = calculate_address(x1, y)local end = calculate_address(x2, y)for address = start, end dopoke(address, lookup[peek(address)])end That’s much faster than , but since we’re mad scientists, we don’t want fast — we want crazy fast! pset() Doing more work to do less work Just like before, the one-liner above has a place where a lot of extra work is hidden: is secretly a performance hog. lookup[…] In compiled languages like C, arrays are simply block of continuous memory. Accessing an element is simple: just take the address of the array, add the index (multiplied by element size), and voila! In Lua, the table structure has to handle everything from simple arrays to complex nested objects. It doesn’t matter that we know our look-up table has only integers as indices. As far as Lua is concerned, we could change our mind at any time, say and ruin its day. This means that Lua can’t use the simple array representation C does, relying on slower hashtables instead. lookup[“banana”] = “cucumber” What are we to do as mad scientists? What mad scientists always do — implement it ourselves! There is a nice chunk of memory reserved for our convenience in the PICO-8 memory map, starting at 0x4300. If we keep our look-up tables in memory, we can replace with , which turns out to be much faster. lookup[index] peek(tableaddr+index) But we can do even better! Our tables are exactly 256 bytes long, so if we keep them at “round” (0x??00) addresses, we can get away with using bitwise OR ( on PICO-8) in place of addition, taking advantage of that operation being even quicker. bor() After all is said and done, our loop now looks like this: for screenaddr=start,end dopoke(screenaddr,peek( ))end bor(lutaddr,peek(screenaddr)) Sure doesn’t like an improvement, but it’s not the first time optimization made something ugly. look Against all odds We’ve got our filter working at ludicrous speeds, but as usual, there is one more problem. Screen coordinates are like people — about half of them are odd. When the line segment we want to draw starts or ends at an odd X coordinate, we can’t change the entire byte — we have to carefully change only the part describing the left (or right) pixel. We could handle this inside the loop, but adding conditionals to the most-often repeated piece of code is right at the top of the list of big optimization no-no’s. This is why we handle the thorny stuff outside the main loop, carefully using bitwise operations to change only one half of the byte: start = local addr = start-1local previous = peek(addr)poke(addr, bor(band(previous, 0xf),band( , 0xf0))) address of first full byte of our line if x1 is odd: <LUT[v]> Similar handling is done for as well (but the unfortunate case is when is even). The real code has some extra magic in the condition in order to handle fractional coordinates as well, but the principle is the same. x2 x2 End of the line That’s the end of part 1. We are now able to darken a single horizontal line segment, which probably isn’t enough to impress people at parties yet. But have no fear! The next post will be all about taking our horizontal line routine and putting the effect together. So, if you’re in the mood for more mad science, stay tuned for and look for it on or on the . Let me know if you liked this part, and if you have any questions, feel free to tweet at me. part 2 my Twitter lexaloffle.com forums Until then, have fun hacking on the PICO-8! Part 1 | Part 2 | Part 3 | Part 4 | Play the game

Stories, News & Mentions about PGE

Pge’s Stories on HackerNoon

Pge's News & Mentions