This tool calculates the public key from a private key using elliptic curve cryptography with the NIST P-256 curve.

ECDH Key Exchange

The Elliptic Curve Diffie-Hellman (ECDH) key exchange allows two parties to establish a shared secret over an insecure channel:

1. Party A generates private key a and calculates public key A = a × G
2. Party B generates private key b and calculates public key B = b × G
3. Both parties exchange their public keys
4. Party A calculates shared secret: S = a × B
5. Party B calculates shared secret: S = b × A
6. Both parties arrive at the same shared secret S = a × b × G

Security Properties

• The shared secret cannot be derived by an eavesdropper who only knows the public keys
• Based on the computational difficulty of the Elliptic Curve Discrete Logarithm Problem (ECDLP)
• The X coordinate of the shared point is typically used as the shared secret for further cryptographic operations

How It Works

The tool implements elliptic curve point multiplication using the NIST P-256 curve parameters:

• Prime field: p = 2^256 - 2^224 + 2^192 + 2^96 - 1
• Curve equation: y² = x³ - 3x + b (mod p)
• Base point: Pre-defined generator point G
• Public key calculation: Q = k × G where k is the private key

Key Features

• Input validation: Ensures private key is valid hex and within curve order
• Secure arithmetic: Uses BigInt for precise modular arithmetic
• Efficient algorithm: Double-and-add method for scalar multiplication
• Clear output: Separate display of X and Y coordinates

Security Notes

• Private keys must be randomly generated and kept secure
• This tool is for educational/development purposes
• Never enter real private keys in web tools for production use

This tool implements the mathematical foundations of elliptic curve cryptography as specified in NIST standards.

Password Generator based on AES-MP - Experimental, NOT SECURED!!!

Tại sao kỹ sư hệ thống nhúng nên học assembly?

Tôi vốn không học ngành khoa học máy tính hay những ngành liên quan đến lập trình, nhưng may mắn tôi được học khóa kiến trúc máy tính và hợp ngữ (Assembly) khi còn học đại học, và may mắn hơn nữa khi tôi được học với một người thầy lớn tuổi và có nhiều kinh nghiệm với những CPU “cổ” (ví dụ như 8086). Có lẽ vì thầy lớn tuổi nên thầy đã trả qua một kỳ khi mà các ngôn ngữ cấp cao chưa mạnh, hay các MCU tại thời điểm thầy làm việc có bộ nhớ khá khiêm tốn, và thực sự thì các ứng dụng sử dụng MCU tại thời điểm đó còn chưa phức tạp như thời điểm viết bài viết này nên việc sử dụng assembly để lập trình ứng dụng vẫn là một công việc phổ biến và phù hợp thời ấy.

Nhưng hiện giờ đã là năm 2024, khi các MCU 32-bit đã rất rẻ và có nhiều bộ nhớ, các trình biên dịch ngôn ngữ C (C compiler) đã rất phổ biến và tối ưu, thư viện hỗ trợ cho các MCU cũng đã được phát triển rất nhiều, điều này giúp cho việc lập trình nhúng trở nên dễ tiếp cận hơn. Tuy nhiên, với khoảng thời gian 10 năm làm nhúng tại nhiều công ty và được tiếp xúc với nhiều đồng nghiệp từ các bạn mới tốt ngiệp (fresher) cho tới các expert có hơn 10 năm kinh nghiệm, tôi quan sát thấy rằng những kỹ sư có kiến thức nền tảng vững vàng và hiểu biết sâu sắc về hệ thống nhúng đều có khả năng đọc, hiểu và viết chương trình assembly.

Tôi sẽ liệt kê ra một vài trường hợp tại sao ngôn ngữ cấp cao (như C) không thể thay thế assembly.

• Khi dự án làm việc với một MCU mới, chúng ta chỉ có tài liệu (Datasheet, user manual) và C compiler (bắt buộc phải có), và chỉ thế thôi, chúng ta không có IDE, không có BSP (Board Support Package), mọi thứ phải bắt đầu từ con số 0 (build from scratch).
• Khi bạn cần viết/sửa đổi core implementation của hệ điều hành (Việc này cũng khá phổ biến nếu dự án làm việc với in-house RTOS).
• Khi compiler bị lỗi!!! Đúng vậy, việc compiler bị lỗi khá là phổ biến nếu bạn code cho embedded đủ nhiều, kể cả compiler có bản quyền đắt tiền (Không một phần mềm nào là không có lỗi).
• Khi chúng ta muốn hiểu sâu về kiến trúc của một MCU/CPU, và đây là điều quan trọng nhất.

Và ở phần tiếp theo, tôi sẽ trích lại một hồi ký của một kỹ sư lập trình nhúng giả tưởng, qua đó phản ánh cách mà assembly xuất hiện trong công việc của một kỹ sư lập trình nhúng. Đó có thể là tôi hoặc bạn trong những giai đoạn khác nhau của công việc, và mục đích của tôi là để nhấn mạnh việc cần thiết phải biết về ngôn ngữ assembly kể cả khi chúng ta hiếm khi sử dụng nó, nhưng khi chúng ta cần tới nó, chúng ta biết sẽ phải làm gì.

