DEV Community: Jeff

How to create a WeCom App to enable WeCom Login for the Web app

Jeff — Wed, 15 May 2024 02:11:09 +0000

Login to WeCom Console

https://work.weixin.qq.com/

Create an app

Create a self-built app under the Apps tab:

Note down app credentials

Firstly, note down the AgentId, Then Click View and send secrets to WeCom:

And note down the AppId and AppSecret from WeCom:

Specify the callback domain

Configure the Trusted IP List

Done!

After the integration, you can now log in through WeCom. The final result would be like:

Beyond the Code: The Undervalued Art of Communication in Tech Careers

Jeff — Wed, 27 Mar 2024 05:52:37 +0000

In the world of software development, the phrase "Talk is cheap, show me the code" has become a rallying cry for those who prioritize tangible results over mere discussion. It's a sentiment that resonates with the hacker ethos, emphasizing the value of working code over theoretical chatter. However, as many seasoned programmers have discovered through their careers, this axiom can be misleading and, in some contexts, detrimental to professional growth and influence in the workplace.

The Misconception of Code as King

The adage suggests that the only thing that truly matters in the tech industry is the ability to write good code. While technical proficiency is undoubtedly essential, it's a narrow viewpoint that fails to recognize the complexity of the software development process and the multifaceted nature of tech careers. This perspective can lure programmers into a false sense of security, believing that if they can just code well, success will naturally follow.

Communication: The Unseen Pillar of Success

In reality, effective communication is often a more valuable currency than the ability to code. As developers climb the career ladder, they quickly realize that their impact and potential for advancement hinge not only on their technical skills but also on their ability to articulate ideas, collaborate with others, and influence decision-making processes.

Why Talk Isn't Cheap

Teamwork and Collaboration: Software development is rarely a solo endeavor. It requires constant communication with team members, stakeholders, and clients. The ability to discuss problems, brainstorm solutions, and synchronize efforts is critical to the success of any project.
Leadership and Influence: As developers advance into leadership roles, their responsibilities shift from writing code to guiding teams and shaping the direction of projects. Influential leaders must be able to communicate a vision, motivate their team, and negotiate with other departments or clients.
Problem-Solving and Innovation: Before any code is written, there must be a clear understanding of the problem at hand. Developers who can effectively communicate with non-technical stakeholders to identify the root of issues will be more adept at creating innovative solutions.
Mentorship and Knowledge Sharing: Experienced developers are often expected to mentor juniors. The ability to explain complex concepts in an accessible manner is crucial for fostering the next generation of talent.
Career Advancement: When it comes to promotions and career opportunities, those who can present their ideas compellingly and build relationships within and outside their organization will often have an edge.

The Real Cost of Undervaluing Communication

By undervaluing communication, developers limit their professional growth. They may become pigeonholed as "code machines," missing out on opportunities to contribute to strategic discussions and to take on more significant roles within their organizations.

The Balance of Code and Conversation

This is not to say that coding skills are unimportant; rather, it's a call to recognize the symbiotic relationship between code and communication. The most successful tech professionals understand the power of both. They know when to let their code do the talking and when to step up and articulate their thoughts.

In conclusion, while "Talk is cheap, show me the code" captures the importance of concrete results, it paints an incomplete picture of what it takes to thrive in the tech industry. Communication is not just talk; it's the lifeblood of collaboration, leadership, and innovation. As developers navigate their careers, they would do well to invest as much in their communication skills as they do in their technical abilities, for in the landscape of professional growth, talk is not only not cheap—it's invaluable.

Pulumi Has Wowed Me

Jeff — Wed, 13 Mar 2024 10:52:59 +0000

As a programmer, there's always this urge to turn everything into code, hence the variety of xxx as code solutions. Even when it comes to diagramming, I prefer to use code, which led to the concept of diagram as code. I've discussed some related content in my previous article, "Quickly Overviewing the Domain Model of Code with tplant - Jeff Tian's Article - Zhihu."

But that's not all. We even want to store our secrets in code repositories! Secret as code. Of course, we can't store them in plain text. Hence, SOPS is a convenient tool that allows us to track changes to secrets using git, as detailed in "Encrypting Sensitive Information in Kubernetes Clusters - Jeff Tian's Article - Zhihu."

Is that enough? Not quite! We also hope to allocate and track changes to our infrastructure through code, so-called GitOps, or Infrastructure as code (IaC).

