Fixing long-term bugs is not so easy in production😁 Just running 6776 delete queries

maxProfit :: [Int] -> Int
maxProfit (p:ps) = fst . foldl go (0, p) $ ps
  where
    go :: (Int, Int) -> Int -> (Int, Int)
    go (profit, minPrice) price = ( max profit (price-minPrice)
                                  , min minPrice price)

vs

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        auto [profit, price] = std::accumulate(
            prices.begin()+1, prices.end(),
            std::make_pair(0, prices[0]),
            [](std::pair<int, int> acc, int price) {
                return std::make_pair(
                    std::max(acc.first, price-acc.second),
                    std::min(acc.second, price)
                );
            }
        );

        return profit;
    }
};

CPP is an absolute nightmare

Prime numbers and π are keys to our world secrets💀

After adding this label into my profile, none of HRs is not writing to me😂

Haskell has so so so good type-system and even crazy AI can write a project in a seconds 👻

Origin: Garbage collection was invented by American computer scientist John McCarthy around 1959.
Language: It was specifically designed for the Lisp programming language to automate the management of memory for its characteristic list-based data structures.

Functional programming languages are GOAT I think

https://youtube.com/shorts/TRw-Ep09p20?si=Pc-7xDFmXCo7c26r

The new product review😂😂😂

Day to day I am understanding how good Haskell's approach to software development🙃

https://github.com/abdivasiyev/telegram-teams-server

Telegram to Microsoft Teams bridge

vibe coded by expensive tokens

LOL

I am not in LinkedIn anymore💔

Early years of my career, I was interested in writing articles, doing streams. But now everyone will use LLM instead of searching and learning something. LLM is developing reduced attention span among engineers as like TikTok, Instagram does. Hope everything should be ok🫠

And I do not have any ideas what about to write

Using primitive types is shooting yourself in the foot. One missing check and you will loose your all logic🤧🤧🤧

Even with Haskell or Rust's strong type system, you will end up with dynamic language (JS or PHP) like result.

So, parse, do not validate guys

For example:

package users

type Repo interface {
    GetByID(context.Context, int, int, int) (User, error)
}

Can you predict which argument is used as id of the user? Or what for responsible another arguments?

In Go's idiom, there are usual two ways:

– using a struct to pass these arguments. But there is a problem. How do you require to fill all fields of struct? Will you return runtime error? So you will end up production failure in your services.
– using named arguments. Kind of works, but you will not read always any documentation or function definition, so messing up with this also easy.

So, let's add third way to our idiom:

// types package
package types

// phantom types
type (
    User struct{}
    Customer struct{}
)

type constraint interface {
     User | Customer
}

type ID [T constraint] int64
type Offset [T constraint] int64
type Limit [T constraint] int64


// users package
package users

type Repo interface {
    GetByID(context.Context, types.ID[types.User], types.Offset[types.User], types.Limit[types.User]) (User, error)
}

In the last solution, a caller can not misuse any arguments, they will get compile time error whenever they changed order of the arguments. But there is a trick again thanks to Go's explicit type casting😐. You just easily convert types.ID into types.Offset because of their underlying data types. For this, one can use a struct instead of int64 as underlying type. But it will be so overcomplicated.