You can pay a tiny amount for the tablet now and receive a bigger discount. The OnePlus Pad Go is an affordable tablet that was released in some markets...

OnePlus Pad Go lands in Europe on April 23 alongside new OnePlus Watch 2 version - GSMArena.com news

It&#x27;s rumored to launch in H2 2024. Last week, tipster Max Jambor claimed the OnePlus Pad 2 will be launched in the second half of 2024, which, he now says,...

OnePlus Pad 2's processor tipped - GSMArena.com news

MOBILES &amp; TABLETS News: OnePlus introducing the 8GB RAM Solar Red OnePlus 11R in India with Rs 1250 instant discount on Amazon. This model offers a 6.74-inch AMOLED display,

OnePlus 11R Solar Red colour Variant with 8GB RAM to launch in India on April 18: All details - Times of India

Check out a detailed camera comparison of the Rs 24,999-worth OnePlus Nord CE4 and Rs 23,999-worth Rs OPPO F25 Pro.

OnePlus Nord CE4 vs OPPO F25 Pro camera comparison

South Indian Organised Retailers Association (ORA), in its April 10 letter to OnePlus India’s director of sales, Ranjeet Singh, threatened to discontinue the sale the brand’s products in 4,500 stores across Southern and Western states

OnePlus reacts to Indian retailers' boycott threat, says working to resolve issues

Two organizations representing brick and mortar stores are not happy with how OnePlus has been treating their members. OnePlus has angered retailers in...

Retailers in India rebel against OnePlus, threaten sales ban - GSMArena.com news

OnePlus 11, the flagship phone from OnePlus in 2023, has received a price cut. OnePlus 11 a better phone than the OnePlus 12R.

OnePlus 11 5G Gets a Price Cut in India

This decision is estimated to impact around 4,500 stores from 23 retail chains across Andhra Pradesh, Telangana, Tamil Nadu, Karnataka, Maharashtra and Gujarat/

Offline Stores In 6 States To Stop Selling OnePlus Phones

OnePlus India faces major issue with offline retailers and now it could be out of over 150,000 stores in the country as AIMRA looks for a solution. Read more on News18.com

OnePlus India In Big Trouble, Faces Complete Blackout From Offline Sellers: Here’s The Story - News18

OnePlus 11 5G was launched in India in February 2023. The price of the model has now been reduced in the country. The phone is powered by a Qualcomm Snapdragon chipset and carries a 5,000mAh battery with SuperVOOC fast charging support. The handset is also equipped with the company&#x27;s HyperBoost ...

OnePlus 11 5G Receives Price Cut in India: Check How Much It Costs Now, Other Offers | Technology News

PlusOne

plusone

On our first set of data structures, we get into the definition and scope of non-primitive structures. Have a look at the previous read on in case you feel a little lost. Right off the batt, we define what it means to be a non-primitive set, and how this can be further broken down. The Power of Data structures Let's get right into it. A non-primitive structure is what happens when you combine two or more primitives. What we mean is simple. A and , for instance,  are primitives. The simplest representations of data. char int Broadly speaking, linear non-primitives can be grouped further as below: Linear Non-Primitives Stacks Queues Linked lists Arrays Here, as stated before, data is sequential - one after another. Some of these structures might , stackify, is that you?. ring a bell Arrays These are what we call stores of homogeneous (meaning similar) data. So one might have an array like this: my_array = [ , , , , , , , , ] ;

vowels = [ , , , , ] ; 1 2 3 4 5 6 7 8 9 ' a' 'e' 'i' 'o' 'u' Note how has only integers while has . In both instances, our array has a collection of primitives - . my_array vowels char one type of primitive per array Arrays are of a fixed size. Once declared, the computer knows the amount of memory reserved for items to be stored there.  You might ask: "But what if the type of data I have changes in size greater than the array?" Well, you might need to consider a different type of structure to store this data. Use arrays, for instance, to store months of the year. We will not be changing this count anytime. Above declared, the sizes of the arrays are inferred. Meaning the types, since not defined per se, are  'figured out' based on the values and how we use them. We might as well have this: For python. array

count_down = array.array( , [ , , , , ]) import 'i' 5 4 3 2 1 # where *i* stands for int (an array of integers). Types may go on as: for c char for f float for d double for and so forth. u Unicode Have a look at the for more insight into this. As well, take note that the has different functions to enable array manipulation. documentation array module Rust: count_down: [ ; ] = [ , , , , ]; let i32 5 5 4 3 2 1 // where *i32* is signed integers, and *5* in *[i32; 5]* is the size of the array. i.e have five integers Important pointer: Python lists and arrays are not the same! Operations on an array will be based on the of the array element, with indexing starting from . Hence, the first item, in either case, would be: index 0 count_down [0] The result from the above is 5 (the semi-colon has been left out for brevity but should be used based on the language you are using). Let's take a look at another structure that looks similar, but is not the same - Linked lists. Linked lists Unlike arrays, linked lists store data in a non-contiguous form. This implies one piece of data is not placed side by side to the other as: `[1,2,3,4,5]`, rather it is stored in form of nodes with pointers to the next as so: [data1, pointer_to_data2] ...  [data1, pointer_to_data3] ... so and on The last item in our linked list, since there is no pointer to the next, would have . null As well, linked lists are dynamic-  their size is not fixed at initialization. Linked lists will be further broken to: a) Singular linked lists (used in the elaboration of linked lists above) b) Circular linked lists c) Doubly linked lists Circular Linked Lists These have three items in a node: the previous data, the data, and finally, the next data in the sequence. ... [null, data1, pointer_to_data2] [pointer_to_data_1 ,data1, pointer_to_data3] The first item (the head), has a as the previous pointer while the last node has on the next pointer. null null Doubly linked lists Similar to circular linked lists, these have two pointers as well. The only difference would be the last node, instead of a , has a pointer back to the first item in the list. 1 + 1 = circular. null In most of what we implement through code, we have implementations of linked lists. You will hardly get yourself doing this manually, but understanding that some of the things we call 'mutable arrays ' are actually implementations or wrappers around more complex structures. Example: If navigating through my directory, my computer needs to know where I am, where I'm from, and possibly have the correct link/structure to the nested directory I'm navigating to. So to the top-level directory, I cannot go any higher, no previous node. Likewise to the last directory or file, there is no 'next' option. Till now, we have come to understand the importance of data structures, the groups they have been placed into, and we have an idea of what some of the linear data structures involved. We could go on and on on the details of each, but that is a tale for another day. A breather for us both at this point.  Go read something non-algorithm-like for a moment. We'll still meet here, same time, the same drive. Previously published at: https://thegreencodes.com/data-structures-the-linear-non-primitives

Representations of Data: One Primitive Plus One Primitive Equals Linear Non-Primitives

Hello 👋 How often have you wished for a method that doesn't exist on collections or string helpers? You start chaining methods, only to hit a wall when one of them turns out to be missing. Honestly, it's understandable; frameworks, you know, are a one-size-fits-all thing. I found myself in this situation multiple times. Every time, before diving into how to extend the framework, I check to see if what I want to extend is macroable or not. But what does that mean? That's exactly what we'll be exploring! WTF Are Macros? 🍏 Let's say we have this JWT: $jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'; And we need to extract the headers: str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); // does not exist 😞

//  BadMethodCallException  Method Illuminate\Support\Stringable::fromJson does not exist. The fromJson() doesn't exist 😔 Sure, one could simply do: json_decode(str($jwt)->before('.')->fromBase64()); But where's the fun in that? Plus, it is my article 🤷 So, we need a way to extend the Stringable class. There are a few ways to do this, but Laravel thought ahead, it knew that developers might want to add custom methods, so it made the class macroable, or as I like to call it, extendable. If you inspect the Illuminate\Support\Stringable class, you'll see it uses a Macroable trait. Let's go ahead and extend the class. In the AppServiceProvider, add the following: <?php

namespace App\Providers;

use Illuminate\Support\Stringable;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Stringable::macro('fromJson', function (bool $associative = true) {
            return json_decode($this->value, $associative);
        });
    }
} Now, let's rerun the code: str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson();

// ["alg" => "HS256", "typ" => "JWT"] It works perfectly 🎉 But now, you might be wondering, how did this work? And what exactly is $this->value? What in the Harry Potter is going on? Unveiling the Magic 🪄 We know that the Stringable class uses the Macroable trait, which provides the macro() method. Let's take a closer look at what it does: // src/Illuminate/Macroable/Traits/Macroable.php

/**
 * Register a custom macro.
 *
 * @param  string  $name
 * @param  object|callable  $macro
 *
 * @param-closure-this static  $macro
 *
 * @return void
 */
public static function macro($name, $macro)
{
    static::$macros[$name] = $macro;
} It's pretty straightforward; it just saves the callback to a static macros array. Now, if we inspect the trait further, we will find the __call method, which is triggered every time a non-existent method is called. In our case, that's fromJson(). Let's dive in: /**
 * Dynamically handle calls to the class.
 *
 * @param  string  $method
 * @param  array  $parameters
 * @return mixed
 *
 * @throws \BadMethodCallException
 */
public function __call($method, $parameters)
{
    if (! static::hasMacro($method)) {
        throw new BadMethodCallException(sprintf(
            'Method %s::%s does not exist.', static::class, $method
        ));
    }

    $macro = static::$macros[$method];

    if ($macro instanceof Closure) {
        $macro = $macro->bindTo($this, static::class);
    }

    return $macro(...$parameters);
} First, it checks if a macro is registered, which is the case with fromJson(), it then fetches the callback (or object) from the macros array. Now, for the magic trick; if the macro is a closure (as in our case), it calls bindTo() which essentially tells the closure that $this should refer to whatever is passed as the first argument. In this case, it is the Stringable instance, which happens to have the $value attribute. // $this here is the stringable
// $this inside the closure is now referencing the stringable class
$macro->bindTo($this, static::class); And this is why we can do $this->value. We Can Do Better: Mixins 🧩 There is one more thing I want to show you! When we extend the same class a couple of times, the service provider might get messy very quickly. We can extract all our custom macros to a class called a Mixin. Let's create a StringableMixin: <?php

namespace App\Macros;

use Closure;

class StringableMixin
{
    public function fromJson(): Closure
    {
        return function (bool $associative = true) {
            json_decode($this->value, $associative);
        };
    }