How do you do IaC? Feel free to share in the comments.

Let me start with how we do it.

Initially, we took a rather basic approach, using shell or PowerShell scripts, which is purely imperative. It was a hassle to tweak the scripts and verify the changes simultaneously. It was quite a headache.

Later, we moved on to Terraform, and since we primarily used AWS cloud, we also employed CloudFormation. This declarative approach significantly improved, though it fell short in the automation testing department. Moreover, writing the declarative files was somewhat dull; it wasn't programming but felt like writing HTML a decade ago. Strictly speaking, HTML is a markup language, not a programming language.

After comparing various options, our team recently decided to use Pulumi for IaC. Although I'm still getting the hang of it, the experience has been quite impressive, particularly in the following aspects:

Secret as Code is even better than SOPS.

As mentioned in "Encrypting Sensitive Information in Kubernetes Clusters - Jeff Tian's Article - Zhihu," after learning about SOPS, I've used it in several real-world projects. However, a significant issue I encountered was often forgetting to encrypt secrets before committing, leading to plain text ending up in the code repository. While there are ways to avoid this, it still leaves room for error. With Pulumi, to my surprise, there's no need for SOPS. It has the same functionality as SOPS, encrypting secrets within the code instead of saving them in plain text. But it's simpler and leaves no room for error because it provides alternative ways to retrieve plain text secrets rather than displaying them in the files.

Automated Testing

I never thought IaC could be like writing business logic with automated testing! That means you can now do TDD in your IaC projects! For example, you define the following secret information in your secrets.json file:

{
  "secrets": [
    {
      "pulumiSecretName": "rds-credentials",
      "awsSecretName": "/rds/{env}-{region}",
      "createAwsSecret": true,
      "kmsKeyIdOrAlias": null,
      "keys": [
        { "name": "username", "value": "master", "configKey": null },
        { "name": "password", "value": null, "configKey": "rds-password" }
      ],
      "description": "Secret storing credentials to RDS used by human users to access the database",
      "tags": {
        "from": "passwordstate",
      }
    },
    ...
  ]
}

In the above secret definition, we added a tag. You can use automated tests to verify that the final deployed resources contain the expected tags before actually deploying to production:

[Theory]
[ClassData(typeof(StackTestData))]
public async Task Should_CreateSecretsWithProperTags(string stackName)
{
    // act
    var resources = await RunDeployment(stackName);
    var names = GetService<ManagedSecretsResourceNames>();

    // assert
    var secrets = resources.OfType<Secret>().ToList();
    var expectedSecretsCount = Config.SecretsConfig.Secrets.Count * Config.DeploymentEnvironment.Environments.Count;
    secrets.Count.Should().Be(expectedSecretsCount);

    foreach (var secret in secrets)
    {
        var secretName = await secret.Name.GetValue();
        // ignore created secrets for different environments
        if (!secretName!.Contains(Config.DeploymentEnvironment.CurrentEnvironment.Name))
        {
            continue;
        }

        var secretConfig = Config.SecretsConfig.Secrets.Single(x => names.SecretName(x.AwsSecretName) == secretName);

        var secretTags = await secret.Tags.GetValue();
        secretTags.Should().NotBeNull();
        foreach (var tag in Config.DefaultResourceTags)
        {
            secretTags.Should().Contain(secretTag => secretTag.Key == tag.Key && secretTag.Value == tag.Value);
        }

        foreach (var tag in secretConfig.Tags)
        {
            secretTags.Should().Contain(secretTag => secretTag.Key == tag.Key && secretTag.Value == tag.Value);
        }

        secretTags.Should().Contain(secretTag => secretTag.Key == "pulumi-secret-name" && secretTag.Value == secretConfig.PulumiSecretName);
    }
}

Easter Egg: The Unexpected AI Feature

The team decided to use the C# version of Pulumi, which I found a bit daunting. However, I discovered that Pulumi offers an AI feature that answers any question I have. From what I've seen of the AI's guidance, it's focused on coding and does an incredibly reliable job of preventing any mishaps in the team (I'm still not fired at 35+).

Even better, although it seems only to write code on the surface, this AI can do anything. For instance, when I come across English words I don't recognize, I ask it to translate:

See? It can translate and even provides more thoughtful explanations than other AIs I've tried, including pinyin annotations!

Of course, you can use it directly in Chinese as well because it understands Chinese:

