My 2020 Review — Tech Edition

Looking at the half-finished “2019 Year-End Summary” in my notes always feels inexplicably amusing. Then I want to say time really flies—it’s that time of year again to write a recap and review. 2020 was the most surreal year I’ve lived through: the pandemic, the financial crisis, a world order undergoing “changes unseen in a century”… Under the onslaught of so much information, it’s hard to have the space and awareness for independent thought. Luckily this article is only a recap of 2020 on the technical side, otherwise I don’t know when I’d ever finish writing it.

First, let’s look at an overview of my code commits on the two code hosting platforms I mainly use, GitHub and Gitee.

In Q1, commits were concentrated on GitHub. Before that I only used Gitee as a domestic backup. As US sanctions kept tightening, and after GitHub announced several times that it was blocking certain countries, I felt that foreign stuff still isn’t all that reliable, so I switched to committing code to Gitee and using GitHub as a backup. Later the company also started using Gitee Enterprise, so in the second half of the year there were especially many commits on Gitee~

I took a look: the main technologies (languages) I worked with this year, ranked by code volume: Python -> C# -> Flutter(Dart) -> Frontend (JS) -> Kotlin -> Go -> Java -> PHP

Below I’ll pick a few and talk about related applications and takeaways~

Python

Python ranking first is no surprise. Python has always been my main language. The main areas I used it in this year were web backends, machine learning (deep learning), data analysis and processing, crawlers, desktop apps, and so on—all things that make money in production work. Python is both fast and stable. For example in web development, with Django I can finish in half a day what would take a statically typed language at least a full day. Twice the result with half the effort. Life is short, I use Python—that line really isn’t just talk~

Python Web

On the Python web backend side I mainly used the Django framework. Building on previous casual use I went a bit deeper, read some of the framework source (and wow, it’s impressive), and this year I also started using DRF, the standard for building RESTful APIs, and likewise chewed through some of its source (PS: a lot of DRF features you simply wouldn’t know how to use without reading the code; the docs could use improvement)

Because at work I mainly use Django for backend services, I spent quite a bit of time learning and researching this framework this year, and even made a rapid-development template myself. Features include: Docker deployment, caching, an automatic business-code generator, API rate limiting, Django Admin captcha, login attempt limits, hiding Rest Framework’s default API homepage, and so on. The code is also open-sourced~

• Project homepage: https://deali-axy.github.io/DjangoStarter/
• Code: https://github.com/Deali-Axy/DjangoStarter
• Gitee code homepage: https://gitee.com/deali/DjangoStarter

Some of my notes on tinkering with and researching Django I published as a column. Here’s a selection:

• Django Development Highlights Column (Zhihu): https://www.zhihu.com/column/c_1270023754924769280
• Using Django-Filter: https://zhuanlan.zhihu.com/p/291336772
• Experience notes: a few ways to customize details of drf-yasg API docs: https://zhuanlan.zhihu.com/p/269499888
• Adding custom Actions to Django Admin and removing the restriction that objects must be selected: https://zhuanlan.zhihu.com/p/163467332
• Django middleware: implementing an IP whitelist for the Admin backend: https://zhuanlan.zhihu.com/p/163455319
• Django rapid development practice: a guide to configuring the DRF framework and xadmin: https://zhuanlan.zhihu.com/p/100135134
• Finish backend development in one hour: Django Rest Framework development practice: https://zhuanlan.zhihu.com/p/113367282
• “Forcibly” using the MVVM design pattern in Django: https://zhuanlan.zhihu.com/p/136571773
• Containerized deployment practice for Django apps: https://zhuanlan.zhihu.com/p/128500053
• Django’s signal mechanism: https://zhuanlan.zhihu.com/p/135361621
• Adding captcha and multiple-login-attempt limits to Django Admin: https://zhuanlan.zhihu.com/p/138955540
• Talking about Django app deployment and performance: https://zhuanlan.zhihu.com/p/152679805
• Configuring the Django-TinyMCE component to support image uploads: https://zhuanlan.zhihu.com/p/162915134

Due to length I’ll only compile this Django portion. For more articles you can search my WeChat official account or Zhihu… (being lazy)

Besides Django, I also tried FastAPI, the async framework that was very popular this year—a framework that wants to compete with Go on speed, and that also sells static typing (100% type-annotation coverage) as a feature. Emm, it feels as simple and convenient as Flask to use, but like Flask, the framework itself doesn’t provide many features; to actually develop with it you need a whole pile of third-party libraries. You can use Flask’s ecosystem, and the outlook should be pretty good~ But the Django all-in-one suite is still more comfortable to use hhh