    // Add more macros here as needed
} Now, in AppServiceProvider, we can register this mixin: use App\Macros\StringableMixin;
use Illuminate\Support\Stringable;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Stringable::mixin(new StringableMixin);
    }
} And that's it! Now, we can do: str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); Which is basically the same, just a bit cleaner. If you are curious about how this works, the mixin() method on the Macroable trait uses the reflection API. It retrieves all the public methods from the Mixin class, expects each to return a closure, and then registers the closure as a macro just like we have seen earlier. The Poor IDE 🥲 Well, as you have seen, there is a lot of magic going on, and the IDE wouldn't know about the defined macros. If you're working within a team, other developers won't know about these macros either, which is not good. Luckily, there are tools to help you with that. A free and open-source option is the Laravel IDE helper package. You can install the package and generate the _ide_helper.php file, and you should be good to go. And So It Ends.. Our example is fairly simple, but you can push macros much further than this, as most of the common classes Laravel ships with are macroable. For instance, you can add a new apiResponse() macro, or anything that you feel is very common in your app's logic and is being repeated more than it should be. But don't overdo it. Macros add a new layer of complexity, and when working in a team, they could be confusing. So, whenever you feel something is missing from your application, but not from the framework itself, use macros 🪄 Hello 👋 How often have you wished for a method that doesn't exist on collections or string helpers? You start chaining methods, only to hit a wall when one of them turns out to be missing. Honestly, it's understandable; frameworks, you know, are a one-size-fits-all thing. I found myself in this situation multiple times. Every time, before diving into how to extend the framework, I check to see if what I want to extend is macroable or not. But what does that mean? That's exactly what we'll be exploring! macroable WTF Are Macros? 🍏 Let's say we have this JWT: $jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'; $jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'; And we need to extract the headers: str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); // does not exist 😞

//  BadMethodCallException  Method Illuminate\Support\Stringable::fromJson does not exist. str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); // does not exist 😞

//  BadMethodCallException  Method Illuminate\Support\Stringable::fromJson does not exist. The fromJson() doesn't exist 😔 Sure, one could simply do: fromJson() json_decode(str($jwt)->before('.')->fromBase64()); json_decode(str($jwt)->before('.')->fromBase64()); But where's the fun in that? Plus, it is my article 🤷 So, we need a way to extend the Stringable class. There are a few ways to do this, but Laravel thought ahead, it knew that developers might want to add custom methods, so it made the class macroable , or as I like to call it, extendable. Stringable macroable If you inspect the Illuminate\Support\Stringable class, you'll see it uses a Macroable trait. If you inspect the Illuminate\Support\Stringable class, you'll see it uses a Macroable trait. Illuminate\Support\Stringable Macroable Let's go ahead and extend the class. In the AppServiceProvider , add the following: AppServiceProvider <?php

namespace App\Providers;

use Illuminate\Support\Stringable;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Stringable::macro('fromJson', function (bool $associative = true) {
            return json_decode($this->value, $associative);
        });
    }
} <?php

namespace App\Providers;

use Illuminate\Support\Stringable;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Stringable::macro('fromJson', function (bool $associative = true) {
            return json_decode($this->value, $associative);
        });
    }
} Now, let's rerun the code: str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson();

// ["alg" => "HS256", "typ" => "JWT"] str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson();

// ["alg" => "HS256", "typ" => "JWT"] It works perfectly 🎉 But now, you might be wondering, how did this work? And what exactly is $this->value ? What in the Harry Potter is going on? $this->value Unveiling the Magic 🪄 We know that the Stringable class uses the Macroable trait, which provides the macro() method. Let's take a closer look at what it does: Stringable Macroable macro() // src/Illuminate/Macroable/Traits/Macroable.php

/**
 * Register a custom macro.
 *
 * @param  string  $name
 * @param  object|callable  $macro
 *
 * @param-closure-this static  $macro
 *
 * @return void
 */
public static function macro($name, $macro)
{
    static::$macros[$name] = $macro;
} // src/Illuminate/Macroable/Traits/Macroable.php

/**
 * Register a custom macro.
 *
 * @param  string  $name
 * @param  object|callable  $macro
 *
 * @param-closure-this static  $macro
 *
 * @return void
 */
public static function macro($name, $macro)
{
    static::$macros[$name] = $macro;
} It's pretty straightforward; it just saves the callback to a static macros array. Now, if we inspect the trait further, we will find the __call method, which is triggered every time a non-existent method is called. In our case, that's fromJson() . Let's dive in: macros __call fromJson() /**
 * Dynamically handle calls to the class.
 *
 * @param  string  $method
 * @param  array  $parameters
 * @return mixed
 *
 * @throws \BadMethodCallException
 */
public function __call($method, $parameters)
{
    if (! static::hasMacro($method)) {
        throw new BadMethodCallException(sprintf(
            'Method %s::%s does not exist.', static::class, $method
        ));
    }

    $macro = static::$macros[$method];

    if ($macro instanceof Closure) {
        $macro = $macro->bindTo($this, static::class);
    }

    return $macro(...$parameters);
} /**
 * Dynamically handle calls to the class.
 *
 * @param  string  $method
 * @param  array  $parameters
 * @return mixed
 *
 * @throws \BadMethodCallException
 */
public function __call($method, $parameters)
{
    if (! static::hasMacro($method)) {
        throw new BadMethodCallException(sprintf(
            'Method %s::%s does not exist.', static::class, $method
        ));
    }

    $macro = static::$macros[$method];

    if ($macro instanceof Closure) {
        $macro = $macro->bindTo($this, static::class);
    }

    return $macro(...$parameters);
} First, it checks if a macro is registered, which is the case with fromJson() , it then fetches the callback (or object) from the macros array. Now, for the magic trick; if the macro is a closure (as in our case), it calls bindTo() which essentially tells the closure that $this should refer to whatever is passed as the first argument. In this case, it is the Stringable instance, which happens to have the $value attribute. fromJson() bindTo() $this Stringable $value // $this here is the stringable
// $this inside the closure is now referencing the stringable class
$macro->bindTo($this, static::class); // $this here is the stringable
// $this inside the closure is now referencing the stringable class
$macro->bindTo($this, static::class); And this is why we can do $this->value . $this->value We Can Do Better: Mixins 🧩 There is one more thing I want to show you! When we extend the same class a couple of times, the service provider might get messy very quickly. We can extract all our custom macros to a class called a Mixin. Let's create a StringableMixin : StringableMixin <?php

namespace App\Macros;

use Closure;

class StringableMixin
{
    public function fromJson(): Closure
    {
        return function (bool $associative = true) {
            json_decode($this->value, $associative);
        };
    }

    // Add more macros here as needed
} <?php

namespace App\Macros;

use Closure;

class StringableMixin
{
    public function fromJson(): Closure
    {
        return function (bool $associative = true) {
            json_decode($this->value, $associative);
        };
    }

    // Add more macros here as needed
} Now, in AppServiceProvider , we can register this mixin: AppServiceProvider use App\Macros\StringableMixin;
use Illuminate\Support\Stringable;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Stringable::mixin(new StringableMixin);
    }
} use App\Macros\StringableMixin;
use Illuminate\Support\Stringable;

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Stringable::mixin(new StringableMixin);
    }
} And that's it! Now, we can do: str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); str($jwt)
    ->before('.')
    ->fromBase64()
    ->fromJson(); Which is basically the same, just a bit cleaner. Which is basically the same, just a bit cleaner. If you are curious about how this works, the mixin() method on the Macroable trait uses the reflection API . It retrieves all the public methods from the Mixin class, expects each to return a closure, and then registers the closure as a macro just like we have seen earlier. mixin() Macroable reflection API The Poor IDE 🥲 Well, as you have seen, there is a lot of magic going on, and the IDE wouldn't know about the defined macros. If you're working within a team, other developers won't know about these macros either, which is not good. Luckily, there are tools to help you with that. A free and open-source option is the Laravel IDE helper package. Laravel IDE helper You can install the package and generate the _ide_helper.php file, and you should be good to go. _ide_helper.php And So It Ends.. Our example is fairly simple, but you can push macros much further than this, as most of the common classes Laravel ships with are macroable. For instance, you can add a new apiResponse() macro, or anything that you feel is very common in your app's logic and is being repeated more than it should be. But don't overdo it. Macros add a new layer of complexity, and when working in a team, they could be confusing. apiResponse() So, whenever you feel something is missing from your application, but not from the framework itself, use macros 🪄

Laravel Under The Hood - The Magic of Macros

