DEV Community: Luiz Lopes

DeFi Connected — Terra Hackathon

Luiz Lopes — Mon, 19 Apr 2021 22:42:28 +0000

DeFi isn’t rebuilding finance, it’s dismantling it. In its place, we build something so powerful it’ll change humanity’s fate. We are IDEO Colab Ventures, Delphi Labs and Terra. We want to join forces with YOU.

Join our 48h Terra Hackathon; lets build the next gen of DeFi together.

What you get as a participant

Access to Delphi Labs big brain support
IDEO product design tutorship
A chance to join our incubation program — with further access to funding and support from both Delphi Labs and IDEO Colab. Our team is working 24/7 helping to unlock the potential of DeFi.

IDEO Colab Ventures and Delphi Labs are investors & supporters of many disruptive teams, including:

We see the walls to mainstream adoption. And we want to incubate builders to break them down. That’s why we chose to join forces with Terra and Do Kwon.

They're solving many of the hardest problems in crypto:

On-ramps
Accessible UI
Developer on-boarding tools with Terra projects like Saturn, Alice, and Anchor.

So what actually will happen in the initial 48h event?

Delphi Labs and IDEO experts will lead your early-stage team through a design research sprint, as you talk to real end users and collaborate with peers, experts, and mentors in the DeFi community.
A small number of the most promising teams will be invited to the full 11-week residency. During this time each team will be assigned a senior member of Delphi Labs or IDEO as a mentor and have regular sessions with the wider team to share progress, get guidance and feedback.
At the end of the residency we expect that one or more of the projects will be offered full incubation. Allowing us to fund the projects from IDEO VC, Delphi Ventures and Delphi Labs while also providing deeper UI/visual design, token econ and hiring support.

What to get involved?

Submit your 1-minute application by Tuesday, April 27, 2021 at 00:00 (GMT+3).
We do not care where you are, or where you’ve been.We care about what you dream of building
Apply here: https://eventornado.com/event/defi-connected

Original Twitter 🧵: https://twitter.com/IDEOVC/status/1377377343421833220

Looking for ideas?

José Maria Macedo from Delphi Labs composed a wish-list of ideas that no one is yet building on Terra.

The Case For Expression Reduction

Luiz Lopes — Mon, 20 Apr 2020 15:30:47 +0000

This article was originally posted at wickeddeveloper.com.

As a software developer you will inevitably have to debug some piece of code you wrote months if not years ago, or code from a colleague that is no longer part of your team. As you step through some routine you notice an array of conditional statements with complicated conditional expressions. As you search for the bug in the code you'll end up noticing that you can't hold all of the values in your head. You can no longer remember what a particular value means or what it points to.

I have found that creating boolean variables that hold the value of an expensive or complicated expression makes it easier to read and understand code.

Let's look at a trivial piece of code, written in JavaScript, and see how assigning complex conditions to a variable makes it much easier to understand and read the code. Keep in mind this code is not something you'd use in production, I'm only using this to illustrate the point.

Suppose there is a function that takes an argument called drink and inside of this function we check what type of drink it is and return an emoji of a coffee, tea, or milk.

/* Assume COFFEE, CAFE, LATE, MOCHA, TEA, etc are imported into this module. */

function getDrinkEmoji(drink) {
    if (drink === COFFEE || 
        drink === CAFE || 
        drink === LATE || 
        drink === MOCHA) {
        return '☕';
    } else if (drink === TEA || 
               drink === BLACK_TEA || 
               drink === GREEN_TEA || 
               drink === OOLONG_TEA) {
        return '🍵';
    } else {
        return '🥛';
    }
}

Reading through code like that requires you to hold quite a lot in your head.

Now let's look at the same code but having assigned the expression to a variable.