Machine (Deep) Learning

This year I also made some small things in machine learning. At the start of the year I continued with my NLP, including sentiment analysis, dialogue prediction, and the like… nothing particularly worth saying. What’s worth mentioning is that I got into BERT, and it really is quite strong. I made a Chinese text classification project (mainly classifying news articles), and the results were pretty good. Likewise the code is open source, help yourself

• BERT classifier code: https://github.com/Deali-Axy/bert-chinese-classifier

Besides improving the NLP work I’d already started, this year I also got into recommendation systems. Combined with crawlers, a metasearch engine, and the text classification mentioned above, I made an aggregation reading & recommendation app similar to Toutiao, which helped me take first place in the graduating class for my thesis project and Outstanding Graduate. Turns out four years of university weren’t a complete waste~

(Inserting a video of this App here)

Later at work I also did some computer vision stuff, researching several tech stacks for face detection and recognition. Because our service had to be deployed in two parts—one on a GPU server, one on NVIDIA’s embedded device (Jetson)—on the server we had plenty of performance to spare so we mainly looked at accuracy; on the embedded device we could only use lightweight algorithms, no longer chasing accuracy, just hoping performance wouldn’t collapse~

Then I used MTCNN, FaceNet, ResNet, and several of OpenCV’s machine-learning detectors, mixing and matching them. A colleague used YOLO for another object-detection part; I just tagged along~

The rest—data analysis, crawlers, desktop (PyQt)—was mostly work-related, and fairly straightforward with nothing particularly worth recording. I didn’t write blog posts at the time (maybe I’ll pad some out later if I have time)

C#

Now for the C# section. This is an elegant, fine language. The .NET Core platform also developed rapidly this year; by year-end the official .NET 5 platform had already been released, intending to unify everything. But it seems the ecosystem didn’t make any major progress over the course of the year, so until the ecosystem has a big development I won’t make the .NET Core stack my mainstay for now. I’ll keep following and learning though~

On the .NET Core side it was mainly web development stuff. At the start of the year I originally planned to use ASP.NET Core as the backend framework for my thesis project, but later due to time I switched to Django. I did, however, seriously make a practice project and put it on GitHub. Code below.

• Code: https://github.com/Deali-Axy/AspNetCore2-Learning

At the time I hadn’t been using ASP.NET Core for long, and a lot of things were unfamiliar. But middleware, dependency injection, and so on are pretty similar to Spring’s approach (you ask why it’s different from Django? Dynamic languages can get by without DI—those who know, know). Later I continued learning and used these technologies to make some things, mainly getting familiar with the MVC stack. Although MVC isn’t that useful anymore, you can’t beat how fast it is for solo development. ASP.NET Core’s MVC isn’t particularly amazing to use, but the features are quite rich and overall performance is decent (though I still find Django’s MVC more natural)

Then I followed Yang Xu and learned some ORM, RPC, WebAssembly, and the like. Most importantly I also systematically reviewed C# fundamentals, and felt I benefited a lot. Unfortunately I didn’t have enough time to finish all the courses. Hoping in 2021 I’ll get through all of Yang Xu’s classes~

Later I also dabbled a bit in the ABP vNext framework, and learned some things about gRPC, microservice gateways, identity centers, and monitoring systems, so I can say I have some understanding of the overall .NET Core ecosystem. Later I also used some .NET Core in production, for example the company’s new data middle platform and the backend + PC client of a mini program. Felt pretty good, just that I’m still not especially proficient, so development efficiency isn’t as high as with Django…

Same as before, I wrote some articles while learning and using it. Here’s a selection:

• (This one was featured and pinned on the homepage of “.NET Developers’ Home”—cnblogs) A 6,000-word long piece I spent a week putting together! Deep thoughts on the essence of technology, casual notes on simple practice with the cross-platform development framework ASP.NET Core: https://zhuanlan.zhihu.com/p/267938409
• ASP.NET Core study notes: Getting started: https://zhuanlan.zhihu.com/p/105443116
• ASP.NET Core study notes: (2) Views, models, persistence, files, error handling, logging: https://zhuanlan.zhihu.com/p/105953794
• ASP.NET Core study notes: (3) Building a chat room with the SignalR real-time communication framework: https://zhuanlan.zhihu.com/p/106321863
• ASP.NET Core study notes: (4) Getting started with Blazor WebAssembly: https://zhuanlan.zhihu.com/p/107262924
• ASP.NET Core study notes: (5) Build and deploy: https://zhuanlan.zhihu.com/p/203298625

