fix html

matu3ba · matu3ba · commit 1bfe684aaef7 · 2024-11-01T22:21:01.000+01:00
diff --git a/impressum.html b/impressum.html
@@ -1,14 +1,15 @@
 <!doctype html>
 <title>Impressum</title>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 
 <h2>Impressum und ViSdP</h2>
 
-<i>[Demanded by German law]</i><p>
+<i>[Demanded by German law]</i>
+<p>
 
 Placeholder until E-Mail for contact.<br>
 Name<br>
 Street<br>
 City<br>
 
-<p>
+</p>
diff --git a/index.html b/index.html
@@ -26,8 +26,6 @@ <h2>Posts</h2>
   </ul>
 </div>
 
-<p>
-
 <div style="text-align:left">Handwritten until there are more entries.
 <br><a href="impressum.html">Impressum, Datenschutz</a>
 </div>
diff --git a/post/ci_library.html b/post/ci_library.html
@@ -79,6 +79,7 @@
 
 </style>
 <div id="contents">
+</div>
 <div style="text-align:left; padding up down: 1em">
 <h2>Towards an extensible continuos integration library.</h2>
 </div>
diff --git a/post/optimal_debugging.html b/post/optimal_debugging.html
@@ -208,7 +208,7 @@ <h2>Towards an optimal debugging framework library.</h2>
     <!-- hw -> kernel -> user space resources -->
       <ol>
         <li>Debugging hard(ware) problems</li>
-        <a href"https://interrupt.memfault.com/blog/schematic-review-checklist">
+        <a href="https://interrupt.memfault.com/blog/schematic-review-checklist">
           Hardware design reviews</a> with extensive focus on core components
         (power, battery, periphery, busses, memory/flash and debug/test infrastructure)
         to enable debugging and component tests against product and assembling defects.
@@ -290,7 +290,22 @@ <h2>Towards an optimal debugging framework library.</h2>
             <li>incorrect protocol handling</li>
             <li>insufficient handling of or the software requirements themself</li>
           </ol>
-            TODO: more things missing, unclear what to use ideally
+          The source of these problems are usually
+          <ol>
+            <li> incorrect constrains on the design, meaning how the different
+              parts should interact and work towards the goals for the use
+              cases</li>
+            <li> unclear, unspecified or incorrectly assumed hardware or software
+              guarantees by components </li>
+            <li> implementation oversights, unintended use cases, unfeasibility
+              of a general solution due to time and/or money constrains</li>
+          </ol>
+          Formal modeling of the design, model checking, code review, writing
+          tests for edge cases or runtime validation are typically used with
+          best practice being to write code in a risk-aware, testable and
+          debuggable way. The methods and scope are here very wide and very
+          domain and use case specific, so no general or short recommendation
+          can be made.
         </li>
         <!-- https://www.cprogramming.com/tutorial/memory_debugging_parallel_inspector.html -->
       </ol>
@@ -301,8 +316,11 @@ <h2>Towards an optimal debugging framework library.</h2>
         <li>minimal descriptions for C, Rust, Zig; Posix, Linux, Windows</li>
       </ol>
 
-      Overall, one can summarize that it is <b>good practice to have</b> a
-      <b>system correctness and debugging strategy</b>.
+      Ideally, only the system behavior and interactions with domain and
+      use-case specific parts need cognitive load from the programmer, whereas
+      the other error classes have standard approaches to isolate and eliminate.
+      Unifying debug tooling simplifies usage for bigger developer productivity
+      and exposing as library allows to automate this process.
 
       <!-- <li>Verification</li> -->
     <li><a href="#uniform_execution_representation">Uniform execution representation.</a></li>
@@ -329,4 +347,5 @@ <h2>Towards an optimal debugging framework library.</h2>
   <!-- Section 3: Uniform execution representation and queries over program execution.<br> -->
   <!-- Section 4: Abstraction problems during problem isolation.<br> -->
   <!-- Section 5: Program modification and validation language, query language and alternatives.<br> -->
+</div>
 </html>
diff --git a/post/process_behavior.html b/post/process_behavior.html
@@ -79,6 +79,7 @@
 
 </style>
 <div id="contents">