On October 14, 2018, I published my first story on HackerNoon. Six years and 126 stories later I look back at my words through the lenses of numbers, first. Words written: 122,410 “Sense and Sensibility” by Jane Austen has 119,394 words written. I can export all of my stories as PDFs in one document. I’m thinking about “Nonsense & Hypersensibility,” as the most appropriate title. TOTAL READING TIME GENERATED: 569,700 minutes I’m like 200,000 minutes short of the time required to walk the full length of the Great Wall of China. AWARDS (The Magnificent Seven plus One, better than Hateful Eight, LOL) 2020 The Winner of the HackerNoon Award “Noonies2020” for the Most Controversial Writer of the Year. 2021 The Winner of the HackerNoon Award “Noonies2021” for the Critical Thinker of the Year. 2022 The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- FREELANCING. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- ELON MUSK. The Winner of the HackerNoon Award “Noonies2022” for the Critical Thinker of the Year. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- GAMING-INDUSTRY. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- MICROSOFT. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- INTERNET-CENSORSHIP. The Writing Contest Awards The Cybersecurity Writing Contest, July 2022: the 3rd place The Linux Writing Contest, September 2022: the 2nd place The Defi Writing Contest, November 2022: the 2nd place The Decentralize-AI Writing Contest, October 2024: the 1st place Six Stories for Six Birthday Candles 2018 - Two Years an Upwork Slave: How to Own Freelancers and Sue Those You Can’t Own 2019 - Why I Choose HackerNoon Over Medium 2020 - Is Upwork Posting Fake Jobs To Keep Freelancers Bidding? [A Deep Dive] 2021 - A Requiem for John David McAfee 2022 - Alexa dot com is DEAD: F*CK the Alternatives! 2023 - Why I Turned Down an 'HR for Happiness' Role in a Top Software Company 2024 - Breaking The UStatus Quo: Between Elon Musk's Terminus and Lex Fridman's Empire Romanus My Top Six Memorable HackerNoon Moments #6 When my 100th story got published on HackerNoon: #5 When I got my first HackerNoon merch, a T-shirt: #4 When I framed and hung pictures of my first HackerNoon Top Stories: #3 When I stumbled upon my story in some other language than English (I sure hope I’m not mistaken, lol): #2 When I got my first Noonie Writing Award: #1 When I shared the most supportive tweet: That’s all HackerNoon folks, until my next writer’s Bday or notable writing milestone. I don’t have places to be, but I have new stories to write. On October 14, 2018, I published my first story on HackerNoon. Six years and 126 stories later I look back at my words through the lenses of numbers, first. Words written: 122,410 “Sense and Sensibility” by Jane Austen has 119,394 words written. I can export all of my stories as PDFs in one document. I’m thinking about “Nonsense & Hypersensibility,” as the most appropriate title. TOTAL READING TIME GENERATED: 569,700 minutes I’m like 200,000 minutes short of the time required to walk the full length of the Great Wall of China. AWARDS (The Magnificent Seven plus One, better than Hateful Eight, LOL) 2020 2020 The Winner of the HackerNoon Award “Noonies2020” for the Most Controversial Writer of the Year. 2021 2021 The Winner of the HackerNoon Award “Noonies2021” for the Critical Thinker of the Year. 2022 2022 The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- FREELANCING. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- ELON MUSK. The Winner of the HackerNoon Award “Noonies2022” for the Critical Thinker of the Year. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- GAMING-INDUSTRY. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- MICROSOFT. The Winner of the HackerNoon Award “Noonies2022” for the Contributor of the Year- INTERNET-CENSORSHIP. The Writing Contest Awards The Cybersecurity Writing Contest, July 2022: the 3rd place The Linux Writing Contest, September 2022: the 2nd place The Defi Writing Contest, November 2022: the 2nd place The Decentralize-AI Writing Contest, October 2024: the 1st place Six Stories for Six Birthday Candles 2018 - Two Years an Upwork Slave: How to Own Freelancers and Sue Those You Can’t Own Two Years an Upwork Slave: How to Own Freelancers and Sue Those You Can’t Own 2019 - Why I Choose HackerNoon Over Medium Why I Choose HackerNoon Over Medium 2020 - Is Upwork Posting Fake Jobs To Keep Freelancers Bidding? [A Deep Dive] Is Upwork Posting Fake Jobs To Keep Freelancers Bidding? 2021 - A Requiem for John David McAfee A Requiem for John David McAfee 2022 - Alexa dot com is DEAD: F*CK the Alternatives! Alexa dot com is DEAD: F*CK the Alternatives! 2023 - Why I Turned Down an 'HR for Happiness' Role in a Top Software Company Why I Turned Down an 'HR for Happiness' Role in a Top Software Company 2024 - Breaking The UStatus Quo: Between Elon Musk's Terminus and Lex Fridman's Empire Romanus Breaking The UStatus Quo: Between Elon Musk's Terminus and Lex Fridman's Empire Romanus My Top Six Memorable HackerNoon Moments #6 When my 100th story got published on HackerNoon: #6 #5 When I got my first HackerNoon merch, a T-shirt: #5 #4 When I framed and hung pictures of my first HackerNoon Top Stories: #4 #3 When I stumbled upon my story in some other language than English (I sure hope I’m not mistaken, lol): #3 #2 When I got my first Noonie Writing Award: #2 #1 When I shared the most supportive tweet: #1 That’s all HackerNoon folks, until my next writer’s Bday or notable writing milestone. I don’t have places to be, but I have new stories to write.

My Six Years of Writing on HackerNoon in Numbers and Pictures

በ HackerNoon ላይ የኔ የስድስት አመታት ፅሁፍ በቁጥር እና በፎቶ

Mých šest let psaní na HackerNoon v číslech a obrázcích

Mis seis años de escritura en HackerNoon en números e imágenes

Os meus seis anos de escritura en HackerNoon en números e imaxes

हैकरनून पर मेरे छह साल के लेखन का विवरण संख्याओं और चित्रों में

HackerNoon-ում գրելու իմ վեց տարիները թվերով և նկարներով

HackerNoon で私が執筆した 6 年間を数字と写真で振り返る

Lixdii sano ee aan wax ku qori jiray HackerNoon ee Tirooyinka iyo Sawirrada

எண்கள் மற்றும் படங்களில் ஹேக்கர்நூனில் எனது ஆறு வருட எழுத்து

Шаш соли навиштани ман дар HackerNoon дар рақамҳо ва расмҳо

Alty ýyllyk “HackerNoon” -da sanlar we suratlar

HackerNoon'da Altı Yıldır Yazdıklarım Rakamlarla ve Resimlerle