Because of the various crawlers, data analysis, and machine learning in daily work, I also used C# for crawlers and data processing, and the efficiency is pretty high. Writing crawlers in Python is the fastest and most convenient, but you can’t get around the deployment hassle. C# is different—once you write it, it can be deployed on all platforms. I can even make a UI with WinForms; on Windows you don’t need to install anything, just open and use it. Linux and Mac also have corresponding UI frameworks. Through the .NET Standard, the underlying layer can share one set of code. Very comfortable.

But one really annoying thing about .NET projects is that there can only be one main entry point. Although that sounds like a given, it’s simply inconvenient for crawlers. When you often need to write something to run separately for verification, you usually have to create a new project in the solution to test, and re-import all the dependencies, which is a hassle… There are other alternatives like unit tests, LINQPad, dotnet script, etc., but they’re still not as convenient as Python, Java, Kotlin, Dart, and the like~ (Go is like this too, by the way)

PS: This year I used Selenium a lot for crawlers. C# + Selenium with the IE driver—even ancient systems were all brought fully into line~

.NET Core has a promising future~

Flutter

Time has arrived in the year 0202. If we were to vote for developers’ favorite frontend technology, Flutter would definitely make the list… Although we’ve been complaining about how many pitfalls it has and how unstable it is, you can’t stop people’s enthusiasm for Google’s tech. Flutter’s ecosystem is pretty good now; Chinese communities, tutorials, and chat groups are everywhere. It might be making fewer and fewer people learn native app development (Android / iOS) purely…

This year’s Flutter work was mainly on developing that aggregation reading & search app for my thesis project, comprehensively applying a lot of things I’d accumulated before. Besides that I made a Flutter crawler framework and open-sourced it on GitHub (address below). Emmm, and I also routinely updated the Minimalist Poetry app I made in 2019 with a few minor versions…

• Flutter crawler framework: https://github.com/Deali-Axy/flutter_spider_fx

Although the final result of that crawler framework wasn’t perfect, I still gained a lot, mainly going deeper into the Dart VM’s EventLoop and Isolate. At the time (early 2020) Dart’s Isolate still had quite a few shortcomings, which meant this crawler framework couldn’t actually achieve true multithreaded crawling… Not sure if the Dart team has improved it since…

Because I came to Flutter from native Android development, for a lot of things Android has I’d look for Flutter replacements, like EventBus, ORM, OkHttp, and so on. Right now I still haven’t found a relatively mature, easy-to-use ORM for Flutter; the others are OK. For simpler things you can just call native. The frustrating part is that the Flutter framework updates too fast, with frequent Break Changes, and many third-party libraries often can’t keep up with Flutter’s update speed, so… upgrade cautiously (if it works, just make do).

A compilation of Flutter articles:

• Run crawlers on your phone! A first look at a Flutter crawler framework~: https://zhuanlan.zhihu.com/p/108028434
• Setting Android and iOS splash screens in Flutter cross-platform app development: https://zhuanlan.zhihu.com/p/262251346
• Behind the development of Minimalist Poetry: Flutter mobile app rapid-build practice—state management, internationalization, data persistence, performance optimization (1): https://zhuanlan.zhihu.com/p/100235769
• Flutter mobile app rapid-build practice—state management, internationalization, data persistence, performance optimization (2): https://zhuanlan.zhihu.com/p/100763432

Frontend

Although I write frontend quite often (and the code volume isn’t small), I’m still not very proficient. Maybe because I never systematically learned frontend, I often get tripped up by JS. Luckily I have a master to carry me~

This year I encountered quite a few new frontend things. At first I wanted to put together a simple admin backend, and discovered the ancient LayUI. It was even pretty simple and handy to use. But on Zhihu I saw a lot of professional frontend people criticizing it, basically about modularization issues. I think LayUI really is, as its official site says, a framework that’s very friendly to backend developers—you don’t need a lot of frontend knowledge, just copy-paste and you’re done~

I discovered a Bootstrap-like frontend styling framework called Semantic UI. The semantic class names are actually kind of interesting. Tired of Bootstrap’s default styles, Semantic UI’s interface is also a breath of fresh air. I haven’t used it in depth though, just looked it over roughly. After getting used to Bootstrap, suddenly switching to these semantic classes feels a bit unfamiliar, but I have a feeling it’s a good thing. I’ll keep following it. Some Bootstrap sites could be rewritten with Semantic UI; the workload shouldn’t be too big~