function getDrinkEmoji(drink) {
    const isCoffee = drink === COFFEE || 
                     drink === CAFE || 
                     drink === LATE || 
                     drink === MOCHA;
    const isTea = drink === TEA || 
                  drink === BLACK_TEA || 
                  drink === GREEN_TEA || 
                  drink === OOLONG_TEA;

    if (isCoffee) {
        return '☕';
    } else if (isTea) {
        return '🍵';
    } else {
        return '🥛';
    }
}

Here we can more quickly understand what the expressions inside of the if and else if are evaluating to.

📌 You may also prefix your variables with words like has, should, was, etc.

This pattern makes a lot of sense when you find yourself evaluating the condition multiple times. When you do it once you can just reference the variable again when you need it.

In this next example, our function receives an array of drinks, we use the Array.some method to test whether the drinks include a coffee or a tea and then return an emoji.

function getDrinksEmoji(drinks) {
    const hasCoffee = drinks.some(drink => drink === COFFEE || 
                                           drink === CAFE || 
                                           drink === LATE || 
                                           drink === MOCHA);
    const hasTea = drinks.some(drink => drink === TEA ||
                                        drink === BLACK_TEA || 
                                        drink === GREEN_TEA || 
                                        drink === OOLONG_TEA);
    const hasCoffeeAndTea = hasCoffee && hasTea;

    if (hasCoffeeAndTea) {
        return '☕ + 🍵';
    } else if (hasCoffee) {
        return '☕';
    } else if (hasTea) {
        return '🍵';
    } else {
        return '🥛';
    }
}

We had to execute the expensive computation of testing if the drinks include a coffee or tea once, we referenced that expression multiple times in our code without additional performance penalty, and the code is still easy to read and understand.

Conclusion

Conditional statements are an invaluable tools in software development, they provide us with flow control to determine the output of our programs. You'll inevitably run across them when writing and reading code. If you are the author of the code, or reading code that you have control over, do yourself a favor and assign your expensive and complicated condition statements to variables with meaningful names. Doing so will free up space in your head and your code will be much easier to read and understand.

Links

Thanks to Greg Timmerman, and @nicholascloud for reading a previous version of this post. @nicholascloud also gave this pattern a name (expression reduction).

Easy Way To Find Weekday From a Given Date String

Luiz Lopes — Thu, 30 May 2019 22:17:33 +0000

I've recently been introduced to the Intl object, which is used as the namespace for the ECMAScript Internationalization API. It has a neat object called DateTimeFormat which can be used to format a date value into locale specific strings.

I'll show you a typical use case for using Intl.DateTimeFormat to generate the weekday of a given date string (e.g. 07/16/1945).

Problem

Given a dateString in the format MM/DD/YYYY, find and return the weekday for that date.

Solution

/**
 * Given a date string in the format MM/DD/YYY, find and return the 
 * weekday for that date in English.
 *
 * @param {string} dateString
 * @returns {string} - weekday for the given date [e.g: Wednesday]
 */
const getWeekDay = (dateString) => {
  const date = new Date(dateString);
  const dateTimeFormatOptions = { weekday: 'long' };
  const dateTimeFormat = new Intl.DateTimeFormat('en-US', dateTimeFormatOptions); 
  return dateTimeFormat.format(date);
}

Explanation

Create a function expression called getWeekDay which takes a string (dateString).
Create a Date object with the given dateString, so that we can pass it as a parameter into the format method of DateTimeFormat.
Create an object to hold the options parameter for Intl.DateTimeFormat. Setting the weekday property equals to long, so that we get the localized weekday when calling format.
Create a an instance of Intl.DateTimeFormat setting locales to en-US, and passing in the previously created dateTimeFormatOptions object.
Return the result of calling format method on Intl.DateTimeFormat to find the weekday for the given date.

Output

console.log(getWeekDay("07/16/1945"));
// expected output: "Monday"

In closing, we used the Intl.DateTimeFormat object to quickly find the weekday of a given date string. Best of all Intl has great support across modern browser.

Thank you for reading.