The most crucial point is that unlike OpenAI's ChatGPT or many other foreign AI assistants inaccessible to users in China, it is available directly from within China!

Another outrageous easter egg is that you can use it without logging in! Can you believe that?

Lastly, there are no limits whatsoever! It's incredibly generous; I've been using it for almost a month now, and it has never refused to answer my questions! There is no need to log in, let alone pay.

In one word: Phenomenal!

Migrating Part of a Code Repository While Retaining the Full Commit History

Jeff — Tue, 09 Jan 2024 06:41:33 +0000

The purpose of this post is to explain how to migrate code with commit history using the tool git-filter-repo.

Background

Recently, I undertook a task that required migrating a specific folder from one project into a new code repository to preserve the commit history. After some effort, I finally discovered the git-filter-repo tool, which perfectly accomplished this job. I am documenting this experience here.

Install `git-filter-repo`

To start, install git-filter-repo. The easiest way to do this on Mac is by using brew.

brew install git-filter-repo

It is an open-source tool, and the source code can be found at https://github.com/newren/git-filter-repo

Checkout a new branch

Create a new branch based on main branch in the original code repository for the partial migration.

git checkout -b feature/JIRA-123-github-migration

Filter the directories and files that need to be migrated

If there are these files or directories that need to be migrated:

File Lambda.sln
File Lambda.Worker.sln.DotSettings.use
Directory Worker
Directory Worker.Tests

If you'd like to migrate them to folder ~/repos/NewLambda, then specify the files or directories that need to be migrated and the target folder using the --path and --target options, respectively.

git filter-repo --path Lambda.sln --path Lambda.Worker.sln.DotSettings.user --path Worker --path Worker.Tests --target ~/repos/NewLambda

Check result

Confirm the migration results by checking if the directories have been successfully migrated and if the project files not in the migration scope are excluded. You can execute ls under ~/repos/NewLambda folder.

Verify the completeness of the commit history migration by using the command git log --oneline in the target directory, ~/repos/NewLambda.

Push the migrated to remote

If the migration is intended for GitHub, create a new repository on GitHub and add the remote origin to the local target directory.

Push the migrated files to the new repository on GitHub.

git push --set-upstream origin $(git branch --show-current)

Submit a PR

Finally, submit a pull request from the migrated branch to the main branch for team members to review.

These steps are to migrate a code repository and retain the commit history using git-filter-repo.

How can non-tech people understand asymmetric encryption?

Jeff — Tue, 19 Sep 2023 12:28:23 +0000

How many total sock inspections should be expected to perform?

Jeff — Wed, 14 Jun 2023 11:49:26 +0000

Farhad has just washed and dried all his socks at the laundromat. Now he wants to pair the socks up. (Each sock shares a unique design with its pair.)

Farhad starts with a total of 20 socks (10 pairs). He picks up and holds one sock in one hand. With the other hand, he picks up the other socks one-by-one until he finds the matching sock.

How many total sock inspections should Farhad expect he'll perform to finish pairing 20 socks?

The answer is 65.

The exact number of socks Farhad picsk up to pair his first sock depends on luck. On average, we'd expect him to pick up 11 socks to match his first pair. This estimate comes from averageing the lucky and unlucky numbers. That average is $\frac{20+2}{2}=11$ if he has 20 socks.

Similarly, for the 2nd pair we'd expect him to pick up $18+22=10\frac{18+2}{2}=10$ socks.

And so on, and finally 2 to match the last pair. This comes out to a total of sock $11+10+9+8+7+6+5+4+3+2=10⋅11+22=5⋅13=6511+10+9+8+7+6+5+4+3+2=10\cdot\frac{11+2}{2}=5 \cdot 13=65$ pick-ups.

Use TypeScript to make DDD come true

Jeff — Thu, 22 Jul 2021 11:54:37 +0000

DDD

Domain Driven Design is popular and even became a de facto standard for enterprise technology team, however, it's only showcases, not the real implementation. How many times that you see the fancy design diagrams and at them same the poor code?

Many people prefers design first, what implies that code is the implementation, and only the slide shows are design. But actually, code is design.

Code = Design = Model = Documents

If not the case, then everytime you change the code you need to update the UML class diagrams and database E-R design documents. And eventually these kind of documents becomes unreliable gradually because you can't make sure that they are updated in time.

In fact, code is more suitable for expressing the designs, and source code is a document indeed, can be used to describe the current product's design decisions perfectly.