+</div>
 <div style="text-align:left; padding up down: 1em">
 <h2>Process semantics and abstraction problems on Linux, MacOS, Posix, Windows.</h2>
 </div>
diff --git a/post/shennanigans_in_c.html b/post/shennanigans_in_c.html
diff --git a/post/shennanigans_in_cpp.html b/post/shennanigans_in_cpp.html
@@ -113,7 +113,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">};</span>
 <span class="line"><span class="tok-kw">class</span> T2 {</span>
 <span class="line"><span class="tok-kw">public</span>:</span>
-<span class="line">    std::map<std::string, T1> mapex1;</span>
+<span class="line">    std::map&lt;std::string, T1&gt; mapex1;</span>
 <span class="line">    <span class="tok-kw">void</span> AddT1 (<span class="tok-kw">const</span> std::string &amp;t1str) {</span>
 <span class="line">        T1 t1obj(t1str);</span>
 <span class="line">        mapex1.emplace(t1str, t1obj);</span>
@@ -151,7 +151,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">                         , 1, 0, 0, 0</span>
 <span class="line">                         , 0, 0, 0, 0 };</span>
 <span class="line">  <span class="tok-comment">// clang-format: on</span></span>
-<span class="line">  <span class="tok-type">int64_t</span> val_mcpy;
+<span class="line">  <span class="tok-type">int64_t</span> val_mcpy;</span>
 <span class="line">  <span class="tok-comment">// val_mcpy = memcpy(&amp;val_mcpy, some_vals[1], <span class="tok-builtin">sizeof</span>(val_mcpy);  // refusal to compile</span></span>
 <span class="line">  val_mcpy = <span class="tok-builtin">memcpy</span>(&amp;val_mcpy, &amp;some_vals[1], <span class="tok-builtin">sizeof</span>(val_mcpy);   // refusal to compile</span>
 <span class="line">  <span class="tok-type">int64_t</span> val_wrong = *<span class="tok-builtin">reinterpret_cast</span>&lt;<span class="tok-type">int64_t</span>*&gt;(some_vals[1]);            <span class="tok-comment">// runtime error</span></span>
@@ -162,7 +162,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">  <span class="tok-kw">if</span> (val != <span class="tok-number">INT64_MIN</span>) <span class="tok-kw">return</span> 1;</span>
 <span class="line">  <span class="tok-kw">return</span> 0;</span>
 <span class="line">}</span>
-</code></pre>
+</code></pre></figure>
     </li>
 
     <li> <a href="https://stackoverflow.com/questions/11598990/is-stdstoi-actually-safe-to-use">
@@ -192,12 +192,12 @@ <h2>Some C++ footgun avoidance.</h2>
     <li> Checking, if typename is a string is complex (even with C++17 extension).
       <figure><figcaption class="cpp-cap"><cite class="file">is_typname_string.hpp</cite></figcaption>
 <pre><code><span class="line"><span class="tok-type">template</span>&lt;typename STR&gt;</span>
-<span class="line"><span class="tok-type">inline</span></span> <span class="tok-type">constexpr</span> bool is_string_class_decayed = false;</span>
+<span class="line"><span class="tok-type">inline</span> <span class="tok-type">constexpr</span> bool is_string_class_decayed = false;</span>
 <span class="line"><span class="tok-type">template</span>&lt;typename... STR&gt;</span>
 <span class="line"><span class="tok-type">inline</span> <span class="tok-type">constexpr</span> bool is_string_class_decayed&lt;std::basic_string&lt;STR...&gt;&gt; = true;</span>
 <span class="line"><span class="tok-comment">// decay_t will remove const, &amp; and volatile from the type</span></span>
 <span class="line"><span class="tok-type">template</span>&lt;typename STR&gt;</span>
-<span class="line"><span class="tok-type">inline</span></span> <span class="tok-type">constexpr</span> bool is_string_class = is_string_class_decayed&lt;std::decay_t&lt;STR&gt;&gt;</span>
+<span class="line"><span class="tok-type">inline</span> <span class="tok-type">constexpr</span> bool is_string_class = is_string_class_decayed&lt;std::decay_t&lt;STR&gt;&gt;</span>
 <span class="line"><span class="tok-type">template</span> &lt;typename TChar, typename TString&gt;</span>
 <span class="line"><span class="tok-type">inline</span> <span class="tok-type">constexpr</span> bool is_string = is_string_class&lt;TString&gt; &amp;&amp; std::is_same_v&lt;TChar, typename TString::value_type&gt;;</span>
 <span class="line"><span class="tok-kw">static_assert</span>(is_string_class&lt;std::string&gt;);</span>
@@ -221,7 +221,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <pre><code><span class="line"><span class="tok-kw">void</span> cstring_string_interop() {</span>
 <span class="line">  <span class="tok-kw">const</span> <span class="tok-type">char</span> * cmd = <span class="tok-str">"ls"</span>;</span>
 <span class="line">  <span class="tok-type">char</span> <span class="tok-kw">const</span> * buffer[] = {<span class="tok-str">"ls"</span>, <span class="tok-str">"-l"</span>, NULL};</span>
-<span class="line">  <span class="tok-type">char</span> * <span class="tok-kw">const</span> * argv = <span class="tok-builtin">const_cast</span><<span class="tok-type">char</span> * <span class="tok-kw">const</span> *&gt;(buffer);</span>
+<span class="line">  <span class="tok-type">char</span> * <span class="tok-kw">const</span> * argv = <span class="tok-builtin">const_cast</span><span class="tok-type">char</span> * <span class="tok-kw">const</span> *&gt;(buffer);</span>
 <span class="line">  int execed = execve(cmd, argv, NULL);</span>
 <span class="line">  (<span class="tok-kw">void</span>)execed;</span>
 <span class="line">}</span>
@@ -246,7 +246,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">    <span class="tok-type">static</span> <span class="tok-type">constexpr</span> <span class="tok-kw">const</span> T value = v;</span>
 <span class="line">  };</span>
 <span class="line">}</span>