Nhật ký của một kỹ sư phần mềm nhúng.

Sức hấp dẫn bởi sự dễ dàng của Arduino!

- Ngày XX tháng YY năm ZZZZ

Vâng, với Arduino, bạn có thể mua các module cảm biến và một bộ khung robot về và … Voila, chúng ta đã có một project khá là cool. Bạn học được cách các sensor hoạt động như thế nào, bạn biết cách điều khiển các cánh quạt quay như thế nào để máy bay có thể bay lên , bay tiến hay bay lùi, bạn có một đồ án tốt nghiệp đồ sộ đáng tự hào khi bạn đã lập trình những tính năng phức tạp nhất, tất nhiên là trên Arduino … Cho đến khi bạn đi làm và bạn nhận ra, những dự án thực thụ không dùng Arduino. Bạn được giao cho một dự án với một con MCU bạn chưa gặp bao giờ, dự án không có IDE, mọi người viết code bằng bất cứ text editor nào (tất nhiên Notepad++ luôn là sự lựa chọn số 1) và mọi người build code bằng command line (What the heck!!!). Bạn nhập cuộc khá dễ dàng, bạn follow coding guideline, và bạn đã build được project như mọi người. Tiếp theo, bạn được giao cho nhiệm vụ viết một driver cho một khối ngoại vi của dự án, bạn háo hức với lần đầu tiên bạn được thể hiện khả năng coding của mình. Bạn bắt đầu viết những dòng code đầu tiên, bạn được mọi người trong team hướng dẫn cho cách sử dụng debugger, mọi thứ khá suôn sẻ. Và chuyện gì rồi cũng sẽ đến, bạn thấy chương trình của mình không chạy, bạn muốn debug, bạn không có hàm print của arduino, bạn phải làm quen với việc sử dụng debugger, cũng không phải việc gì quá khó khăn, ngoại trừ việc bạn thấy chương trình của mình viết chạy không theo thứ tự từ trên xuống dưới như bạn từng biết. Với tâm thế cẩn thận, thử lại nhiều lần, bạn nghĩ rằng debugger bị hư, hoặc con MCU bị hư, vì nó chạy không đúng thứ tự, bạn báo cáo với mentor của bạn. Mentor của bạn mỉm cười và nói “Chương trình của mình build với compiling option -O2, nó sẽ optimize code bằng cách re-order (sắp xếp lại) các instruction”, “Vậy làm sao đểu build không optimize vậy anh?”, “Ở đây chúng ta không làm thế, debug bằng assembly đi em”. WHATTT??? Assembly, ngôn ngữ tối cổ chỉ học 4 buổi trên trường đại học và bạn còn chẳng nhớ bạn đã từng học cái gì (ah, thực ra là tôi vẫn nhớ hàm mov để chuyển data giữa các register ?!?!!.

Khi bạn là người đầu tiên trong công ty làm việc với một dòng MCU mới/lạ.

- Ngày XX tháng YY năm ZZZZ

Bạn được công ty giao cho một dự án mới, với những công nghệ mới nhất, con MCU và kit phát triển bạn được giao là bản prototype chỉ giành cho những partner có ký NDA (Non-Disclosure Agreement - thỏa thuận bảo mật thông tin), bạn không thấy có một theard stackoverflow hay post reddit nào nói về dòng MCU này. Và công việc của bạn khá đơn giản: “Bring-up (làm cho chạy) board này cho chạy tới hàm main”. Bạn không có gì nhiều ngoài tài liệu của dòng MCU này (bản preliminary và strictly confidential), compiler lưu hành nội bộ (và còn có nhiều limitation haha). Không có “BSP - Board Support Package”, vì bạn là người tạo ra nó. Và bạn phải bắt đầu tìm hiểu về cách con MCU này start up như nào và bạn biết rằng C compiler bạn đang dùng không có một cách chính thống nào để thiết lập được Stack Pointer trước khi project của bạn có thể sử dụng được chương trình viết bằng ngôn ngữ C. Bạn tìm hiểu cách viết chương trình bằng assembly, và bạn ước bạn đã học assembly kỹ hơn, bạn thấy mọi thứ được dạy trên trường đại học thật là hợp lý. Bạn chợt ngờ ngợ hiểu ra Stack Pointer là gì, Vector Table là gì, Program counter là gì,…

Khi bạn có một project làm việc với co-processor và không có C compiler.

- Ngày XX tháng YY năm ZZZZ

What da heck? Tại sao lại không có C compiler? Tại vì co-processor này dành ứng dụng ngách (niche), ai lại bỏ công sức tạo ra một C compiler mà dùng cho tập khách hàng nhỏ nhỉ? Đó chỉ chỉ đơn giản là lý do liên quan đến cost. Lúc này, bạn thấy rằng chẳng có gì khó khăn cả, bạn thoải với việc viết cả một chương trình lớn bằng assembly. Bạn bẻ tay, đứng dậy vặn người và ngồi xuống đọc tài liệu ISA của co-processor (ISA - Instruction Set Architecture - Kiến trúc tập lệnh), YOLO.

Bạn gặp exception.

- Ngày XX tháng YY năm ZZZZ

Đôi khi, bạn thấy chương trình của bạn gây ra exception (exception là một dạng interrupt - ngắn- nhưng thường gây ra bởi lỗi của CPU, ví dụ như access (truy cập) địa chỉ không tồn tại), và bạn không hiểu tại sao, chương trình của bạn nhìn khá logic. Nhưng khi debug assembly, bạn nhận ra rằng bằng cách nào đó, mỗi khi chương trình của bạn gọi đến một instrucion cụ thể, sau đó bạn dùng debugger để stepping thì bạn thấy CPU gây ra exception liên quan đến memory. Bạn nhìn các CPU register và các thông tin về mã lỗi và nhận ra rằng instruction của bạn truy cập vào “non-aligment” memory address. Voila, đây là lúc bạn đã hiểu việc học/đọc/hiểu ngôn ngữ ASSEMBLY có ích thế nào. Một khi bạn hiểu được nguyên nhân gây ra vấn đề (root cause), việc sửa lỗi trở nên dễ như ăn bánh.

Lời kết,

4 tình huống tôi kể trên là tình huống giả định về một kỹ sư (in general) gặp những hoàn cảnh cần kiến thức về assembly trong công việc, từ lúc là junior, qua mid level, cho đến lúc là “hardcore” engineer. Chắc chắn rằng việc nhớ toàn bộ các câu lệnh hợp ngữ có thể không cần thiết ở thời điểm tôi viết bài viết này, nhưng việc nắm được cách đọc và hiểu assembly sẽ giúp chúng ta rất nhiều trong việc debug và làm việc với low level software, và chắc chắn rằng không gì có thể ngăn cản bạn thiết kế ra chương trình cho bất kể MCU nào.

Một số gợi ý cách tiếp cận ngôn ngữ assembly

• Build-from-scratch một project với bất kỳ evaluation kit nào bạn đang có. Giả sử bạn chỉ có toolchain (compiler, assembler, linker), bạn thử build một project “hello word” như blink led. Bạn thử tập viết startup code, viết linker script,…
• Thử thiết kế và viết một RTOS đơn giản.
• Viết một chương trình xuất xung PWM bằng assembly.

Một vài link tham khảo các khái niệm trong bài viết

• Memory reordering - Wikipedia
• GCC assembly syntax
• ARM Cortex M exception Handling - Memfault

–

Cabal

Installation and setup

There are plenty ways to install Cabal, I prefer using WSL as a platform to learn Haskell, so it seems I have the cabal installed (possibly via ghcup), so it’s time to update it.

> cabal install cabal-install

Then go to the project folder and initialize

> mkdir project_dir && cd project_dir
> cabal init

After this command, the project_dir.cabal file will be created, we will edit our build structure in this file.

Setup project with Cabal

At the directory of the cabal file: to build then run:

> cabal build
> cabal run

The cabal package is written in haskell, and it is consider as a part of the haskell ecosystem. With cabal, the source code will be more organized, just like how we use make for the other project. I put here the the cabal file of the project I am working on for the sake of explanation.

cabal-version:       >=1.8.0.4
-- Initial package description 'thingkell.cabal' generated by 'cabal init'.
--   For further documentation, see http://haskell.org/cabal/users-guide/

name:                thingkell
version:             0.1.0.0
-- synopsis:
-- description:
-- bug-reports:
-- license:
license-file:        LICENSE
author:              Truong Tran
maintainer:          contact@tranvantruong.com
-- copyright:
-- category:
build-type:          Simple
extra-source-files:  CHANGELOG.md, README.md, bit_utils.c
executable thingkell
  main-is:             Main.hs
  other-modules:   Memkell, Bitkell, Crkell, Hexkell, Ihex, Ffi
  -- other-extensions:
  build-depends:       base >=4.13 && <4.14,
                      split,
                      parallel,
                      bytestring,
                      attoparsec,
                      optparse-applicative
  hs-source-dirs: ./src
  -- extra-source-file: src/bit_utils.c
  --C-sources-dirs: ./src
  C-sources: src/bit_utils.c
  Includes: bit_utils.h
  Include-dirs: ./src
  Install-includes: bit_utils.h
  default-language:    Haskell2010

What I want to point out here is how to setup this to work with mixed C source code via FFI with haskell.

Setup testing in Cabal

Yeah, why not leveraging the test driven development, and why not apply it from the begining. It seems testing setup in cabal is nothing more than just a separated executable file that has the test harness to the code we want to test. At the time of wrtting this blog post, I have the following folder structure of how I setup the test code for my module. I use the Tasty frame work to develop test, the test case organizing is intuitive, so which this setup, I can focusing on develop the test case case and run the test every time I modify the code. It worths noting that testing is all about checking the side effect, so we should prepare testing is a way that can be easily resued when we change the interal processing implementation which is normally pure.

I think for now, we have all the CABAL setup necessary for a complete Haskell project including the following steps:

• The haskell source code itself for the logic code.
• The C code and Foregin Function Interface (FFI) setup
• The Tasty test framework setup.

Actually, setting up the testing with CABAL is nothing like setting up the whole project target. except that instead of calling the cabal run, we shall call cabal test. I took a while to realize that and come up with the following folder structure to setup the project with the testing.

prj_root_folder
¦   thingkell.cabal
+---app
+---output
+---src
¦       Bitkell.hs
¦       bit_utils.c
¦       bit_utils.h
¦       Crkell.hs
¦       Ffi.hs
¦       Hexkell.hs
¦       Ihex.hs
¦       Main.hs
¦       Memkell.hs
¦       MemService.hs
¦       
+---test
        8byte.bin
        8byte_start0.hex
        8byte_start17.hex
        8byte_startFFFC.hex
        HexTest.hs
        Long_Lorem_ipsum_start_at_32K.bin
        Long_Lorem_ipsum_start_at_7FF0.hex
        Long_Lorem_ipsum_start_at_7FF0_variance1.hex
        Main.hs

We can see that I have put all the core implementation inside the src folder, while the test artifact into the testfolder. You will see that each folder has it own main.hs, which means that we have 2 targets in the cabal file and each one need their own main function to run.

Testing with tasty

Then, we have finish setup the testing environment. Then, we will jump down to actually writing the test. OK, I approached the topic by desigining the test case firstly, from simple to sophisticated. I have preprapred some known-good hex file using the available hex file utility. I have tried to create several use case to vet all code I wrote in the core implementation, something like to test my logic to handle different type of hex record, such as data record, linear address record,… I put here some of the testing code I wrote in the HexTest.hs below (it is just a part of it).

test_CollectAndMergeMemSect :: TestTree
test_CollectAndMergeMemSect = testCase "Test collect and merge memsect" $ do
    let hexRecord = [IntelHexRecord {ihexAddress = 0, ihexData = [], ihexRecordType = 4},
            IntelHexRecord {ihexAddress = 4, ihexData = [1], ihexRecordType = 0},
            IntelHexRecord {ihexAddress = 6, ihexData = [2], ihexRecordType = 0}
            ]
    print $ collectAndMerge2Memsect hexRecord

test_ihex2MemSect :: TestTree
test_ihex2MemSect = testCase "Convert hex file into MemSect" $ do
    -- test
    ihRecord <- iHex2HexRecords "test/8byte_start17.hex"
    let preprocess = hexRecordPrependExtended $ catMaybes ihRecord
    print $ hexChunks2MemSect preprocess

test_ihex2MemSect_fffc :: TestTree
test_ihex2MemSect_fffc = testCase "Convert hex file that crosses" $ do
    -- test
    ihRecord <- iHex2HexRecords "test/8byte_startFFFC.hex"
    let preprocess = hexRecordPrependExtended $ catMaybes ihRecord
    print $ hexChunks2MemSect preprocess

Well thanks to this testing, I help me to detect the problem in my code easier, I am glad that the effort figuring out the setup worths.

I will finish this blog at this time, I have some incorrect logic to debug so I will make the report next time about the project I am working on. See you and Happy new year!

This page hepls to calculate the SHA-256 value from the input hex string or array of uint8 values in C syntax.

Calculate SHA-256

Diffie-Hellman problem

Let’s define the Diffie-Hellman problem with color:

• Give g to be the generator of the group, in this case we chose the color g in the RGBA in the color space.
• Let’s define the ^ to be the one way function, that is giving 2 color x and y, we can easily compute the mixed color m=x^y, but given the color m, it is “hard” to find the color which m is mixed from.
• The DHP in the color space will be: Give 2 color \(X\) and \(Y\), where as \(X=g^x\) and \(Y=g^y\), it is hard to find the color the color \(Z=(g^x)^y\)

It sounds logical, right? Let’s take a closer look.

Color mixing algorithm

For someone who is not familiar with graphic processing, color in image can be represent in several way, in this post, I use the RGBA which use Red-Green-Blue-Alpha element to represent color, and it is represented by a vector of 4 byte, however, in this blog post, I ignore the Alpha channel to reduce the complexity, se let’s assume all the alpha in this blog post is 1.0. Here are some examples:

* rgb(255, 99, 71)

* rgb(32, 99, 71)

* rgb(99, 99, 250)

Now we define the mix color operation, there are several one for this, but for the workable DH scheme, we will need the one that has the commutative and associative characteristic.

• Option1 - Additive blending: C1(r1,g1,b1) ^ C2(r2,g2,b2) = Z(r1+r2, g1+g2, b1+b2), it seems to match our imagination about the RGB color space, however, it has the problem about the saturation, our information will be lost. For instance, if one of the color in mixing is white (FFFFFF), the result is always wh/ite due to saturation.

• Option2 - Average blending: On the surface, it is commutative, but it doesn’t provide associative. So I wanna make a modification for it. \(F\) is the funcion which take the list of colors to produce the new color.

  \(F(color1)\) = \(color1\)

  \(F(color1, color2)\) = \((color1+color2)/2\)

  \(F(color1, color2, color3)\) = \((color1+color2+color3)/3\) = \(F(color1,color2)*2/3 + F(color3)*1/3\)

• Option3 - Multiply blending: This is a common blend mode, the special effect of this mode is that the result is alway a color darker than 2 input colors. Here is the blend function for it \(F(a,b) = a.b\) where as the result in RGB-888 notation is new \(Z\) color is \(Rz = Ra.Rb/255; Gz = Ga.Gb/255; Bz=Ba.Bb/255\)

Let’s see the illustration of the color blending in different modes.

Mode	Example
Addition
Average
Multiply

Based on the result of the blending, we can easily see addictive blending doesn’t fit with the realtiy of paint mixing, because the more we mix, the lighter it is, but it shall be darker in reality. However, we will accept it for the DH key exchange, just for reference.

Try out the key exchange with color blending

Let’s make the key exchange between Alice and Bob, as the following table.

Then, looking at the table, we can see that all 3 options produce a viable way to do the DH key exchange using color, here are some of the observations:

• We see that Alice and Bob can create the identical color, or nearly indentical color as as shared secret. There are the minor deviation in some cases (like the Near white case of the Avarage blending), this is simply the rounding error when the operation involve the number division.
• For the Addictive blending, the shared secret color can be obtained by both Alice and Bob, we can see that it indeed saturated to White color. Similarly, for the Multiply blending, the result can be quickly saturarted to Black color, though it is not as easy as white color, but from the human eyes resolution, the difference betwene black and near black color is negligible.
• If you are a good person in distinguishing color, you can see the final shared secret having some correlation with the public color.

Trivial security evaluation

We call it trivial because all above color blending mode are not truely one way function mathematically, because the private key are easily calculated from common g color and the public key, see the following:

• Addictive blending: We can use the color subtraction.
• Average blending: We can use the linear interpolate or extrapolate to extract the private color.
• Muliply blending: We can use the public color divide to common g color and we will get the private color.

With that said, we don’t really consider the mathematical characteristic of these operation, because it trivial to break the scheme. Thus we only evaluate the security properties of the scheme bases on the color visualization. Let’s see the following analysis:

• Addiction blending: we can easily see that this scheme work only if the g is near the dark color to avoid the saturation, at the same time, the private key should be chosen that it shall not cause the saturation. With that said, the result of the Color DH is always brighter color than the g and the public key itself, thus the attacker can just mix gx and gy, and brute force the color from (g^x)^y to g^x.

• Average blending: Well, I believe Average blending is the most accurate interm of color visualization, because it reflect the way we mix paint in real life. The share secret it this case is a bit harder to guess, because it can be brighter and darker than the public colors.

• Multiply blending: This scheme is the opposite of the Addiction blending, where it need the g color to be near the while color, and the result of the blending is always the darker color. Though this scheme does not cause much of the saturation problem (unless one of the serecet color is completely black - represent by 0 value), it does not represent the real color blending in reality. For instance, if we mix 2 color of the same color, the result shall be the same color in real life, but with this multiply color bleanding, we get the darker color.

Afterthought

I have realized that using the RGB color model is not appropriate with the paint mixing analogy key exchange, since the RGB is the Addictive color model, it represent light emission. While in case of the paint mixing, paint has color X because it absort all the light of the other color than X (or it reflect and scatter the X color), thus the CMYK color model should be more appropriate. However, the blending operation would be the same, as my time is limited, I let this post as it is and I will update this post in the future to demonstrate color blending in CMYK color space.

I have also read some discussion about color blending modeling in math, it seems that with the current common color model, it is difficult to make the mathermatical representation of the color blending to be exact as we see in reality, because color mixing is not only about the light mixing but also the chemical reaction and biological phenomenon of the human eye. For instance, all 3 mode of color blending in our example are associative, but in reality, when we mix color (A+B) then mix with C, that result will be different from when we mix the (B+C) then mix with A, the order of paint mixing does matter in some case. During the time I write this blog post I have found these interesting post:

• Colour-mixing magma by Mark Seemann
• Color theory (I haven’t known it exist) on Wikipeia

Last but not least, this blog post is purely for entertainment + self education purpose. It may contains some oversimplified technical detail, by no mean, I am trying to propose color blending operation as a DH key exchange in the serious application.

Been learning Haskell intensively from last year, starting with some fundamental knowledge about category theory. I have been exploring the concepts of functors and monads, particularly focusing on understanding category theory. To aid in my learning journey, I came across a valuable resource: Dr. Bartosz Milewski’s YouTube channel. His series of lecture videos on Category Theory for programmers have been immensely helpful. They have not only piqued my interest but also provided me with new perspectives on the programming work I have been doing for years, making me contemplate the quality of my code and the potential bugs that may arise due to the imperative nature of certain languages.

Some Ideas from Category Theory

Another Way of Abstraction

Category theory introduces a novel approach to abstraction. It represents things as dots (objects) and arrows (morphisms). A category should exhibit the following characteristics:

• Identity operation: This morphism maps an object to itself. id x = x
• Composition: When applying morphism f from object a to object b, and then morphism g from object b to object c, the resulting morphism g . f (called g after f) should satisfy g . f = a -> c.

Example(s) of Using Category Theory to Abstract Common Mathematical Characteristics

These are my own interpretations, which may not perfectly align with the theory, but they demonstrate how I perceive the topic.

The Adder and Number Zero, and/or the Multiplier and Number One

Although addition and multiplication are distinct operations we learn as children, mathematical abstraction reveals similarities between the two. I use the symbol ^ to represent the operator:

• Composition: (a^b)^c = a^(b^c)
• Commutative property: a^b = b^a
• Identity element: I is the identity element, ensuring that for every number, the operation x ^ I = I ^ x = x.
• For every operation f and g in set M, the composition f x g is also in set M.

We observe that these characteristics align with the number zero for addition and the number one for multiplication. Category theory addresses such special characteristics in a more abstract manner, referring to them as monoids. The diagram below (image from Wikipedia) depicts a monoid:

Initially, this diagram might appear overwhelming, but after watching Dr. Bartosz’s lecture on monoids, I gained a better understanding. In general, a monoid is defined within a category with the following morphisms:

• \(\mu\): M ⊗ M -> M. This represents multiplication or the binary operator, mapping a pair of objects of the same type to an object of the same type.
• \(\eta\): I -> M. Here, I denotes the unit. Although I haven’t fully grasped this concept yet, I accept it for the time being and continue my search for answers.

For this particular category, the following characteristics hold:

• Multiplication: Morphism of a pair of objects to an object. For example, the multiplication of two real numbers yields a real number.
• Associativity: Suppose we have \(\mu\) (\(\mu\)(x,y),z) = \(\mu\) (x,\(\mu\)(y,z)). This equation represents the associativity of real number multiplication.
• Identity: We have \(\mu\) (\(\eta\) (I), x) = \(\mu\) (x,\(\eta\) (I)) = x, denoted as left identity and right identity (\(\lambda\) and \(\rho\)) in the diagram. For instance, in multiplication, the number 1 serves as the identity element.

And Then the Monad

Monad? Another new term. I have been struggling to grasp the most fascinating concept of Haskell and Category theory. In fact, I even paused my Haskell coding practice to read and watch numerous articles and videos to gain a better understanding. However, I needed to set aside the concept of category theory temporarily to comprehend monads from an imperative perspective.

Let’s consider Haskell, a pure functional language where functions are pure and do not modify state variables or cause side effects such as writing to files, sending data over the internet, or altering registers (I happen to be an embedded software engineer). At this point, a question arises: Why are pure functions essential in functional programming? In Haskell, we do not have expressions like count = count+1 because they violate the principles of the mathematical universe. Impure functions lead to the collapse of lazy evaluation, thus rendering function composition and eta reduction are inefficient.

Allow me to provide an example illustrating the use of monads. I will not delve into the definition of a monad for now. This explanation draws inspiration from Ertugrul Söylemez’s blog post.

Let’s assume we implement an integer square root function that takes an integer and returns its square root. We can represent this function as shown in the following figure:

However, as you know, this function has its limitations. It can only return numeric values, and for certain inputs like 17, an integer root does not exist. How can we address this problem? In C, we solve it by providing a function that returns the validity of the result via another pass by reference variable, as shown below:

The problem with this approach is evident: the function is impure due to the modification of the global variable pRet. So, what’s the point? Why do we emphasize the purity of Haskell if it does not simplify our lives? Suppose we want to compute the positive fourth root, which can be expressed as: \(\sqrt[4]{x} = \sqrt{\sqrt{x}}\)

We can implement the fourth root of an integer using the function depicted in the following block diagram:

As previously discussed, the square root function presents several problems, which are carried forward when computing the fourth root. So, how can we correctly compose the sqrt function? Haskell, and mathematics in general, provide a solution.

Suppose we can define a type that represents whether the function’s return value is an integer or Nothing. In Haskell, we call this type Maybe Int. The function signature for this approach is depicted in the following diagram:

Looking at the diagram, we can simulate a similar approach in C by returning a structure that represents the Maybe Integer type. However, what is the advantage? One crucial aspect is that we still pass an integer as the input value, as the square root function operates on integers. Another significant advantage is that by avoiding the use of global variables, the function remains pure and preserves laziness. Moreover, we can use a special composition technique known as bind (>>=) operation to compose functions. Let’s examine how we compose i_sqrt into fourth_sqrt in the following figure:

Analyzing the diagram, we observe that the fourth root function is implemented by composing two i_sqrt functions. The composition is special because it not only passes the output of the first function as the input of the second function (like the dot (.) operation in Haskell), but it also handles cases where the first i_sqrt function yields Nothing. In such cases, Nothing is directly forwarded to the output without passing through the second i_sqrt box. This behavior aligns with the definition of the bind (>>=) function in the Maybe Monad. The Haskell definition is as follows:

(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
(>>=) m g = case m of
                   Nothing -> Nothing
                   Just x  -> g

As we can see, the Monad is precisely defined, serving its purpose. This example highlights a few key benefits of using monads:

• It facilitates function composition in a special and potentially clever way.
• In the i_fourth_sqrt function mentioned above, the intermediate calculation after the first i_sqrt is encapsulated within the bind function. We no longer require global variables to store the state of the first i_sqrt result or any temporary variables. Additionally, we can skip the second i_sqrt block if the immediate result is Nothing, thanks to lazy evaluation.
• Monads aid in abstracting calculations, hiding intricate details and allowing us to focus on high-level computations. Last- ly, while error handling is not the primary purpose of monads, they provide a useful tool for handling error cases.

To conclude this blog post, let’s revisit the original definition of a Monad found in some textbooks:

A Monad is a monoid in the category of endofunctors.

When we examine what defines a monoid, we find:

• The binary operator (»=): Composing two functors. It’s worth noting that functions can be seen as instances of functors. In the square root example mentioned earlier, the endofunctor maps from the category of integers to the category of integers (the mapping from the category to itself).
• The unit element, which in Haskell is the return function. In the i_sqrt function, the return function of the Maybe monad is Just.
• Associativity of the bind operator.

I hope this example sheds some light on the usefulness of monads. While I’ve only listed a few benefits here, the true power of monads extends beyond error handling. It allows for clever function composition and abstracts computations, enabling us to focus on higher-level concepts.

That concludes this part of my blog post, as I fear my explanations might become convoluted if I continue.

The original comment

What did AUTOSAR solve?

It’s a job creator for application engineers.

Did software become less complex and easier to develop/configure?

Jesus fucking christ fuck no.

Did the software become smaller or faster with AUTOSAR?

See above.

Forgive my vulgarity.

I spent 2+ years trying to unfuck an existing AUTOSAR project at a company that builds vehicle telematic ECUs. I can safely say that the AUTOSAR standard and all available implementations (Vector, Mentor Graphics, and Electrobit) is an upside-down on fire dumpster full of dog shit.

I’m not even gonna go into how much trouble it is to get the attention of an AUTOSAR distributor. If you’re a student or small business and you just want to see the specification then you can go grab it from autosar.org. It’s just a bunch of PDFs and they’re all free. But the implementation is where you’ll spend money, and if you aren’t Ford / GM / some automotive startup with a shit ton of money, nobody will want to talk to you because AUTOSAR is \(\)\(\)$$.

Let’s assume you get past all that. After you spend months negotiating contracts with Mentor Fuckups or Eletroshit or whatever AUTOSAR package you decided was the least bad, you’ll spend a few more months sitting in online seminars while some talking head explains why it takes 6 hours to configure a million goddamn things so their garbage tool can shit out an entire Italian resaurant’s worth of spaghetti code just to blink an LED at 1Hz. Except it’s not 1Hz, it’s 10Hz, or 0.1Hz, or some other bullshit that you didn’t want, because you muttered the wrong incantation to the configuration utility somewhere around step 2 out of 800, so guess what, you get to back and do the entire fucking thing again.

Get the flying fuck out of here if you want to try doing something more complicated than that. You want to send a CAN frame? Get completely fucked. You have to buy a separate tool beyond what you already spent $800k on just to generate the stupid little ARXML “network definitions” files that are compatible with your AUTOSAR configurator, learn how to use that, then fight problems between export / import because of course both tools were written by different teams and aren’t 100% compatible (WHY THE FUCK WOULD ANYTHING EVER JUST FUCKING WORK?), then get your application developers to understand how to interface their C code to the new “network interface layer”, and etc etc etc.

Now let’s assume you’re track-side and you want to add a new CAN signal just to get some info out of your ECU. With vanilla C it’s a matter of hacking something in quickly OR running some custom interface generation script that takes a few seconds, like the howerj/dbcc scripts. AUTOSAR? Hours. Literally even days if something goes wrong and your entire project blows up. Our firmware test turn-around window was weeks just because it took so long to get the network definition generator to spit out something useful without breaking a million other things, all the while the AUTOSAR vendor gave us excuse after excuse, patch after patch, never really fixing the problem.

The final straw came when we realized we couldn’t hire anyone who would want to mess with this shit. Imagine working in the industry for 10 years, and then you take a job where someone says “Hey thanks for spending all that time learning all that cool stuff that we can’t use, here’s the MSPaint equivalent of embedded software development platforms, we need Mona Lisa by lunch.” Our choice was either over-pay seniors to deal with this giant pile of 5th stage super-cancer, or hire kids fresh out of college and hope they wouldn’t wise up to the fact that any skillset developed while working with AUTOSHIT was absolutely useless and bail.

After 2 years with 20+ engineers working like this we gave up. Everyone else went on vacation while 3 guys spent a few days getting ADC ports, CAN, LIN, SPI, and a few other things up an running on a development kit. We had a working ECU running on a vehicle less than 2 weeks later. And that was from starting with a clean install of a compiler + IDE and a blank main.c. Our code safety team ran it through the ISO26262 verification process and everyone’s stress level was suddenly much lower because they could actually DO THE JOB THEY WERE HIRED TO DO instead of fighting the trash-tier AUTOSAR tool all day.

I would rather shove a shotgun in my ass and blow my god damn balls off than ever lay my eyes on AUTOSHIT ever again. Complete fucking waste of time. If ever you see AUTOSAR on a job description then fucking RUN.

How to start

Just google `open AI chatGPT” and you will be guide to the chatGPT link, unfortunately, at the moment, it is currently geographically blocking Vietnam user, there are several workaround you can find out there.

Let’s get started

The feel

Obviously, as an machine under the hood, chating with it is not something like the human, however, for the purpose I am wanna try, it is interesting than using google search, but it is lke using the google assistance, except that this bot is not internet connected, but use their historical trained data. I guess openAI have provided it massive knowledge.

One think I was always wanna do but hate to learn is the GUI, like Linus Tovard spoke in TED session with Chris Anderson. Then, I have asked the bot to generate the code of simple GUI program (adder of 2 input numbers). As first, to be frank, I am scared of what it can do, it provide the initial version, then I complain, and it provides the revised version, and it did excellence for several round. The fololwing is the simplified conversation between myself and the bot.

Well it is really terifying, but in the end, it is just the massive if-else, isn’t it

I am a fool, I am always think of the neural-network works like the massive if-else mesh. After couple of hours playing with in, I am convinced about the capabliity of the context in generated

• My goal is to make an salary calculator in python with GUI:

  • I wanna learn a bit of the GUI in python so I asked the bot to generate the simple GUI app, with some input textbox and one calculate button. I copied the python code it gen and run it run pretty well.

  • I see the font is quite small, so I asked chatbot to increase the font size. Well It remembers the previous code and it generates the code to change the font size. Moreover, it also explains to me the code like a teacher, cool huh? I like it.

  • Tweaking my questions some more rounds, and it performs like an expert in python. The content it generates having the consideration of the whole discussion, not just the dry ass Q&A.

  • However, when it comes to some bugy code it generates, I copied the error to the chat box to challenge our bot. It started to behaves like a junior, haha. I have tried to simplify my question, it seems to help a bit, but it cannot hide the fact that the code it generate is not from itself but the mix of some unknow expert in stackoverflow (haha).

• Actually, my plan of learning haskell is abit behind the schedule, because I am so stupid to understand the monoid, monad, May be,… So I would like to check if it can be my mentor during the learning. So was asking the following question.

  • In the ELI5, what is the functor in category theory. The following image is the outcome. Impressive huh?

What we should prepare as an engineer?

For me, with above 2 simples example, the chat bot like GPT really awesome to the point that would put some pressure on us, chat GPT seems to to compete with us, the engineer in these tedious job (like implement some low complex requirements). That may not immediately affect our job now, but the junior engineer would be in the difficult market now. Frankly, if I was able to use my 2 hours of engineering to tell the GPT to make some simple app, which may take a whole week or more of a junior, I would prefer worknig with chat GPT (I hate working with human haha).

Personal verdict?

Think of how magically our brains are, I don’t think we could build the “skynet” that is superior the humankind intelligence in total (and the skynet without weapon connected is harmless, isn’t it?), I think the main reason the chatGPT is disconnected from the internet is to ensure that it cannot learn the negative stuff from the humankind, thus their purpose is achieve with just a little side effect. However, as an egineer. What I can see that it can generate the simple code that it would take me a day or so to do, in just a few minute. Thas is really impressive. Then it is that, the chatGPT cannot handle the much of the complexity like a middle engineer, but for simple task like writing some small module we normally see the entry level engineer did, I am afraid that these job will bee soon replace if the cost/performance of chatGPT is considered. The it is not the end of the our career for sure, for instance, before the calculator is invented, we still doing the math on paper. And when the calculator and computational science is rolling out, it is not mean that we can fire the mathenmatician or we can skip the Algebra 101 class in the college. ChatGPT or equivalent tools will be the powerfull tool to do the tedious job of the programming, like the calculation remove our stress of incorrect calculation, or like the computer spreadsheet (and database recently) replace the paper-and-pen book keeping.