United States of America v. Google LLC., Court Filing, retrieved on April 30, 2024, is part of HackerNoon’s Legal PDF Series. You can jump to any part of this filing here. This part is 9 of 37. D. Search Access Points 1. A Search Access Point Is Where A Desktop Or Mobile-Device User Can Enter A Query 146. A search access point is any place on a device where a user enters a search query. Tr. 323:11-19 (Barton (Google)); Des. Tr. 44:5-8 (Google-NF 30(b)(6) Dep.); Tr. 1027:23-25 (Higgins (Verizon)) (search entry points are “different mechanisms for you to access search on the device"). 2. Search Access Points On Desktop 147. Desktop browsers allow users to view websites, including GSEs. Tr. 7642:13–17 (Pichai (Google)) (in 2004, browser users could “navigate to Yahoo.com or Google.com or whatever your choice was"). Desktop browsers direct queries entered into the address bar to a GSE. Des. Tr. 211:16–212:5 (Google-RG2 30(b)(6) Dep.) (queries entered into a browser's address bar are conducting “default search”); Tr. 700:12–701:2 (Rangel (Pls. Expert)) (discussing DXD-01 at .001–04 and showing general search being conducted from an address bar in Safari on desktop). In the past, toolbars, or plug-ins for different browsers, were another method by which consumers could access GSEs (and by which Google could track general search market share). Tr. 7642:2–12 (Pichai (Google)) (“Google Toolbar was a way by which, in those days in browsers, you could add an extension . . . a search box . . . it provided users a convenient way to search Google”); Tr. 201:2–6 (Varian (Google)). The advent of built-in search boxes on browsers rendered downloadable tool bars obsolete. Tr. 7676:16–7677:19 (Pichai (Google)) (toolbar was developed when there was no built-in browser search box); Tr. 201:4–8 (Varian (Google)) (toolbars are “no longer popular”). 3. Search Access Points On Mobile 148. The number of search access points on mobile has grown over time. Des. Tr. 71:8–19, 72:4–20 (Ezell (AT&T) Dep.) (search access points include search widgets, browser search, and voice search); Tr. 3714:3–11 (Nadella (Microsoft)) (“search access point[s]” are “the places where people get to a search engine” and have “changed over time and have multiplied”); UPX0581 at -625. 149. Market participants have developed a lexicon to describe the geography of mobile devices and places where app icons and widgets, including ones containing search access points, can be placed. Des. Tr. 65:19–68:15 (Ezell (AT&T) Dep.) (describing terms such as the hot seat, minus one screen, plus one and plus two screens, and application tray). The default home screen is the screen users sees after unlocking a mobile device or pressing the home button. Tr. 790:22– 791:2, 805:25–806:2 (Kolotouros (Google)). The plus one screen refers to the screen to the right of the default home screen, i.e., the screen a user navigates to by swiping from right to left from the default home screen. Id. 947:23–948:8. The minus one screen refers to the screen to the left of the default home screen, i.e., the screen a user navigates to by swiping from left to right from the default home screen. Tr. 3123:1–12 (Tinter (Microsoft)); Des. Tr. 42:2–17 (Giard (T-Mobile) Dep.). 150. The hot seat or application dock on a mobile device refers to the bottom row of apps that a user can access quickly and that persist when swiping to the right or left. Tr. 923:8– 23 (Kolotorous (Google)). a) Mobile Browsers 151. Mobile browsers are preinstalled on virtually all mobile devices distributed in the United States. Tr. 1518:17–19 (Yoo (Google)) (MADA requires Chrome to be pre-loaded on the device); Tr. 2454:11–16 (Cue) (Apple)) (Safari browser is preloaded onto Apple devices). 152. Mobile browsers contain preinstalled search access points (e.g., address bar, default homepage) set to default GSEs. Tr. 1518:17–21 (Yoo (Google)) (MADA requires Chrome with Google set as the default search engine); Tr. 795:15–17 (Kolotouros (Google)) (address bar on Chrome is a search access point); Tr. 1028:1–3 (Higgins (Verizon)) (a search bar in a browser is a search entry point). b) Search Apps 153. Search apps are applications that allow users to conduct searches and direct queries to a preset GSE. Tr.797:25–798:11 (Kolotouros (Google)) (the Google Search app directs a search query to Google through the same process as searching through Chrome.); Des. Tr. 55:16–19 (Ribas (Microsoft) Dep.) (Bing search app links to searches on Bing); Des. Tr. 142:20–25 (van der Kooi (Microsoft) Dep.) (a search app is an entry point that “can either be downloaded or that is the default on a third-party platform”). Search apps are search access points that can be preinstalled on a smartphone or other device. Tr. 323:11–19 (Barton (Google)) (The Google search app is one access point). The preset GSE in a search app generally cannot be changed by the user. Tr. 6066:17–21 (Whinston (Pls. Expert)) (a search widget is a manifestation of a search engine application with a convenient search entry box); Tr. 833:11–16 (Kolotouros (Google)) (the widget can be removed but the search itself cannot be changed). 154. The Google Search App—with Google set as the default GSE—is preinstalled on virtually all Android devices distributed in the United States. Tr. 1518:12–16 (Yoo (Google)) (MADA requires the Google search app to be preinstalled on the device); UPX0129 at -905 (MADA requires preinstallation of the Google search app). c) Search Widgets 155. Widgets are self-contained code that display a program, or a piece of a program, that is a shortcut to an application. Tr. 1029:6–12 (Higgins (Verizon)) (a search widget is “a small piece of software that sits on your device that allows access to search capability.”). Search widgets are search access points, directing queries to a preset GSE. Tr. 794:3–5, 795:8–14 (Kolotouros (Google)) (Google search widget is a search access point that must be set to Google search); Des. Tr. 98:1–10 (Christensen (Motorola) Dep.) (a search widget is “a common way to search” and home screen placement enhances accessibility of the widget); Tr. 559:9–13 (Rangel (Pls. Expert)) (the search widget “allows consumers to type a search there without having to open a browser; a search app and, by default, searches with Google”); Des. Tr. 143:2–23 (van der Kooi (Microsoft) Dep.) (the search default/search box is “already on the device and is staring you in the face”). The Google Search Widget is a visual representation of the Google search app in which users can enter queries. Tr. 791:3–7, 794:3–9 (Kolotouros (Google)) (explaining that the Google Search Widget is part of the GSA and that it is a search box users can enter questions in). The Google Search Widget is sometimes referred to as the QSB or quick search box. Tr. 796:16–19 (Kolotouros (Google)). 156. Google’s search widget is preinstalled across the home screen of all Android devices distributed in the United States. Tr. 18:1–4 (Sept. 19, 2023 sealed PM session) (Yoo (Google)) (the widget is part of the Google search app, which the MADA requires to be on the device); Tr. 815:9–22 (Kolotouros (Google)) (Google had not granted, any waivers, which would allow manufacturers to remove the widget from the home screen); Tr. 815:16–816:1 (Kolotouros (Google)) (not aware of any Samsung or Motorola device without a pre-installed Google Search Widget); Tr. 792:25–793:23 (Kolotouros (Google)) (discussing JX0049 and confirming that all MADAs require Google Search Widget placement on the default home screen). Tr. 3125:10– 3125:22 (Tinter (Microsoft)) (against Microsoft’s preference, Google widget appears on the home screen of the Microsoft Duo, a dual-screen Android smartphone); Des. Tr. 45:6–11 (Christensen (Motorola) Dep.) (all Motorola devices ship with the Google Search Widget on the default home screen). 157. Neither Android users nor Google’s counterparties like the search widget on the device’s home screen. UPX0128 at -546–47 (2016 Lockheimer (Google) email to Google chief business officer informing him that “[w]e’ve done UX research” confirming that “[u]sers generally are tired (visually) of our widget” and “OEMs are VERY tired (visually) of our widget . . . they feel like they don’t get to differentiate”). 4. Other Search Access Points 158. Other search access points, such as voice assistants and smart keyboards, have miniscule search volume. Tr. 3107:3–3108:19 (Tinter (Microsoft)) (Apple hoped to encourage use of the voice assistant and voice entry point but “in practice, that thesis did not play out as…there was not a significant user behavior shift” from searching in the browser to using Siri and Spotlight). Continue Reading Here. About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings.
This court case retrieved on April 30, 2024, storage.courtlistener is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. United States of America v. Google LLC., Court Filing, retrieved on April 30, 2024, is part of HackerNoon’s Legal PDF Series. You can jump to any part of this filing here. This part is 9 of 37. United States of America v. Google LLC., Court Filing, retrieved on April 30, 2024, is part of HackerNoon’s Legal PDF Series . You can jump to any part of this filing here . This part is 9 of 37. HackerNoon’s Legal PDF Series here D. Search Access Points 1. A Search Access Point Is Where A Desktop Or Mobile-Device User Can Enter A Query 1. A Search Access Point Is Where A Desktop Or Mobile-Device User Can Enter A Query 146. A search access point is any place on a device where a user enters a search query. Tr. 323:11-19 (Barton (Google)); Des. Tr. 44:5-8 (Google-NF 30(b)(6) Dep.); Tr. 1027:23-25 (Higgins (Verizon)) (search entry points are “different mechanisms for you to access search on the device"). 2. Search Access Points On Desktop 2. Search Access Points On Desktop 147. Desktop browsers allow users to view websites, including GSEs. Tr. 7642:13–17 (Pichai (Google)) (in 2004, browser users could “navigate to Yahoo.com or Google.com or whatever your choice was"). Desktop browsers direct queries entered into the address bar to a GSE. Des. Tr. 211:16–212:5 (Google-RG2 30(b)(6) Dep.) (queries entered into a browser's address bar are conducting “default search”); Tr. 700:12–701:2 (Rangel (Pls. Expert)) (discussing DXD-01 at .001–04 and showing general search being conducted from an address bar in Safari on desktop). In the past, toolbars, or plug-ins for different browsers, were another method by which consumers could access GSEs (and by which Google could track general search market share). Tr. 7642:2–12 (Pichai (Google)) (“Google Toolbar was a way by which, in those days in browsers, you could add an extension . . . a search box . . . it provided users a convenient way to search Google”); Tr. 201:2–6 (Varian (Google)). The advent of built-in search boxes on browsers rendered downloadable tool bars obsolete. Tr. 7676:16–7677:19 (Pichai (Google)) (toolbar was developed when there was no built-in browser search box); Tr. 201:4–8 (Varian (Google)) (toolbars are “no longer popular”). Yahoo.com Google.com 3. Search Access Points On Mobile 3. Search Access Points On Mobile 148. The number of search access points on mobile has grown over time. Des. Tr. 71:8–19, 72:4–20 (Ezell (AT&T) Dep.) (search access points include search widgets, browser search, and voice search); Tr. 3714:3–11 (Nadella (Microsoft)) (“search access point[s]” are “the places where people get to a search engine” and have “changed over time and have multiplied”); UPX0581 at -625. 149. Market participants have developed a lexicon to describe the geography of mobile devices and places where app icons and widgets, including ones containing search access points, can be placed. Des. Tr. 65:19–68:15 (Ezell (AT&T) Dep.) (describing terms such as the hot seat, minus one screen, plus one and plus two screens, and application tray). The default home screen is the screen users sees after unlocking a mobile device or pressing the home button. Tr. 790:22– 791:2, 805:25–806:2 (Kolotouros (Google)). The plus one screen refers to the screen to the right of the default home screen, i.e., the screen a user navigates to by swiping from right to left from the default home screen. Id. 947:23–948:8. The minus one screen refers to the screen to the left of the default home screen, i.e., the screen a user navigates to by swiping from left to right from the default home screen. Tr. 3123:1–12 (Tinter (Microsoft)); Des. Tr. 42:2–17 (Giard (T-Mobile) Dep.). 150. The hot seat or application dock on a mobile device refers to the bottom row of apps that a user can access quickly and that persist when swiping to the right or left. Tr. 923:8– 23 (Kolotorous (Google)). a) Mobile Browsers a) Mobile Browsers 151. Mobile browsers are preinstalled on virtually all mobile devices distributed in the United States. Tr. 1518:17–19 (Yoo (Google)) (MADA requires Chrome to be pre-loaded on the device); Tr. 2454:11–16 (Cue) (Apple)) (Safari browser is preloaded onto Apple devices). 152. Mobile browsers contain preinstalled search access points (e.g., address bar, default homepage) set to default GSEs. Tr. 1518:17–21 (Yoo (Google)) (MADA requires Chrome with Google set as the default search engine); Tr. 795:15–17 (Kolotouros (Google)) (address bar on Chrome is a search access point); Tr. 1028:1–3 (Higgins (Verizon)) (a search bar in a browser is a search entry point). b) Search Apps b) Search Apps 153. Search apps are applications that allow users to conduct searches and direct queries to a preset GSE. Tr.797:25–798:11 (Kolotouros (Google)) (the Google Search app directs a search query to Google through the same process as searching through Chrome.); Des. Tr. 55:16–19 (Ribas (Microsoft) Dep.) (Bing search app links to searches on Bing); Des. Tr. 142:20–25 (van der Kooi (Microsoft) Dep.) (a search app is an entry point that “can either be downloaded or that is the default on a third-party platform”). Search apps are search access points that can be preinstalled on a smartphone or other device. Tr. 323:11–19 (Barton (Google)) (The Google search app is one access point). The preset GSE in a search app generally cannot be changed by the user. Tr. 6066:17–21 (Whinston (Pls. Expert)) (a search widget is a manifestation of a search engine application with a convenient search entry box); Tr. 833:11–16 (Kolotouros (Google)) (the widget can be removed but the search itself cannot be changed). 154. The Google Search App—with Google set as the default GSE—is preinstalled on virtually all Android devices distributed in the United States. Tr. 1518:12–16 (Yoo (Google)) (MADA requires the Google search app to be preinstalled on the device); UPX0129 at -905 (MADA requires preinstallation of the Google search app). c) Search Widgets c) Search Widgets 155. Widgets are self-contained code that display a program, or a piece of a program, that is a shortcut to an application. Tr. 1029:6–12 (Higgins (Verizon)) (a search widget is “a small piece of software that sits on your device that allows access to search capability.”). Search widgets are search access points, directing queries to a preset GSE. Tr. 794:3–5, 795:8–14 (Kolotouros (Google)) (Google search widget is a search access point that must be set to Google search); Des. Tr. 98:1–10 (Christensen (Motorola) Dep.) (a search widget is “a common way to search” and home screen placement enhances accessibility of the widget); Tr. 559:9–13 (Rangel (Pls. Expert)) (the search widget “allows consumers to type a search there without having to open a browser; a search app and, by default, searches with Google”); Des. Tr. 143:2–23 (van der Kooi (Microsoft) Dep.) (the search default/search box is “already on the device and is staring you in the face”). The Google Search Widget is a visual representation of the Google search app in which users can enter queries. Tr. 791:3–7, 794:3–9 (Kolotouros (Google)) (explaining that the Google Search Widget is part of the GSA and that it is a search box users can enter questions in). The Google Search Widget is sometimes referred to as the QSB or quick search box. Tr. 796:16–19 (Kolotouros (Google)). 156. Google’s search widget is preinstalled across the home screen of all Android devices distributed in the United States. Tr. 18:1–4 (Sept. 19, 2023 sealed PM session) (Yoo (Google)) (the widget is part of the Google search app, which the MADA requires to be on the device); Tr. 815:9–22 (Kolotouros (Google)) (Google had not granted, any waivers, which would allow manufacturers to remove the widget from the home screen); Tr. 815:16–816:1 (Kolotouros (Google)) (not aware of any Samsung or Motorola device without a pre-installed Google Search Widget); Tr. 792:25–793:23 (Kolotouros (Google)) (discussing JX0049 and confirming that all MADAs require Google Search Widget placement on the default home screen). Tr. 3125:10– 3125:22 (Tinter (Microsoft)) (against Microsoft’s preference, Google widget appears on the home screen of the Microsoft Duo, a dual-screen Android smartphone); Des. Tr. 45:6–11 (Christensen (Motorola) Dep.) (all Motorola devices ship with the Google Search Widget on the default home screen). 157. Neither Android users nor Google’s counterparties like the search widget on the device’s home screen. UPX0128 at -546–47 (2016 Lockheimer (Google) email to Google chief business officer informing him that “[w]e’ve done UX research” confirming that “[u]sers generally are tired (visually) of our widget” and “OEMs are VERY tired (visually) of our widget . . . they feel like they don’t get to differentiate”). 4. Other Search Access Points 4. Other Search Access Points 158. Other search access points, such as voice assistants and smart keyboards, have miniscule search volume. Tr. 3107:3–3108:19 (Tinter (Microsoft)) (Apple hoped to encourage use of the voice assistant and voice entry point but “in practice, that thesis did not play out as…there was not a significant user behavior shift” from searching in the browser to using Siri and Spotlight). Continue Reading Here. Continue Reading Here . Here About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case retrieved on April 30, 2024, storage.courtlistener is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. About HackerNoon Legal PDF Series: We bring you the most important technical and insightful public domain court case filings. This court case retrieved on April 30, 2024, storage.courtlistener is part of the public domain. The court-created documents are works of the federal government, and under copyright law, are automatically placed in the public domain and may be shared without legal restriction. storage.courtlistener

What Are Search Access Points? Explaining How Google Works

Is Your Reporting Software WCAG Compliant? Make Data Accessible to Everyone with Practical Steps

One of the preparatory stages of design development for any project is always the stage where the basic rules are laid down. Depending on the scale of the project, these may be some guidelines (if it is a small project involving one designer, such as a landing page), or large-scale design systems that combine several interfaces, in the work with which a group of designers participates. Regardless of the project, implementing these rules allows you to achieve consistency throughout the project, making it easier for the user to understand the interface. Also, a system of stable rules organizes all design elements and significantly speeds up the process at advanced stages; you will not have to design each individual element during scaling. It will be enough to select the necessary component and its state. Next, I will describe the basic set for a small project and the implementation process. Okay, let's start with the task. First, let's see what we have. Do we (or the design customer) have any guidelines? This could be just a logo drawn with a pen on paper. For some, it is a link to some color palette; for someone else, it is already their own corporate guideline, which already contains information about some accepted design elements. That is, there is always some starting point. If there is nothing at all, no problem, this is also a starting point. Often, even more advantageous. Let's assume that we are exactly in it. This means that we are currently limited exclusively by our imagination. Great! The main thing is not to spoil anything. To do this, you need to tune in, anything will do, the main thing is to be well inspired by something. Let's assume, however, that we already have a logo and such processes as benchmarking and elaboration of the central idea of ​​the design have been completed. Then, we boldly create our new cover and can even announce the launch of our latest project in all social networks. Choose a font if it is not regulated by the brand book. Do not underestimate this task. The font must match the brand. Plus, it is not always possible to painlessly change the font at the layout stage. In short, there are a lot of resources on the Internet for selecting a font and even a font pair. So, it is worth collecting several options and evaluating how it will look in the environment, on several screens. Then it is worth choosing a more suitable option, taking a break, and looking again the next morning. If there are no doubts, then this is a good option, if something confuses you, it is worth digging around at this stage. Having chosen the appropriate font, we form the text styles, thus, laying the foundation of the design system. There are several principles here. Everything should always be a multiple of 8 px. There is no way around it, especially if the indentation system and grid are also a multiple of 8 px. Then the logic is as follows - select several font sizes for the first screen. For this, again, we use a beautiful screen, a slogan, and see how it works. Then we determine the font sizes for the h1-h4 headings and at least two font sizes for the t1-t2 text, or better four t1-t4. We understand that the projects have the main text, various descriptions in cards, decorative elements, information about rights, etc., and with all this, we need to achieve a good level of hierarchy so that the user does not get tired when scanning the text and quickly finds important information for himself. Well, and then all the same is repeated for different styles. I have six of them in the project from L to EB. This whole process takes some time, especially at first, and I agree that there are plugins that allow you to save this time. But there are also advantages if you do everything yourself. Firstly, you will better understand the library of your styles, and it will be easier for you to choose the right style. Secondly, your library will be customized as much as possible. Working with a color palette. I already had a color palette, but to make it easier to work with the project, it is worth preparing shades for this palette in advance. In this particular project, I decided to use Radix, because this resource helps achieve an even greater level of consistency and reduces your time. Here, you can get not just a set of shades, but 12 different shades at once that are tied to individual design elements (text, buttons in different states, dividers, etc.). Plus, in one click, you can get a palette for the light and dark theme of your interface. Next, we load the resulting palette into Local variables. You can make several mods right here (light, dark, multi-colored, as many as you like). So, that in the future, by setting a certain color to different elements of the frame, you can change the color scheme of this frame in one click. This operation significantly saves time at later stages of working with the design. Also, in Local variables, it is worth immediately entering the values ​​of the rounding radii and indents. As usual, everything is a multiple of 8 px. For the radii, I make 5 values ​​from XS to XL; more is possible. Smaller values ​​are used for the smallest elements, such as buttons, and larger ones are used for graphics. This is worth doing so that, during the work process, you do not have to go back and look for the logic of decision-making at an earlier stage. With indents, the principle is the same, but there are more values, I set 13. It looks like this. When working with auto layouts, you do not need to remember the values, for example, of indents or paddings that were used earlier; they are simply pulled from the library. Let's move on to icons. For my project, I decided to use the following types of icons: special and basic. I drew the special icons, but they needed to be made more detailed. Basic icons can be found in the community. Think in advance about where these icons can be used and choose a suitable set. I planned to use them in buttons, cards, forms, etc. There is no point in overloading the library with irrelevant elements. At the moment, we have ready-made basic elements of our design guidelines: typography;
color palette;
rounding system;
indentation system;
set of icons;
so there were logos for various formats and color schemes; Plus I prepared grid styles. Now, it's time to move on to more complex components, consisting of basic ones - these are buttons, various forms, cards, header, footer, etc. But this is a topic for the next part of the tutorial. One of the preparatory stages of design development for any project is always the stage where the basic rules are laid down. Depending on the scale of the project, these may be some guidelines (if it is a small project involving one designer, such as a landing page), or large-scale design systems that combine several interfaces, in the work with which a group of designers participates. Regardless of the project, implementing these rules allows you to achieve consistency throughout the project, making it easier for the user to understand the interface. Also, a system of stable rules organizes all design elements and significantly speeds up the process at advanced stages; you will not have to design each individual element during scaling. It will be enough to select the necessary component and its state. Next, I will describe the basic set for a small project and the implementation process. Okay, let's start with the task. First, let's see what we have. Do we (or the design customer) have any guidelines? This could be just a logo drawn with a pen on paper. For some, it is a link to some color palette; for someone else, it is already their own corporate guideline, which already contains information about some accepted design elements. That is, there is always some starting point. If there is nothing at all, no problem, this is also a starting point. Often, even more advantageous. Let's assume that we are exactly in it. This means that we are currently limited exclusively by our imagination. Great! The main thing is not to spoil anything. To do this, you need to tune in, anything will do, the main thing is to be well inspired by something. Let's assume, however, that we already have a logo and such processes as benchmarking and elaboration of the central idea of ​​the design have been completed. Then, we boldly create our new cover and can even announce the launch of our latest project in all social networks. Choose a font if it is not regulated by the brand book. Do not underestimate this task. The font must match the brand. Plus, it is not always possible to painlessly change the font at the layout stage. In short, there are a lot of resources on the Internet for selecting a font and even a font pair. So, it is worth collecting several options and evaluating how it will look in the environment, on several screens. Then it is worth choosing a more suitable option, taking a break, and looking again the next morning. If there are no doubts, then this is a good option, if something confuses you, it is worth digging around at this stage. Having chosen the appropriate font, we form the text styles, thus, laying the foundation of the design system. There are several principles here. Everything should always be a multiple of 8 px. There is no way around it, especially if the indentation system and grid are also a multiple of 8 px. Then the logic is as follows - select several font sizes for the first screen. For this, again, we use a beautiful screen, a slogan, and see how it works. Then we determine the font sizes for the h1-h4 headings and at least two font sizes for the t1-t2 text, or better four t1-t4. We understand that the projects have the main text, various descriptions in cards, decorative elements, information about rights, etc., and with all this, we need to achieve a good level of hierarchy so that the user does not get tired when scanning the text and quickly finds important information for himself. Well, and then all the same is repeated for different styles. I have six of them in the project from L to EB. This whole process takes some time, especially at first, and I agree that there are plugins that allow you to save this time. But there are also advantages if you do everything yourself. Firstly, you will better understand the library of your styles, and it will be easier for you to choose the right style. Secondly, your library will be customized as much as possible. Working with a color palette. I already had a color palette, but to make it easier to work with the project, it is worth preparing shades for this palette in advance. In this particular project, I decided to use Radix, because this resource helps achieve an even greater level of consistency and reduces your time. Here, you can get not just a set of shades, but 12 different shades at once that are tied to individual design elements (text, buttons in different states, dividers, etc.). Plus, in one click, you can get a palette for the light and dark theme of your interface. Next, we load the resulting palette into Local variables. You can make several mods right here (light, dark, multi-colored, as many as you like). So, that in the future, by setting a certain color to different elements of the frame, you can change the color scheme of this frame in one click. This operation significantly saves time at later stages of working with the design. Also, in Local variables, it is worth immediately entering the values ​​of the rounding radii and indents. As usual, everything is a multiple of 8 px. For the radii, I make 5 values ​​from XS to XL; more is possible. Smaller values ​​are used for the smallest elements, such as buttons, and larger ones are used for graphics. This is worth doing so that, during the work process, you do not have to go back and look for the logic of decision-making at an earlier stage. With indents, the principle is the same, but there are more values, I set 13. It looks like this. When working with auto layouts, you do not need to remember the values, for example, of indents or paddings that were used earlier; they are simply pulled from the library. Let's move on to icons. For my project, I decided to use the following types of icons: special and basic. I drew the special icons, but they needed to be made more detailed. Basic icons can be found in the community. Think in advance about where these icons can be used and choose a suitable set. I planned to use them in buttons, cards, forms, etc. There is no point in overloading the library with irrelevant elements. At the moment, we have ready-made basic elements of our design guidelines: typography; color palette; rounding system; indentation system; set of icons; so there were logos for various formats and color schemes; typography; color palette; rounding system; indentation system; set of icons; so there were logos for various formats and color schemes; Plus I prepared grid styles. Now, it's time to move on to more complex components, consisting of basic ones - these are buttons, various forms, cards, header, footer, etc. But this is a topic for the next part of the tutorial.

The Implementation of Design Guidelines for Small and Medium Projects

So You Want To Be On A Startup Board of Directors

Analysts often encounter outliers in data during their work, such as during AB-test analysis, creating predictive models, or tracking trends. Decisions are usually based on the sample mean, which is very sensitive to outliers and can dramatically change the value. So, it is crucial to manage outliers to make the correct decision. Let's consider several simple and fast approaches for working with unusual values. Problem Formulation Imagine that you need to conduct an experiment analysis using an average order value as a primary metric. Let's say that our metric usually has a normal distribution. Also, we know that the metric distribution in the test group is different from that in the control. In other words, the mean of the distribution in control is 10, and in the test is 12. The standard deviation in both groups is 3. However, both samples have outliers that skew the sample means and the sample standard deviation. import numpy as np

N = 1000

mean_1 = 10
std_1 = 3

mean_2 = 12
std_2 = 3

x1 = np.concatenate((np.random.normal(mean_1, std_1, N), 10 * np.random.random_sample(50) + 20))
x2 = np.concatenate((np.random.normal(mean_2, std_2, N), 4 * np.random.random_sample(50) + 1)) NB that considering metric could have outliers from both sides. If your metric could have outliers only from one side, methods could easily be transformed for that purpose. Cut Off Tails The easiest method is to cut off all observations before the 5% percentile and after the 95% percentile. In this case, we lost 10% of the information as a con. However, the distributions look more formed, and the sample moments are nearer to the distribution moments. import numpy as np

x1_5pct = np.percentile(x1, 5)
x1_95pct = np.percentile(x1, 95)
x1_cutted = [i for i in x1 if i > x1_5pct and i < x1_95pct]

x2_5pct = np.percentile(x2, 5)
x2_95pct = np.percentile(x2, 95)
x2_cutted = [i for i in x2 if i > x2_5pct and i < x2_95pct] Another way is to exclude observations outside the specific range. The low band equals the 25% percentile minus one-half of the interquartile range, and the high band equals the 75% percentile plus one-half. Here, we will lose only 0.7% of information. The distributions look more formed than the initial. The sample moments are even more equal to the distribution moments. import numpy as np

low_band_1 = np.percentile(x1, 25) - 1.5 * np.std(x1)
high_band_1 = np.percentile(x1, 75) + 1.5 * np.std(x1)
x1_cutted = [i for i in x1 if i > low_band_1 and i < high_band_1]

low_band_2 = np.percentile(x2, 25) - 1.5 * np.std(x2)
high_band_2 = np.percentile(x2, 75) + 1.5 * np.std(x2)
x2_cutted = [i for i in x2 if i > low_band_2 and i < high_band_2] Bootstrap The second method we considered here is a bootstrap. In this approach, the mean is constructed like a mean of subsamples. In our example, the mean in the control group equals 10.35, and the test group is 11.78. It is still a better result compared to additional data processing. import pandas as pd

def create_bootstrap_samples(
    sample_list: np.array,
    sample_size: int, 
    n_samples: int
    ):
    
    # create a list for sample means
    sample_means = []
    
    # loop n_samples times
    for i in range(n_samples):
        
        # create a bootstrap sample of sample_size with replacement
        bootstrap_sample = pd.Series(sample_list).sample(n = sample_size, replace = True)
        
        # calculate the bootstrap sample mean
        sample_mean = bootstrap_sample.mean()
        
        # add this sample mean to the sample means list
        sample_means.append(sample_mean)
    
    return pd.Series(sample_means)

(create_bootstrap_samples(x1, len(x1), 1000).mean(), create_bootstrap_samples(x2, len(x2), 1000).mean()) Conclusion Outlier detection and processing are significant for making the right decision. Now, at least three fast and straightforward approaches could help you check the data before analysis. However, it is essential to remember that detected outliers could be unusual values and a feature for the novelty effect. But it is another story :) Analysts often encounter outliers in data during their work, such as during AB-test analysis, creating predictive models, or tracking trends. Decisions are usually based on the sample mean, which is very sensitive to outliers and can dramatically change the value. So, it is crucial to manage outliers to make the correct decision. Let's consider several simple and fast approaches for working with unusual values. Problem Formulation Imagine that you need to conduct an experiment analysis using an average order value as a primary metric. Let's say that our metric usually has a normal distribution. Also, we know that the metric distribution in the test group is different from that in the control. In other words, the mean of the distribution in control is 10, and in the test is 12. The standard deviation in both groups is 3. However, both samples have outliers that skew the sample means and the sample standard deviation. import numpy as np

N = 1000

mean_1 = 10
std_1 = 3

mean_2 = 12
std_2 = 3

x1 = np.concatenate((np.random.normal(mean_1, std_1, N), 10 * np.random.random_sample(50) + 20))
x2 = np.concatenate((np.random.normal(mean_2, std_2, N), 4 * np.random.random_sample(50) + 1)) import numpy as np

N = 1000

mean_1 = 10
std_1 = 3

mean_2 = 12
std_2 = 3

x1 = np.concatenate((np.random.normal(mean_1, std_1, N), 10 * np.random.random_sample(50) + 20))
x2 = np.concatenate((np.random.normal(mean_2, std_2, N), 4 * np.random.random_sample(50) + 1)) NB that considering metric could have outliers from both sides. If your metric could have outliers only from one side, methods could easily be transformed for that purpose. NB Cut Off Tails The easiest method is to cut off all observations before the 5% percentile and after the 95% percentile . In this case, we lost 10% of the information as a con. However, the distributions look more formed, and the sample moments are nearer to the distribution moments. before the 5% percentile after the 95% percentile import numpy as np

x1_5pct = np.percentile(x1, 5)
x1_95pct = np.percentile(x1, 95)
x1_cutted = [i for i in x1 if i > x1_5pct and i < x1_95pct]

x2_5pct = np.percentile(x2, 5)
x2_95pct = np.percentile(x2, 95)
x2_cutted = [i for i in x2 if i > x2_5pct and i < x2_95pct] import numpy as np

x1_5pct = np.percentile(x1, 5)
x1_95pct = np.percentile(x1, 95)
x1_cutted = [i for i in x1 if i > x1_5pct and i < x1_95pct]

x2_5pct = np.percentile(x2, 5)
x2_95pct = np.percentile(x2, 95)
x2_cutted = [i for i in x2 if i > x2_5pct and i < x2_95pct] Another way is to exclude observations outside the specific range . The low band equals the 25% percentile minus one-half of the interquartile range, and the high band equals the 75% percentile plus one-half. Here, we will lose only 0.7% of information. The distributions look more formed than the initial. The sample moments are even more equal to the distribution moments. outside the specific range import numpy as np

low_band_1 = np.percentile(x1, 25) - 1.5 * np.std(x1)
high_band_1 = np.percentile(x1, 75) + 1.5 * np.std(x1)
x1_cutted = [i for i in x1 if i > low_band_1 and i < high_band_1]

low_band_2 = np.percentile(x2, 25) - 1.5 * np.std(x2)
high_band_2 = np.percentile(x2, 75) + 1.5 * np.std(x2)
x2_cutted = [i for i in x2 if i > low_band_2 and i < high_band_2] import numpy as np

low_band_1 = np.percentile(x1, 25) - 1.5 * np.std(x1)
high_band_1 = np.percentile(x1, 75) + 1.5 * np.std(x1)
x1_cutted = [i for i in x1 if i > low_band_1 and i < high_band_1]

low_band_2 = np.percentile(x2, 25) - 1.5 * np.std(x2)
high_band_2 = np.percentile(x2, 75) + 1.5 * np.std(x2)
x2_cutted = [i for i in x2 if i > low_band_2 and i < high_band_2] Bootstrap The second method we considered here is a bootstrap. In this approach, the mean is constructed like a mean of subsamples. In our example, the mean in the control group equals 10.35, and the test group is 11.78. It is still a better result compared to additional data processing. import pandas as pd

def create_bootstrap_samples(
    sample_list: np.array,
    sample_size: int, 
    n_samples: int
    ):
    
    # create a list for sample means
    sample_means = []
    
    # loop n_samples times
    for i in range(n_samples):
        
        # create a bootstrap sample of sample_size with replacement
        bootstrap_sample = pd.Series(sample_list).sample(n = sample_size, replace = True)
        
        # calculate the bootstrap sample mean
        sample_mean = bootstrap_sample.mean()
        
        # add this sample mean to the sample means list
        sample_means.append(sample_mean)
    
    return pd.Series(sample_means)

(create_bootstrap_samples(x1, len(x1), 1000).mean(), create_bootstrap_samples(x2, len(x2), 1000).mean()) import pandas as pd

def create_bootstrap_samples(
    sample_list: np.array,
    sample_size: int, 
    n_samples: int
    ):
    
    # create a list for sample means
    sample_means = []
    
    # loop n_samples times
    for i in range(n_samples):
        
        # create a bootstrap sample of sample_size with replacement
        bootstrap_sample = pd.Series(sample_list).sample(n = sample_size, replace = True)
        
        # calculate the bootstrap sample mean
        sample_mean = bootstrap_sample.mean()
        
        # add this sample mean to the sample means list
        sample_means.append(sample_mean)
    
    return pd.Series(sample_means)

(create_bootstrap_samples(x1, len(x1), 1000).mean(), create_bootstrap_samples(x2, len(x2), 1000).mean()) Conclusion Outlier detection and processing are significant for making the right decision. Now, at least three fast and straightforward approaches could help you check the data before analysis. However, it is essential to remember that detected outliers could be unusual values and a feature for the novelty effect. But it is another story :)