-<span class="line"><span class="tok-builtin">#define</span> FORCE_CONST_EVAL(exp) ::util_force_const_eval::const_expr_value<decltype(exp), exp>::value</span>
+<span class="line"><span class="tok-builtin">#define</span> FORCE_CONST_EVAL(exp) ::util_force_const_eval::const_expr_value&lt;decltype(exp), exp&gt;::value</span>
 <span class="line"><span class="tok-builtin">#define</span> LEAF(FN) (&amp;FN[FORCE_CONST_EVAL(fname_offs(FN))])</span>
 <span class="line"></span>
 <span class="line"><span class="tok-type">int</span> testEq(<span class="tok-type">int32_t</span> a, <span class="tok-type">int32_t</span> b) {</span>
@@ -303,7 +303,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">    fprintf(stdout, <span class="tok-str">"%x, "</span>, array[i]);</span>
 <span class="line">  fprintf(stdout, <span class="tok-str">"\n"</span>)</span>
 <span class="line">}</span>
-</code></pre>
+</code></pre></figure>
     </li>
 
     <li> Incomplete type can not be instantiated in template:
@@ -327,7 +327,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">  <span class="tok-kw">public</span>:</span>
 <span class="line">  <span class="tok-type">int</span> SomeMethod() <span class="tok-kw">override</span> {</span>
 <span class="line">    <span class="tok-kw">return</span> 1;</span>
-<span class="line">  }
+<span class="line">  }</span>
 <span class="line">  <span class="tok-type">virtual</span> ~CSomeClass(); <span class="tok-comment">// missing virtual technical UB</span></span>
 <span class="line">};</span>
 <span class="line"><span class="tok-kw">class</span> CSomeDerivedClass : CSomeClass</span>
@@ -339,7 +339,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">  }</span>
 <span class="line">  <span class="tok-type">virtual</span> ~CSomeDerivedClass(); <span class="tok-comment">// optional virtual</span></span>
 <span class="line">};</span>
-</code></pre>
+</code></pre></figure>
     </li>
 
     <li> Why exceptions do not scale.
@@ -386,7 +386,7 @@ <h2>Some C++ footgun avoidance.</h2>
 <span class="line">  }</span>
 <span class="line">  <span class="tok-kw">return</span> 0;</span>
 <span class="line">}</span>
-</code></pre>
+</code></pre></figure>
     </li>
 
     <li><code>__STDC_VERSION__</code> <a href="https://github.com/open-mpi/ompi/pull/7817">is not necessary defined</a> by C++ compilers.
