Metadata
This report says that it explains the video “E01: What is the FASTEST Computer Language? 45 Languages Tested!” by Dave’s Garage (22:26). The reviewer compared the report with the timestamped captions of the video. The captions have some gaps. Numbers that show only on the screen are not in the captions, so this review tags them [VERIFY].
| Tag |
Meaning |
| [DOC] |
Provable from the document itself (a contradiction, arithmetic, missing data) |
| [KNOW] |
Reviewer knowledge of the field. High confidence, but not yet checked against a primary source |
| [VERIFY] |
A plausible problem. Pass 2 must confirm it against the cited or primary source |
| [VIDEO] |
Checked against the video captions, with a timestamp |
- Tell the reader what the video E01 shows: the languages, the test, and the results.
- Explain the technical reasons for the results: compilers, safety checks (tests that the program does while it runs), memory layout and CPU cache (a small, fast memory inside the processor).
- Give general engineering lessons from the results.
- Support the claims with sources.
| Objective |
Met? |
Why |
| 1. Say what E01 shows |
Partly |
Correct: the focus group is Pascal, Delphi and Ada [08:14]. Correct: the sieve goes to one million, the score is passes per second, and each run is 5 seconds [04:52, 19:51]. Wrong: the report says Delphi was raced. It was not [16:48]. The report does not give the race result. Pascal beat Ada [20:03]. |
| 2. Explain the mechanics |
Partly |
The general ideas are real (bit array against byte array, default Ada run-time checks). But the report overstates cache fit, branch cost and compiler behavior (M2, M3, M4). |
| 3. Engineering lessons |
No |
The central lesson (“E01 shows that safe languages run as fast as unsafe ones”) has no support in the video. The video shows the safe language Ada losing (C2). |
| 4. Sources |
No |
The report cites the video for things that the video does not say. Most technical claims cite Reddit threads and an unrelated GitHub issue (M7, section 4). |
Overall confidence in the document: Low. The report reads like a general essay about compilers. It uses the video title and a few facts from it, but it replaces the real content and result with invented ones.
| # |
Location |
Claim |
Problem |
Tag |
| C1 |
L16, L33, L60 |
E01 is a “head-to-head evaluation” of Ada, Pascal and Delphi, and “benchmarking Ada, Pascal, and Delphi” gives the results. |
Delphi was not raced. Dave says that the Delphi version uses the type ByteBool [16:36], a full byte per flag. He says “its score cannot be counted” [16:48]. He also names the commercial license [16:56]. The race is “a heads-up Ada vs Pascal showdown” [19:07]. |
[VIDEO] |
| C2 |
L27, L55, L60 |
“The results of Episode 01” show that safe languages reach the speed of unrestricted languages. GNAT output “closely rivals” C. |
The video has no safety on and off test and no C in the race. The only result is Ada against Pascal, and Ada lost: “that’s gotta hurt for the Ada guys” [20:03]. Dave compiled Ada with GCC and expected a benefit [20:17]. He thinks the difference comes from the code [20:26]. The report states the opposite of the video. The exact pass counts are on screen only. |
[VIDEO], [VERIFY] numbers on screen |
| C3 |
L39-43 |
Throughput bands: native “1.0x to 0.7x”, managed “0.6x to 0.3x”, interpreted “0.05x to 0.001x”. |
The video gives no per-category numbers. It gives only the extremes of that day: a record of 7301 passes per second [20:38] and a slowest entry of “one pass every 294 seconds” [20:47]. That is a spread of about 2 million to 1. The lowest band (0.001x) is about 2,000 times too optimistic for the slowest entry. The bands are invented and look like measured data. |
[VIDEO], [DOC] |
| # |
Location |
Claim |
Problem |
Tag |
| M1 |
L11 |
The rules forbid “irregular wheel factorizations”. |
The repository rules (CONTRIBUTING.md of PlummersSoftwareLLC/Primes, read on the web in pass 1) permit wheel solutions. They get the tag algorithm=wheel. The rules do require a buffer that is allocated at run time, so that part is correct. |
[VERIFY] (web check done, confirm in pass 2) |
| M2 |
L32, L45-47 |
A packed bit array puts the “entire candidate buffer” in the L1 data cache. Memory drops “by an order of magnitude”. |
For odd numbers to one million, the bit array is 62,500 bytes (61 KiB). Most x86 CPUs have 32 to 48 KiB of L1 data cache, so the array does not fit. It fits the 128 KiB L1 of Apple M-series performance cores. L47 is more careful (“L2, and in many architectures L1”). A saving of 8 times is less than an order of magnitude (10 times). |
[KNOW] |
| M3 |
L27 |
Checks are removed with “-O3 combined with pragma assertions that suppress checks”. The checks “disrupt instruction pipelining”. GCC “vectorizes contiguous memory updates”. |
The mechanism is wrong. -O3 is an optimization level. It does not turn checks off. In Ada you turn checks off with pragma Suppress or the GNAT switch -gnatp. Check branches almost never fail, so the CPU predicts them well. The cost is extra instructions, not pipeline damage. The sieve writes with a stride (a fixed step larger than one), so vectorization is unlikely. Correct part: GNAT does run-time checks by default. |
[KNOW] |
| M4 |
L49 |
AOT compilers remove bounds-check branches “entirely”. Managed runtimes suffer “recurring branch misprediction penalties”. |
C and C++ have no bounds checks to remove. Compilers remove only the checks that they can prove safe. A check that never fails is almost never mispredicted. JIT compilers (compilers that run while the program runs) such as HotSpot also remove many range checks in loops. |
[KNOW] |
| M5 |
L20-22 |
Compiler table: Delphi uses “whole-program link-time code generation”. The Pascal memory strategy is “byte-boolean arrays or bitmapped primitives”. |
The Delphi compiler has a smart linker that drops unused code. It does not do link-time code generation. The row cites [1], the video, and the video says nothing about this. The video shows that the Pascal version uses a packed bit array [11:11] and the Delphi version uses ByteBool bytes [16:36]. The table does not give these facts. |
[VIDEO], [KNOW] |
| M6 |
L33 |
With {$R-} and {$Q-}, Free Pascal and Delphi compete “within a narrow margin of both Ada and C++”. |
Range and overflow checks are already off by default in Free Pascal. There is no C++ in E01 and Delphi has no score. The video does not show these switches. The sentence has no support. |
[KNOW], [VIDEO] |
| M7 |
L6, L16, L22, L41, L60 |
Citations support the E01 facts. |
The E01 focus (L6, L16) cites [2], a podcast summary of a different episode (C# against Java). L22, L41 and L60 cite [1], the video, for claims that the video does not make. See section 4. |
[DOC], [VIDEO] |
| # |
Location |
Claim |
Problem |
Tag |
| m1 |
L6 |
The series grew to “more than 60 programming languages”. |
The repository description says “100+” languages (read on the web in pass 1). The video says “some 45” [01:24]. |
[VERIFY] |
| m2 |
L5 |
The repository rose “to the top ranks of global developer trending charts”. |
The only citation is [2], a podcast summary. The captions do not say this. |
[VERIFY] |
| m3 |
L12 |
Each pass checks the prime count against a known value. |
The video shows ValidateResults, which compares the count with a table of known counts [13:04 to 13:21]. The captions do not show a check on every pass. |
[VIDEO], [VERIFY] |
| m4 |
L10, L46, L49 |
Formulas (the limit, the complexity, the footprint, the step). |
They are images (image1 to image5). A reader cannot copy them, search them or read them with a screen reader. The footprint number in L46 is not in the text. |
[DOC] |
| m5 |
L56 vs L43 |
Python trails Ada and Pascal “by one or two orders of magnitude”. |
L43 puts interpreted languages at 0.05x to 0.001x, which is 1.3 to 3 orders. The two statements do not agree. |
[DOC] |
| m6 |
L41 |
Fortran is in the native group of E01. |
E01 does not race Fortran. Dave only says that he did not have Fortran compilers ready [02:47]. Fortran comes in a later episode (E04). |
[VIDEO] |
| m7 |
L22 |
Delphi uses a “fastcall register convention”. |
Delphi calls this the “register” calling convention. It is similar to fastcall, but the name is different. |
[KNOW] |
| m8 |
L5 |
Dave Plummer is a “former Microsoft systems engineer”. |
Correct. He speaks of his Microsoft work in the MS-DOS and Windows 95 days [00:41]. |
[VIDEO] |
- The report lists 12 sources. The text cites 9 of them. Sources [9], [11] and [12] get no citation.
- [11] (a Reddit thread about C++ in 2023) and [12] (a Hackaday page about a string format) have no relation to the video.
- The most cited source is [6], a GitHub issue in the dotnet/vblang repository (16 times). It carries most of the Pascal, Delphi and cache claims.
- The next are [7], a Reddit thread about the results (13 times), and [2], a podcast summary of another episode (11 times). [7] carries the Ada compiler internals.
- [1] (the video) gets 8 citations. Several of them go on claims that the video does not make (M5, M7).
- The report cites no primary technical source: no Ada reference manual, no GNAT or Free Pascal manual, no CPU cache data, no repository rules file.
- The race result. Pascal beat Ada [20:03]. This is the only result in E01, and the report does not say it.
- Why Delphi has no score. ByteBool is not faithful to the original bit array, and Delphi needs a commercial license [16:36 to 17:03].
- Most of the video. The first 8 minutes are about the series: the volunteers (Rolf, Rutger and a contributor from Romania) [02:10 to 02:23], Docker containers (packaged build setups) for each language [08:45], one make command [03:04], and the language list [04:19].
- Dave’s own caution. He says that code style differs between authors [14:42 to 14:53]. He says the Ada result probably comes from the code [20:26]. The “drag racing club” rule is to improve the code, not to complain [19:14 to 19:29]. Results are for one machine on one day [20:38].
- Pascal facts in the video. The := assignment operator [10:14], array bounds that can start at any index [12:38], LOW and HIGH [12:27], native binaries [13:59], and the 32-bit index limit [10:32].
- A weak point in the video itself. Dave says Ada catches range violations at compile time [18:00]. That is only partly true. Many Ada range checks happen at run time. On this point the report (L27) is more accurate than the video.
- Relevance is low. This video is about Pascal, Delphi and Ada. Assembly and Fortran are only names in a list [02:47, 04:19]. For Fortran, the Dave’s Garage episode E04 (C++ against Fortran against Cobol) is the better video.
- Keep: the sieve as a practice program. The Sieve of Eratosthenes to one million is a good first program for the A side and the B side. The PlummersSoftwareLLC/Primes repository has PrimeAssembly and PrimeFortran folders (seen on the web in pass 1). You can read and run working examples.
- Keep: bit array against byte array. In assembly you do the shift and mask work yourself. In Fortran you can use a LOGICAL array or the bit functions IBSET, IBCLR and BTEST. Measure the two layouts on your own machine.
- Keep: run-time checks. Ada range checks are like the gfortran option -fcheck=bounds. Use checks while you learn, and turn them off only to measure speed.
- Ignore: the throughput bands (L39-43), the “safety costs nothing” conclusion (L55, L60) and the L1 cache claim (L32).