Outlier Detection: What You Need to Know

Uitskieteropsporing: Wat jy moet weet

የውጪ ማወቂያ፡ ማወቅ ያለብዎት

اكتشاف القيم الشاذة: ما تحتاج إلى معرفته

Outlier Detection: Kuntï yatiñamäki

Kənarların aşkarlanması: Nəyi bilməlisiniz

Выяўленне выкідаў: што вам трэба ведаць

Откриване на отклонения: Какво трябва да знаете

Detekcija odstupanja: šta trebate znati

Detecció d'outliers: el que cal saber

Detekce odlehlých hodnot: Co potřebujete vědět

Outlier-detektion: Hvad du behøver at vide

Ανίχνευση ακραίων τιμών: Τι πρέπει να γνωρίζετε

Outlier detekzioa: jakin behar duzuna

تشخیص بیرونی: آنچه باید بدانید

Poikkeamien havaitseminen: mitä sinun tulee tietää

Detección de valores atípicos: o que debes saber

זיהוי חריגים: מה שאתה צריך לדעת

Detekcija ekstremnih vrijednosti: što trebate znati

Deteksyon Outlier: Sa ou bezwen konnen

Outlier-észlelés: amit tudnod kell

Օտարության հայտնաբերում. այն, ինչ դուք պետք է իմանաք