diff --git a/post/shennanigans_in_python.html b/post/shennanigans_in_python.html
@@ -85,13 +85,16 @@
 <div style="text-align:left; padding up down: 1em">
 <h2>Python shennanigans.</h2>
 </div>
+<p>
   The following shennanigans were collected during my work on creating a system
   integration library and framework for hardware and software tests including
   developer tasks like worktree management, building, target deployment and
   configuration. Therefore it should be representative for things one
   might want to do in absence of better tooling. The used Python version was
-  3.8.2, but most problems still persist.<p>
+  3.8.2, but most problems still persist.
+</p>
 
+<p>
   My <b>tldr;</b> retrospection upfront, which you may be able to reproduce
   once you try to code long-running services, which recover from all failures,
   cleanly reset state or generally try to debug spurious problems. Please don't.<br>
@@ -104,7 +107,8 @@ <h2>Python shennanigans.</h2>
   different combination of traversal) becomes unreasonably verbose and error
   prone. The alternative is to use C-like error handling, which requires to figure out
   all possible exceptions of Python libstd methods, which language servers
-  do not support (as of 20240404).<p>
+  do not support (as of 20240404).
+</p>
 
   Aside of these more fundamental limitations, here the list of shennanigans I have run into:
 <ul>
@@ -131,7 +135,7 @@ <h2>Python shennanigans.</h2>
 <span class="line">    <span class="tok-comment"># return big | small == big</span></span>
 <span class="line">    <span class="tok-comment"># also:</span></span>
 <span class="line">    <span class="tok-comment"># return {**big, **small} == big</span></span>
-<span class="line">    <span class="tok-kw">return</span> <span class="tok-type">dict</span>(big, **small) == big</span></span>
+<span class="line">    <span class="tok-kw">return</span> <span class="tok-type">dict</span>(big, **small) == big</span>
 </code></pre>
       </figure>
   </li>
@@ -272,9 +276,9 @@ <h2>Python shennanigans.</h2>
   <li>
 Generic module annotation is not allowed and mypy has no explicit docs for this.
 The following does not work and 'module: object' is the closest we can get as simple annotation.
-      <figure><figcaption class="py-cap"><cite class="file">modle_annotation.py</cite></figcaption>
+      <figure><figcaption class="py-cap"><cite class="file">module_annotation.py</cite></figcaption>
 <pre><code><span class="line"><span class="tok-fn">def</span> check_fn(module: ModuleType) -&gt; <span class="tok-type">int</span>:</span>
-<span class="line">    <span class="tok-kw">if</span> str(type(module)) != "<class 'module'>": <span class="tok-kw">return</span> 1</span>
+<span class="line">    <span class="tok-kw">if</span> str(type(module)) != "module": <span class="tok-kw">return</span> 1</span>
 <span class="line">    <span class="tok-kw">return</span> 0</span>
 </code></pre>
       </figure>
diff --git a/post/shennanigans_in_zig.html b/post/shennanigans_in_zig.html
@@ -86,15 +86,19 @@
 <div style="text-align:left; padding down up: 1em">
 <h2>Zig shennanigans.</h2>
 </div>
-As of <strike>20240404 (zig version 0.12.0-dev.3562+96bc8f17c)</strike>
+As of <del>20240404 (zig version 0.12.0-dev.3562+96bc8f17c)</del>
+<p>
   20240701 (zig version 0.14.0-dev.4234+1e3fb4825), Zig provides
   one of the best possible semantics to optimize memory details, while
   offering widely portable source code with reasonable safety in a
-  relative concise and readable way.<p>
+  relative concise and readable way.
+</p>
+<p>
   Aside of signaling for toolings, I found personally no major annoying
   parts.<br>
   For example, picking up nested slices and some build system parts might be
   inconvenient, but those are one time things and no footguns.<br>
+</p>
   The rest of the language feels very smooth to me in contrast to the potential
   very flexible and cryptic syntax of C (see <a href="https://github.com/JadLevesque/PPMP-Iceberg">preprocessor iceberg</a>).
   <ul>
@@ -164,5 +168,6 @@ <h2>Zig shennanigans.</h2>
       </ol>
       (Updated 20240701)
     </li>
+  </ul>
 </div>
 </html>