Then because I took on a project that needed a mini program, and time was tight—only three days—I used the well-known uni-app and grinded it out. I ran into quite a few pitfalls along the way. Although uni-app’s ads claim it supports seven or eight platforms and is super convenient and all that jazz, the docs aren’t great. A lot of things aren’t spelled out in the documentation; you have to search their forums and such, which is pretty annoying. And different platforms have different pitfalls. Luckily I only made a WeChat mini program; if I had to do others I don’t know what other weird issues I’d run into. Terrifying.

Later while browsing online I found a mini-program framework called Taro that’s also pretty good, but I haven’t used it yet. Might take a look if I get the chance.

At year-end, on a master’s recommendation, I started getting into React. Really nice. With a Flutter foundation, learning React is almost too easy. Reactive UI development is genuinely great. Now I just need a decent styling framework to pair with it. I’ll keep following~

Oh right, there’s also Vue. Two-way binding is well suited to admin backends that need lots of forms, but it feels like there’s too much related stuff. I still prefer React~

PS: There’s just way too much frontend stuff…

Kotlin

I started with Kotlin in 2019. It’s said to be replacing Java—not sure if it can achieve that goal before Java is phased out.

Kotlin’s language design is really great. Functions as first-class citizens—I like this design, much better than C#~

This year I used Kotlin + Spring Boot to make a website, with Ktorm as the ORM. There were still some things I wasn’t used to. Later I wrote a recap post and complained a bit in it, and it got seen by Ktorm’s author… Then I added him on WeChat and received some education from the expert…

Compiled two articles:

• Developing RESTful APIs with Kotlin and Spring Boot: https://zhuanlan.zhihu.com/p/146733027
• Developing RESTful APIs with Kotlin and Spring Boot (2): custom config, CORS, pagination: https://zhuanlan.zhihu.com/p/147523200

Besides that I used Kotlin to write Android. Ever since Android could be written in Kotlin it’s been so comfortable. Being able to develop Android without writing tedious Java code is really nice~

Go, Java, PHP

Last among the language stacks, a word on these three. I’d encountered Go before, and continued learning some this year. Because after compiling to native code deployment is very convenient, it’s handy for making small things sometimes. But for writing business logic it’s still not as good as Java, C#, Python, and the like…

On the Java side it was mainly writing some Android, maintaining apps I’d previously published. At that time I hadn’t learned Kotlin yet, so it had to be Java…

I still want to write a few articles about Android development, but my state at year-end was poor and I was a bit lazy—haven’t posted a new article in almost two months… But I’ve basically finished one about Android development; I’ll publish it after polishing.

I hadn’t used PHP in a long time, but recently I needed to heavily modify some WordPress plugins and themes, so I used it a little bit~

Other

This year I used spare time to grind some algorithm problems. Before I was always making various production applications and hadn’t focused on algorithms. This year whenever I had time I did some, and it felt pretty interesting—a way to relax when tired.

I also attended several training sessions and competitions this year. Although I did pick up a few awards, they don’t compare to when I was in school…

The training did let me encounter a lot of things I didn’t understand before. In October I attended cybersecurity training (though I didn’t learn it very well), but it really opened the door to a new world. Encryption/decryption, reverse engineering, penetration—these were all things I’d long aspired to. Having half a month of systematic study was truly beneficial, but I feel I still didn’t learn thoroughly enough this time; there’s a large amount of knowledge I still need to fill in…

In December I attended big-data-related training, systematically learning about cloud computing fundamentals, distributed storage, distributed computing, high-availability architecture, and more. This is even more helpful for actual work, but I still need to keep practicing on the job to form my own knowledge framework~

In Closing

2020 went by too fast. Over the past year, in various respects there was still some gap from what I’d envisioned. Not particularly satisfied. I feel I’ve gotten lazier and lazier, efficiency isn’t high, and I don’t have the motivation to finish many of the things I’d planned…

There were some improvements though. This year I didn’t spend as much time on tech, started reading books and various social commentary, and also took a few exams along the way, gaining some different things. Of course there are quite a few regrets too, for example the WeChat official account wasn’t operated very well, growth this year wasn’t high (the self-media dream shattered), all sorts of things. In the end it’s always my own reasons. All I can say is: keep working hard going forward!

PS: I haven’t updated articles in a long time recently (this recap took more than a week). I’ve already finished several technical-notes articles; they’ll be published one after another after this recap goes out~

Welcome to Chat

Programming Lab focuses on exploring popular new internet technologies and team agile development practice. On the WeChat official account 「Programming Lab」, reply linux, flutter, c#, netcore, android, kotlin, java, python, etc. in the backend to get related technical articles and materials. You can also leave a message in the official account backend with any questions~