Deteksi Outlier: Apa yang Perlu Anda Ketahui

Rilevamento dei valori anomali: cosa devi sapere

გარე ამოცნობა: რა უნდა იცოდეთ

Шектеулерді анықтау: нені білу керек

ការរកឃើញខាងក្រៅ៖ អ្វីដែលអ្នកត្រូវដឹង

Чектөөлөрдү аныктоо: Сиз эмнени билишиңиз керек

Détection ya ba outlier: Oyo osengeli koyeba

ການ​ກວດ​ສອບ​ນອກ​: ສິ່ງ​ທີ່​ທ່ານ​ຈໍາ​ເປັນ​ຕ້ອງ​ຮູ້​

Nukrypimų aptikimas: ką reikia žinoti

Ārkārtu noteikšana: kas jums jāzina

Fikarohana Outlier: Inona no tokony ho fantatrao

Откривање на оддалеченост: Што треба да знаете

Хэт ихийг илрүүлэх: Та юу мэдэх хэрэгтэй вэ

Pengesanan Outlier: Perkara yang Anda Perlu Tahu

आउटलियर पत्ता लगाउने: तपाईलाई के थाहा छ

Outlierdetectie: wat u moet weten

Go Lemoga Outlier: Seo o Swanetšego go se Tseba

Wykrywanie wartości odstających: co musisz wiedzieć