If developer created a domain model by code which is consistent with what in a domain expert's brain, then the source code is the most efficient, realtime model no doubtedly.

The limit of the equation of Code = Deisgn = Model = Documents is whether the domain expert can read the code. So the easy to learn, expressive and intuitive programming language will have strong benefits in the process of creating domain models.

Domain Modelling

Domain modelling is the most important part in DDD for developers as it requires developers have good abstraction, and it differs from traditional database modelling, and need developers to map the domain knowledge into the code models through the most efficient programming technic.

In the long run, the object oriented language is the first choice of domain modelling, some OO skills can be used to do the domain model abstraction. In the contrary, the functional programming langauges are typically thought to be suitable only for data processing, scientific computing, etc.

TypeScript

But this article shows that TypeScript, which has many functional programming features (
TypeScript's type system fully meets the functional programming requirements), can be used to do the domain modelling, and thanks to its type system and related tool chains, TypeScript should be considered as the best language to make DDD landing.

TypeScript's type system

Comparing to OO, you only need to know a few grammer and it's enough to start domain modelling, so in terms of simplicity, algebraic data type is more suitable for domain modelling so as to make the domain models be documents.

Type

All kinds of programming languages provide primitive types by design, such as string, bool, number, etc.

In TypeScript, you can use the keyword type to compose larger types:



type Name = {
  firstName: string
  middleName: string
  lastName: string
}

The usage of the above is obviouse, and besides this kind of usage, the keyword type has other usages, which is not a trivial feature. It can help you record the domain knowledge into domain models, for example:



const timeToFly = 10

you can not guess the domain knowledge at first glance at the above code. How to make sure what the 10 means? Look up in a document? No, you need to tell yourself that code is document, so you improve your code as follows:



type Second = number
const timeToFly: Second = 10

Type Or

In TypeScript, they are called as Union Types, which can be built by the symbol |:



type Pet = Fish | Bird

So Pet is in type Fish or Bird. In general, functional programming languages have strong pattern match capability to process this kind of type. But the sad thing is TypeScript has limited pattern match capability so you can often see some string literals present in the types to distinguish different types.

Type And

In TypeScript, they are called as Intersection Types, which can be built by the symbol &:



type ABC = A & B & C

The above code tries to say that type ABC contains all A, B and C's properties.

Define Function Types

In TypeScript, there were no differences between function and other types, so you can define functions by using the keyword type:



type Add = (a: number) => (b: number) => number

The above code shows that Add is a function who accepts 2 numbers as arguments and returns a number.

Using code to share domain knowledge



type CreditCard = {
  cardNo: string
  firstName: string
  middleName: string
  lastName: string
  contactEmail: Email
  contactPhone: Phone
}

Notice that we can easily write the above code by just having the knowledge showed previously, to describe the CreditCard payment method. Also please notice we don't use class here.

But is it a reliable domain model? If not, where is the problem?

The most serious problem of the above code is that it didn't record the domain knowledge which should be owned by it inside of it. Let me ask some questions:

Question: can middle name be empty?
Answer 1: Not sure, need to check document.
Answer 2: Maybe? middle name can be null.

Modelling for the nullable type

In functional programming languages, the nullable types can be defined as Optional. Although null is valid in TypeScript (Note: we can enable strictNullChecks to enforece the null check), but in functional programming, you can only use Optional type to express nullable type.

If the domain expert tells you that middle name can exists, or be empty. Plese notice the word "or", indicate that we can use Union Type to model for the nullable type:



type Optional<T> = T | null

A simple Optional is just a Type Or. The improved code looks as follows:



type CreditCard = {
  cardNo: string
  firstName: string
  middleName: Option<string>
  lastName: string
  contactEmail: Email
  contactPhone: Phone
}

Avoid Primitive Obsession

Question: Can we express cardNo with string? If so can it be any string? Is firstName an arbitrary length string? Obviously you can't answer these questions as this model doesn't contain relative domain knowledge.

You may use string type for cardNo during programming, but in domain model, string can't express the domain knowledge of cardNo.

cardNo is a 19-length string starts with 200, name is a string whose length is less than or equal to 50. As such, the domain information can be implemented by type alias:



type CardNo = string
type Name50 = string

With the above types, you now have chance to include the cardNo business rules inside domain models by defining function.



type GetCardNo = (cardNo: string) => CardNo

If a user typed in a string with 20 length, then what will the function GetCardNo return? null? or exception thrown? Actually functionaly programming has more elegant way such as Either Monad or Railway oriented programming to handle errors. At least we can present the function's signature by Optional:



type GetCardNo = (cardNo: string) => Optional<CardNo>

The function expresses the validation process clearly, if you user typed in a string, then returns a CardNo type or empty.



type CreditCard = {
  cardNo: Optional<CardNo>
  firstName: Name50
  middleName: Optional<string>
  lastName: Name50
  contactEmail: Email
  contactPhone: Phone
}

So now the code is full of domain knowledge, and these types can be used as unit tests as well. For example, you'll never assign an email to contactPhone, as they are not string, so in turn they represent different domain knowledge.

The Atomicity and Composibility of the domain models

There were 3 names in the above domain model, can they be changed separately? for example, change middle name only? If not how can we encapsulate the knowledge of atomicity change into the domain model?

In fact we can easily extract Name and Contact types and compose them:



type Name = {
  firstName: Name50
  middleName: Option<string>
  lastName: Name50
}
type Contact = {
  contactEmail: Email
  contactPhone: Phone
}
type CreditCard3 = {
  cardNo: Optional<CardNo>
  name: Name
  contact: Contact
}

Make the error state can't be present

There is an important principle in domain modelling, which can be understood as: The domain models you built should have as many static validations and constraints as possible to make error occurs in compilation time instead of run time, so as to avoid the chance for mistakes. In fact all the domain modellings are following this principle, for example, the Email type and Phone type in the above code. Why not use string? Because string is lakcing of domain knowledges, which gives developers chances to make mistakes.

Let's see another example. The above domain model has a contact type, which contains an Email and Phone properties. After payment done, system can utilize these 2 properties to send notification to user, so there is a rule generated: User must fill in Email or Phone to receive payment messages.

First of all, the above domain models are not matching this business rule, because both Email and Phone are non-nullable type, which means these 2 properties are both required.

Can we change both of them to be Optional?



type Contact = {
  contactEmail: Option<Email>
  contactPhone: Option<Phone>
}

Obviousely we can't do this, as it violets the principle of Make illegal state unrepresentable, so gives chances for coding mistakes. Your domain model represents an illegal state, that both Email and Phone can be empty. You may argue that my xxService will do the validation, to make sure they'll never be both empty. Sorry, we hope our domain model can encapsulate this domain knowledge. For xxService, it's unrelated to domain model. So can we express this rule in the modle model or not? The answer is yes! Because there is a "or" in the rule, so it implies that we can use the type Or (union type) to express this relationship:



type OnlyContactEmail = Email 
type OnlyContactPhone = Phone
type BothContactEmailAndPhone = Email & Phone
type Contact = 
  | OnlyContactEmail
  | OnlyContactPhone
  | BothContactEmailAndPhone

Conclusion

By using TypeScript to guide the domain modelling, we can avoid classes and sub classes, let alone the keywords abstract and bean, etc.

To measure how good or how bad a domain model is, we need to judge

is the domain model contains as many domain knowledges as possible, can it map the domain models inside domain experts' brains?
Can domain model itself be the documents, so everyone can share and communicate with it?

At the mean time, a framework should have as less jargons as possible. For example if you created a domain model class named AbstractContactBase, you increased the complexity of the system without any help on domain models sharing.

Bonus

If you use TypeScript, not only you can build a rich model models, but also you can utilize some tools to generate UMLs from the code. So you can birdview the project's domain models very quickly!

tplant

tplant is that kind of tool which I participated in it.

Screen recording of usage

Text version of usage



npm install --global tplant
cd your-typescript-project-folder
tplant --input src/**/*.ts --output output.svg
open output.svg

Functional style programming is awesome (isomorphic example)

Jeff — Mon, 08 Mar 2021 05:23:27 +0000

This post will present a look and feel about functional style programming, gives you a glance about what it would look like if we wrote programs in a functional programming way.

It's not a real strict functional programming guide, it just shows how interesting yet powerful if we handle problems in a functional programming mind.

Problem

It's quite common challenge to ask you implement an algorithm to detect if 2 strings are isomorphic during a programming job interview, there might be many answers on it. Let's do it again.

Tools

A browser. So we can write pure JavaScript to implement it by pressing F12 with a running brower at hand.

By analyzing the requirement, we can see actually the term isomorphic reflects the requirement quite well, which means having the same form, in other words, the forms (or structures) in a way are the same(equal). So we can just write some code to express the meanings:

const isomorphic = equalBy(structure)

So far we have the signature of the function equalBy, let's implement it:

const equalBy = fn => (a, b) => fn(a) === fn(b)

It's natural and self expressed.

Now we take a closer look into isomorphic, we found it cares only the structure of the string, and doesn't give a shit to the detail characters in it. So how to we express the form (or structure) of the string?

By examining the examples given in the requirement we come up with an idea to express the structure of a string by the character indices in the string, which can be expressed by numbers so it abstracts from the detail characters. So we write the following code:

const structure = s => [...s].map(c => s.indexOf(c)).join('-')

This line of code is a little bit long, let's test it and document it:

console.assert(structure('aabbcc') === '002244', 'A structure of a string can be expressed through the indices of the characters in it');

By far we have both equalBy and structure, so isomorphic is ready to run! We can write some tests to show it:

console.assert(isomorphic('', ''), 'empty strings are isomorphic');
console.assert(isomorphic('aabbcc', 'aabbcc'), 'strings are always isomorphic with themselves');
console.assert(isomorphic('aabbcc', 'zzxxyy'), 'if the characters have the same indices sequence, then the strings composed by them are isomorphic');
console.assert(!isomorphic('aabacc', 'xxyyzz'), 'even if the character indices are the same, however the sequences are not all the same, then the 2 strings composed by them are NOT isomorphic');
console.assert(!isomorphic('aaabbcc', 'xxyyyzz'), 'if any character indices are different, then the strings composed by them are NOT isomorphic');
console.assert(!isomorphic('abcdefghijk', 'abcdefghijba'), 'if the lengths are different, then the strings are NOT isomorphic');

We ran the tests, all pass!

Summary

So the implementation code for isomorphic is only 3 lines in total:

const equalBy = fn => (a, b) => fn(a) === fn(b)

const structure = s => [...s].map(c => s.indexOf(c)).join('-')

const isomorphic = equalBy(structure)

You can see it's a pointless way of writing code, besides cool, it solves problem elegantly even to a simple extend!

You can try on your browser or check it in leetcode too: ~~https://leetcode.com/submissions/detail/465004270/~~ https://leetcode.com/submissions/detail/530009145/

How to get logs from all pods of a service in a cluster?

Jeff — Wed, 10 Feb 2021 02:38:18 +0000

Background

You deployed your app or service to a kubernetes cluster and with multiple instances, and you want to quickly search some logs by keyword. But the service is running on multiple instances in the cluster, so we need a way to gather the relevant logs from all instances instead of pod by pod.

Fake "Solutions"

By googling you might get some answers like

kubectl logs service/your-service-name | grep "xxx"

But this command is not you want, because it just search the log from one pod among the multiple instances. So if you get empty result it doesn't mean there were no relevant logs.

Or someone encourage you execute the following:

kubectl logs -l app=your-app-name | grep "xxx"

This might or might not work, it depends on how the app name was defined in the deployment file, if the app names are different across the instances, because for example, an unique suffix will be appended to the common readable name for each pod. In this case you will never get any logs by the previous command.

Better way

If your deployment file gives unique names to each instance, then you need to first get which labels are fixed across different instances. For example, you can randomly choose a pod, and execute:

kubectl get pod/your-pod -o template --template='{{.metadata.labels}}'

This command will give you result similar to

map[branch:develop namespace:jeff-tian pod-template-hash:54ff684c58 role:cool-app run:cool-app update-timestamp:1608695126059]

From the result we can see that the role is fixed, so we can get the logs in the following way:

kubectl logs --selector role=cool-app | grep "xxx"

Even better way

Send logs to Elasticsearch, and query the logs through Kibana. But this way requires the deployment and integration with ELK, and if you send the logs in real time (for example, using pinojs/pino-elasticsearch), then there is no log latency, only need to change a few application code. If you don't want to change the code, then you can use, filebeats for example, to gather the logs, but in this way you need to solve the log latency challenge.

Comparing to get the logs by the command line, ELK way is obvious more powerful yet need more work to do, which worth a dedicate post to share it in the future.

InversifyJS 中文文档

Jeff — Thu, 31 Dec 2020 12:12:00 +0000

你的项目中有用到 JavaScript 吗？如果有，那么依赖注入是怎么实现的？强烈推荐使用 InversifyJS！

2020年最后一天，工作效率可以说是非常高了。
早上买完域名（https://doc.inversify.cloud/zh_cn ），开始翻译 InversifyJS 文档，到下班时间终于翻译完成。加班部署上线，现在新鲜出炉的中文文档来了！

InversifyJS 小巧优雅又五脏俱全，可以说是一个相当棒的轮子了。如果用得爽，想自己造一个又不知道如何下手，那么：

给你一个 Bonus：这篇文章手把手教你从零开始撸一个 Toy Inversify：https://jeff-tian.jiwai.win/posts/inversion-of-control-implementation-based-on-typescript-3fl6/ ，快来看一看吧！

Connect to external mysql server via phpMyAdmin

Jeff — Mon, 21 Dec 2020 07:43:20 +0000

Background

After I deployed my phpMyAdmin to my kubernetes cluster and ran it, I was astonished by the UI, which only allows you type username and password, there is no way to input my mysql server's host!

Analysis

Seems phpMyAdmin by default only allows you connect to mysql server deployed in the same machine with the phpMyAdmin itself, in terms of this I would say I love adminer more!

Solution

You need to set PMA_HOST to your mysql server host before running the phpMyAdmin instance.

So if you are deploying your phpMyAdmin to your kubernetes cluster, you should edit the deployment.yaml as follows:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: phpmyadmin
    tier: backend
  name: phpmyadmin
spec:
  minReadySeconds: 5
  selector:
    matchLabels:
      app: phpmyadmin
      tier: backend
  template:
    metadata:
      labels:
        app: phpmyadmin
        tier: backend
    spec:
      imagePullSecrets:
        - name: harbor-odp
      containers:
        - image: "phpmyadmin"
          env:
            - name: PMA_HOST
              value: your-my-sql-db.yourhost.com.cn
          imagePullPolicy: Always
          name: phpmyadmin
          ports:
            - containerPort: 80
              name: http
              protocol: TCP
          resources:
            limits:
              cpu: 500m
              memory: 128Mi
            requests:
              cpu: 250m
              memory: 64Mi

[Solved] adb install successfully but can't open the app on Huawei phone

Jeff — Mon, 07 Dec 2020 10:15:44 +0000

Issue

You installed the apk successfully to your huawei phone via adb install:

adb install xxx.apk
Performing Streamed Install
Success

But after the installation you can't open it as the open button is disabled, nor can you find or search it in your phone.

Analyse

There is a private space feature in huawei phone, and you turned it on.

Solution

Go to settings/privacy, you'll see the private space. Switch into that space and you can find the app.

Or you can delete the private space totally to avoid this issue in the future.

DEV Community: Jeff

How to create a WeCom App to enable WeCom Login for the Web app

Login to WeCom Console

Create an app

Note down app credentials

Specify the callback domain

Configure the Trusted IP List

Beyond the Code: The Undervalued Art of Communication in Tech Careers

The Misconception of Code as King

Communication: The Unseen Pillar of Success

Why Talk Isn't Cheap

The Real Cost of Undervaluing Communication

The Balance of Code and Conversation

Pulumi Has Wowed Me

Secret as Code is even better than SOPS.

Automated Testing

Easter Egg: The Unexpected AI Feature

Migrating Part of a Code Repository While Retaining the Full Commit History

Background

Install git-filter-repo

Checkout a new branch

Filter the directories and files that need to be migrated

Check result

Push the migrated to remote

Submit a PR

How can non-tech people understand asymmetric encryption?

How many total sock inspections should be expected to perform?

Use TypeScript to make DDD come true

DDD

Code = Design = Model = Documents

Domain Modelling

TypeScript

TypeScript's type system

Type

Type Or

Type And

Define Function Types

Using code to share domain knowledge

Modelling for the nullable type

Avoid Primitive Obsession

The Atomicity and Composibility of the domain models

Make the error state can't be present

Conclusion

Bonus

tplant

Screen recording of usage

Text version of usage

Functional style programming is awesome (isomorphic example)

Problem

Tools

Summary

How to get logs from all pods of a service in a cluster?

Background

Fake "Solutions"

Better way

Even better way

InversifyJS 中文文档

Connect to external mysql server via phpMyAdmin

Background

Analysis

Solution

[Solved] adb install successfully but can't open the app on Huawei phone

Issue

Analyse

Solution

Install `git-filter-repo`