بهرنی کشف: هغه څه چې تاسو ورته اړتیا لرئ پوه شئ

Outlier Detección: Imakunatan yachanayki

Detectarea valorii aberante: Ce trebuie să știți

Kumenya Hanze: Ibyo Ukeneye Kumenya

බාහිර අනාවරණය: ඔබ දැනගත යුතු දේ

Detekcia odľahlých hodnôt: Čo potrebujete vedieť

Kunze Kuonekwa: Zvaunoda Kuziva

Ogaanshaha ka baxsan: Waxa aad u baahan tahay inaad ogaato

Zbulimi i jashtëzakonshëm: Çfarë duhet të dini

Откривање одступања: шта треба да знате

Outlier Detection: Vad du behöver veta

Utambuzi wa Nje: Unachohitaji Kujua

வெளிப்புற கண்டறிதல்: நீங்கள் தெரிந்து கொள்ள வேண்டியது

Муайянкунии берунӣ: Он чизеро, ки шумо бояд донед

การตรวจจับค่าผิดปกติ: สิ่งที่คุณจำเป็นต้องรู้

ኣውትላይር ምፍላጥ፡ ክትፈልጦ ዘለካ

Daşarky kesgitleme: Bilmeli zatlaryňyz

Outlier Detection: Ang Kailangan Mong Malaman

Ku Kuma Outlier: Leswi U Faneleke Ku Swi Tiva

Виявлення викидів: що вам потрібно знати

آؤٹ لیئر کا پتہ لگانا: آپ کو کیا جاننے کی ضرورت ہے۔

Chiqib ketishni aniqlash: nimani bilishingiz kerak

Ukufunyanwa kwangaphandle: Into ekufuneka uyazi

Ukutholwa Kwangaphandle: Okufanele Ukwazi

Hi everyone, my name is Max Nechaev. I'm an iOS developer and a startup founder. Over the last six months I've traveled a really interesting path, which is full of complexity, uncertainty, trial, error, and fan. We've all thought about our own business at some point. What if you don't work for someone else? What if you could try starting something of your own? Would I be able to do it? I run into these questions quite often. But what's the reasoning here? The point is that if you put your fears aside and try to answer this question as truthfully as possible, you most likely won't be able to give a clear and concise answer. This is where we run into that winged phrase "You won't know until you try". It was after this realization that a seed settled in my mind that sprouted and gave me more and more food for thought each day and each week. Eventually, I realized that I was going to try and create my startup in the IT industry. Market preparation and analysis The first thing that was important to me was mental preparation. I read books on management and business. I spent a lot of time watching videos on different niches, analyzing entrepreneurs and their strategic decisions. Before starting work on any project, it is very important to be ready for it from the inside, not just "think of something and do it". YouTube Second, analyze the market. You can't just take and make any application, because the market is big, there are prevalent trends, there are leaders and outsiders, there are money niches, and there are niches where there is no money in general, no matter how much marketing budgets you pour into it. There are plenty of niche analytics sites out there, at first I used . It helps us in finding apps in different niches in different countries. Moreover, you can see who is earning how much (the only issue I have is that it doesn't show how much someone spends on marketing, so you won't see the real net profit). SensorTower In this article, I would like to share the steps we have taken, not a specific case study, so I will not go into the details of the research. We are not a million-dollar company yet, so there are no working cases yet, but those who are interested in this topic will find a lot of useful tips here. So I will say this. We've settled on a niche of apps that help content creators and SMM specialists. Team building "One man can't fight alone." I keep bombarding you with catchphrases. But in the 21st century, this is the purest truth. I am not used to hearing "success stories" about how some programmer from the village did something and became a millionaire. Because even if there are such cases, it is rather an exception to the rule. It is very important not to fall into the "survivor's syndrome". Don't get me wrong, every good developer can write his first alone. But only if we are talking about real commercial success, multiple financial growth, and high productivity, we are talking about a team. MVP In the first stages, we don't need a big office and several development departments. We need to cover several areas: frontend, backend, design, marketing. You don't necessarily need 4 people, because, often, many mobile apps don't need a backend, plus one person can fulfill multiple roles. I'm lucky here, I have a background as a marketer. I understand how metrics work, ad rooms, what creatives are, what they should look like, and what it takes to get the whole thing up and running. I'm not saying I'm the best at it, but this level is enough for the first stages of a startup's life. So I've been doing iOS development and marketing for the project. Going through a cool school from I realized that a co-founder is needed. A person who will share my values and move in the same direction as me. Startups with co-founders are many times more likely to succeed than those with a single founder. This is shown by the statistics that the folks at have compiled. If you're interested in specific numbers, I encourage everyone to go to their school. Y Combinator Y Combinator My co-founder (surprise surprise) is a backend developer. This means in addition to some business decisions, he'll be able to take on that role as well. This will greatly simplify iOS development (because most of the logic will be put on the backend). And of course, it will increase our speed a lot. We are both senior developers, which means that we will be able to think through everything competently and do it optimally with minimal financial and time investments. There is one last role left uncovered. UX/UI Designer. Because of where I am in the IT industry, I have a lot of talented people around me. So to be honest, I found the designer even earlier than the co-founder. She will also get a share of ownership of the startup and the head designer position when the staff grows. So together we are covering all the initial needs. With a team like this, we can make neither one nor two apps. Maybe we will expand our team and take new people. For now, we plan to take only some temporary outsourcing for adequate money (if necessary). From the start, we build in processes. Set goals and objectives. We make development boards, put up milestones, and spread everything out by dates. We calculate the economics of projects, plan investments, how much, and at what stages. In general, operational activities are also starting to go full speed. Design development At this stage, we have started on the application’s UI. Our goal is style, usability, and beauty from the user's point of view. We have thoroughly analyzed the competitors and identified the weaknesses of each. After that, by improving their apps we create our own. As part of the design, I also laid out a set of objectives. The designer has deadlines for working out each screen. She has a description of the functionality. The goals of the app and the problem it solves. We average 4-5 days of work (not full-time) per screen. Again, some people will find it too long, and some will find it too fast, but at this stage, it works and we are satisfied with it. We work out the entire design in . All task descriptions, boards, and project descriptions are in . Figma Notion Our application allows users to create and generate text content for social networks. That's why we developed the most simple and understandable design, which will completely cover the problem with writing posts, scripts, their organization, etc. Application Architecture Now I'm not talking about the architecture of the iOS part, but mostly about the architecture in general. I'll be honest, initially, the app was made only for the iOS platform and stores everything locally. I didn't intend to add a backend, but later on, I reconsidered my decision. For this purpose, I had to rewrite parts of the functionality. At the same time, it was an important note not to break the existing one. So, it turns out that we are making a full-fledged client-server application, so everything becomes clearer with the architecture. We have a "service" that is responsible for user registration and authorization, it simplifies the work of the iOS application because you just need to send a couple of requests to the backend and the "magic" begins. For the next step, we needed to pull up the database. That's where we will store users, their IDs, data, and content. Separate from that, we need to create a service for working with the database. Because the application should synchronize well with it every time the user opens the application. Yes, yes, you heard right. For now, we are running with somewhat limited functionality of full synchronization, as we don't need it that much. The main point of creating a backend and pulling user-generated content there is to preserve progress. No one wants to delete an app or change phones and lose all their data and all their content. So at this stage, it's still the goal to preserve, not to make seamless instant synchronization for cross-platforming. This is where I'd like to bring up the topic of "optimality". Often, aspiring startups (like us) make a huge mistake of trying to make the perfect product. They spend a huge amount of time (and some even financial resources) to make an ideal product to beat everyone else in the market. But the truth is, it's likely that they'll never make it to release. With limited resources, the word "perfect" is inapplicable. Even the first versions of were pretty ridiculous (not to mention ). I, on the other hand, am a stickler for the word "optimality". It's much more important and more succinct. Instead of making the perfect product, the perfect design, the perfect architecture, and the perfect servers that can handle colossal loads, I will make an optimal solution. It will work fine. NORMAL. And no more. I can refine everything else gradually, as long as the optimal solution generates some cash for me. Facebook Amazon The iOS architecture Now for the most interesting part. Since I'm an iOS developer, I'd like to write more technical "stuff" here. What we used, why, and what problems we encountered. SwiftUI Oh, yeah. We gave up on UIKit. It's even more accurate to say that "I gave up". I decided that since I'm starting to write something from scratch, let it be new and promising technologies. Moreover, SwiftUI is quite easy to layout, screens are made fast. Animations are also easy to implement. Moreover, SwiftUI is reactive, we are working with the Combine framework and it works quite well, no matter what anyone says. Moreover for future hiring, I believe this will be a big plus. There are a huge number of talented developers who already really want to move to 100% SwiftUI but are not yet able to do so. The overwhelming number of apps are still on UIKit. Rewriting them to a new framework is long and expensive, and businesses don't like those words. Did I regret choosing ? SwiftUI To be honest, despite all the pluses of the new framework, there are some outright minuses. For example, navigation. Yes, most developers have problems with it. It's not obvious enough how to take the routing logic into a separate entity, encapsulate it there, and take this responsibility away from the UI (like we're used to in UIKit). With iOS 16 this has gotten a lot easier and clearer, but the problem is that we're still supporting iOS 15 after all. Some guys write their extensions and somehow find a way to bring out the logic of routing through several levels of abstraction, we didn't have the resources for that. That's why we got the classic SwiftUI routing. We also encountered problems with the custom TabBar, which did not want to work correctly. Spent about 4 days doing everything competently. Is reactivity a pain? For many developers, creating reactive applications is a challenge. Especially for those who have never worked with this paradigm. I had a pretty good experience working with RxSwift, so in general, the approach was familiar. I just needed to understand how it all worked inside SwiftUI and how to build the architecture. At the dawn of SwiftUI's launch, everyone was talking about how MVVM was the perfect design pattern for it. Over the last six months, I've been hearing the opposite viewpoint, that MVVM is not suitable for SwiftUI, but that MVI is already laying down quite interestingly. I took the classic approach that Apple recommends. I had several managers that were needed in many places in the application, created one instance, and passed it throughout the UI hierarchy as an Environment variable. Admittedly, I made separate ViewModels for screens a couple of times, as I didn't see the point of making the class an observable manager. Conclusions So, I would like to summarize the above and the results of the first launch. Would I choose SwiftUI for my next application? Most likely yes. But while writing the application, I will be more careful in writing code, create more reusable UI components, and adhere to MVI architecture more strictly. Is a team really necessary? Yes, when you are not alone, you feel more confident, and you feel responsible not only for your destiny but also for your guys. It is always more interesting and precise to think through business or technical architecture together. Plus the saying "one head is good, but two are better" works perfectly here. Now the desire is only to increase the company's staff. What about the finances? It would be foolish to expect big income at the start of the project, so I consider only investments, investments, and once again investments. Of course, a small income begins to appear, and people buy subscriptions, but it is not comparable to the amount of money that comes from investments. I understand these risks and take them into account. Building your own business is a long-term game, full of risks and costs. Emotionally, I am ready for it. It is not an easy path, but I think it is quite realistic for me. Would I advise all developers to follow this path? Of course not. There are dozens of talented developers around me, they are happy, and they earn a lot of money with rather low responsibility. They have a lot of free time. They travel and spend money on whatever they want. Do they need to throw money into the bonfire of a business that could go out at any moment? Probably not. Everyone chooses their own way. I, for example, can't live without it all, and for some people, it's a real hell. I do not condemn either of them, and I am very glad that each person chooses his own way. Thanks for your time, for any questions you can contact me by mail or on Telegram (@maxnech) (or ). LinkedIn

How We Launched Our First MVP in the iOS App Market

Introduction: If you search the internet for a library that can generate sequences, you can hardly find one, although sequences are a core concept of discrete mathematics and computer science. In this short article, we will take a look at a library I wrote for the sequence generation called . SeqGen What Is A Sequence? A sequence (informally speaking ) is a set of elements (mostly numbers) where the production of each element is based on the preceding element(s). The most basic example is a simple linear sequence of positive integers where the first element is 0 and the next element is the preceding element plus one, so we can get the second element by adding one to the first one, and we can get the third element by adding one to second one, and so on. The linear sequence would look like this: . {0, 1, 2, 3, …, n} A more complex example could be the Fibonacci sequence where the first two elements are 0 and 1, and the next element is the sum of the two preceding elements. The Fibonacci sequence would look like this: {0, 1, 1, 2, 3, 5, 8, 13, 21, …, n} We can notice from above that a sequence is defined with two properties: The initial elements A function that produces the next element Using the Library: Dependencies: The SeqGen library is written in the Rust programming language; to follow up, you need to have . Rust installed Creating A Project: Let’s create a new project to use the SeqGen library; we can do so with cargo: $ cargo new --bin sequence && cd sequence Now, let’s add the library as a dependency to our project: $ cargo add seqgen Now, we are ready to use the library. Creating A Sequence: In SeqGen, the sequence creation process maps directly to the two properties of the sequence that we concluded in the What is A Sequence section; we have to define the initial elements and the function that produces the next element (called the transition function in SeqGen). Let’s create the linear sequence: use seqgen::prelude::*;

fn main() {
    let linear_seq = Sequence::new()
        .initial_elements(vec![0])
        .transition_function(|alive_elements, current_element_index| {
            alive_elements.last_element().unwrap() + 1
        });
} The type is a struct that represents a sequence; by calling the associated function on this type, we get a new instance that is undefined. On this undefined instance, we can call methods to define it. Sequence new() The first method is which accepts a vector of elements as an argument, and sets it as the initial elements of the instance. initial_elements() The second method is which takes as an argument a closure that represents the transition from the currently available elements to the next element. transition_function() This closure has access to two arguments: the first is which represents the currently available elements, and the second is (of type ) which is the index of the current element in generation. See the table below for an illustration of the transition function. alive_elements current_element_index usize Current Element in Generation alive_elements current_element_index 1 [0] 1 2 [0, 1] 2 3 [0, 1, 2] 3 n [0, 1, 2, 3, …, n] n is of type , we will take a look at the type later in this article alive_elements SequencePart SequencePart Since the index of the element is also its value in the linear sequence, we can simplify the example above to: use seqgen::prelude::*;

fn main() {
    let linear_seq = Sequence::new().transition_function(|_, i| i);
} Here, we do not need to define the initial elements, and we do not need access to the live elements; we just need the index (which is named in this case), and we simply return it. i In the same manner, we can define the Fibonacci sequence: use seqgen::prelude::*;

fn main() {
    let fib_seq = Sequence::new()
        .initial_elements(vec![0, 1_u128])
        .transition_function(|alive_elements, i| {
            let x = alive_elements.nth_element(i - 1).unwrap();
            let y = alive_elements.nth_element(i - 2).unwrap();

            x + y
        });
} Since the Fibonacci sequence grows exponentially, generating more than 187 elements with this definition will cause to overflow. A better definition would use big int instead of . u128 u128 : Using the Sequence After we defined our sequence, we can access its elements: use seqgen::prelude::*;

fn main() {
    let mut linear_seq = Sequence::new().transition_function(|_, i| i);
    let some_element = linear_seq.nth_element(111);
    println!("{some_element}");
} Here, we are accessing the 111th element using method which returns an immutable reference to the element ( in this case). nth_element() &usize Notice that we made mutable. That’s because the method will mutate the alive elements of the sequence. linear_seq nth_element() In this way, we can access any element of the sequence (from the element with an index of to the element with an index of .) 0 usize::MAX We can also iterate over the sequence like any Rust iterator: use seqgen::prelude::*;

fn main() {
    let linear_seq = Sequence::new().transition_function(|_, i| i);
    linear_seq.for_each(|e| println!("{e}"));
} This code will print all the elements of the sequence (from the element to the element ): 0 usize::MAX $ cargo run -q
0
1
2
3
4
5
6
7
8
9
10
11
12
13
... We can get the odd elements from the sequence using the following code: use seqgen::prelude::*;

fn main() {
    let linear_seq = Sequence::new().transition_function(|_, i| i);
    let odd_elements = linear_seq.filter(|e| e % 2 != 0);

    odd_elements.for_each(|e| println!("{e}"));
} Output: $ cargo run -q                                                            
1
3
5
7
9
11
13
... The sequence we define is lazy, meaning the elements won’t be generated unless needed (in case of iteration), or explicitly requested (using the method or other methods). nth_element() : Working With Parts of the Sequence Sometimes, we need to only work with parts of a sequence, in this case, we have sequence parts. There are three types of the sequence part: AliveElementsPart ImmutableRangePart MutableRangePart AliveElementsPart: We can get the live elements using the method on the sequence: alive_elements() use seqgen::prelude::*;

fn main() {
    let linear_seq = Sequence::new()
        .transition_function(|_, i| i)
        .pre_generate(111);

    let alive_elements = linear_seq.alive_elements();

    for alive_element in alive_elements {
        print!("{alive_element} ");
    }
} This code will print all the alive elements (0 to 110 in this case because we pre-generated 111 elements). ImmutableRangePart: Immutable ranges are ranges of the alive elements; they cannot mutate the sequence. If you will create an immutable range and not all its elements are alive, you will get an error ( error). DeadRange We can create an immutable range using the method which returns a . The variant is , and the variant is . The could be the variant (in case the start of the range is greater than its end), or it could be variant (in case not all elements of the range are alive): range() Result Ok ImmutableRangePart Err RangeError RangeError InvalidRange DeadRange use seqgen::prelude::*;

fn main() {
    let linear_seq = Sequence::new().transition_function(|_, i| i);
    let range = linear_seq.range(0, 3).unwrap();

    for e in range {
        println!("{e}")
    }
} This code will panic with error because there is no alive element. We can correct this with the following: DeadRange use seqgen::prelude::*;

fn main() {
    let mut linear_seq = Sequence::new().transition_function(|_, i| i);

    linear_seq.generate(3);

    let range = linear_seq.range(0, 3).unwrap();

    for e in range {
        println!("{e}")
    }
} Here, we generated 3 elements to make the range valid. MutableRangePart: A mutable range can mutate the sequence (generate elements). We can use a mutable range like so: use seqgen::prelude::*;

fn main() {
    let mut linear_seq = Sequence::new().transition_function(|_, i| i);
    let mut_range = linear_seq.range_mut(0, 111).unwrap();

    for e in mut_range {
        println!("{e}");
    }
} This code will print the elements from 0 to 110. Outroduction: Thank you for reading this article to the end, and I hope you found something useful in it. If you have any suggestions that can improve this library, please , and if you want to , that would be wonderful. open an issue on GitHub contribute to the library Also published here

SeqGen: The Library I Created for Sequence Generation

SeqGen: লাইব্রেরি আমি সিকোয়েন্স জেনারেশনের জন্য তৈরি করেছি

SeqGen: Die Bibliothek, die ich für die Sequenzgenerierung erstellt habe

SeqGen: la biblioteca que creé para la generación de secuencias

SeqGen : la bibliothèque que j'ai créée pour la génération de séquences

SeqGen: वह लाइब्रेरी जो मैंने अनुक्रम निर्माण के लिए बनाई थी

SeqGen: シーケンス生成用に作成したライブラリ

SeqGen: 시퀀스 생성을 위해 만든 라이브러리

SeqGen: a biblioteca que criei para geração de sequências

SeqGen: библиотека, которую я создал для генерации последовательностей

SeqGen: Dizi Oluşturma için Oluşturduğum Kütüphane

SeqGen: Thư viện tôi đã tạo để tạo trình tự

SeqGen：我为序列生成创建的库

Stories, News & Mentions about PLUSONE

Plusone’s Stories on HackerNoon

Plusone's News & Mentions