<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
  <channel>
    <title>Haralds Blog</title>
    <link>https://miamao.de/blog</link>
    <description>genug Unfug</description>
    <copyright>Harald Kirsch</copyright>
    <item>
      <link>/blog/2026-02/23.When_is_an_Exception_an_Exception.html</link>
      <title>When is an Exception an Exception</title>
      <pubDate>Mon, 23 Feb 2026 15:22:05 GMT</pubDate>
      <description>

 Recently I said
  that  
  checked exceptions or not really exceptional . Here is a good example about
  the tradeoffs. 

 Consider building a directed acyclic graph
  (DAG), a  
    dependency graph  for example. The  Node  class has a
  method to add a child: 

 
class Node {
  public void addChild(Node child) { ... }
}
 

 We must make sure that the graph stays acyclic. So the child node may not be an
  ancestor of the current node. We add a check to  addChild . 
 
class Node {
  public vo</description>
    </item>
    <item>
      <link>/blog/2026-01/22.Moving_Clocks_In_Special_Relativity.html</link>
      <title>Moving Clocks In Special Relativity</title>
      <pubDate>Thu, 22 Jan 2026 15:24:26 GMT</pubDate>
      <description>


 $\def\unit#1#2{#1\,\text{#2}}$ 



 What happens to a clock which is moved at some speed for some time. According
  to special relativity it runs slower on the move. Lets get a bit of an
  intuitive understanding of this. 

 Moving a light clock from here to there 
 I described
the  light
clock  earlier and showed how it runs slower when it is moving. Now, what if
we have two identical light clocks, synchronized at some position. Then we move
  one by a distance $d$ and then stop again. Does</description>
    </item>
    <item>
      <link>/blog/2026-01/11.Twin_Paradox_Explained_with_the_Light_Clock.html</link>
      <title>Twin Paradox Explained with the Light Clock</title>
      <pubDate>Thu, 22 Jan 2026 15:24:33 GMT</pubDate>
      <description>

 The Twin Paradox describes how one twin, traveling with non-trivial speed for
  some time and returning back home, is then younger than his twin. This is
  explained in detail by Special Relativity physics. See the
  Wikipedia  Twin
  Paradox  page, for example. 

 On this page you find wording like "...clock is running slow...". How's that?
  The explanation I can grok most easily makes use of
  the  Light
    Clock .
 

 

 While in the stationary clock, light is bouncing at full speed $c$ </description>
    </item>
    <item>
      <link>/blog/2025-08/31.Black_Holes_Singularity_Seriously.html</link>
      <title>Black Holes Singularity Seriously</title>
      <pubDate>Thu, 22 Jan 2026 11:34:58 GMT</pubDate>
      <description>

 $\def\unit#1#2{#1\,\text{#2}}$ 


 The Car 

 Consider a car with wheels having a circumference of $\unit{1}{m}$, so if the
  wheel turns around once per second, the car has a speed of one meter per
  second ($\unit1{m/s}$) or $\unit{3.6}{km/h}$. 

 The car has a somewhat peculiar stop watch on the dashboard. I thas a single
hand. The face is divided into 60 like sized parts suggesting that one round of
the hand is 60 seconds or one minute. Yet it is mechnically connected to one of
the wheels</description>
    </item>
    <item>
      <link>/blog/2025-06/30.Checked_Exceptions_are_not_Exceptions.html</link>
      <title>Checked Exceptions are not Exceptions</title>
      <pubDate>Mon, 23 Feb 2026 15:21:37 GMT</pubDate>
      <description>

 JavaScript/TypeScript has no  checked exceptions  and this bothers
me. 
    
 What are "checked exceptions"? 

 As far as I know, Java
introduced  checked
exceptions  whereby th signature advertises that function may throw an
exception of a specific type. For example  OutputStream.write()  is declared as:

 
  public void write(int b) throws IOException {
  ...
  }
 

 When another method calls it, it must do one of two things: 
 
   Use a  catch(IOException e) {...}  clause to catch
    and </description>
    </item>
    <item>
      <link>/blog/2024-08/18.A_Practical_Use_for_Regular_Language_Intersection.html</link>
      <title>A Practical Use for Regular Language Intersection</title>
      <pubDate>Thu, 22 Aug 2024 07:52:39 GMT</pubDate>
      <description>

Long story short:  Monqjfa  now has
                      an  intersection
                      operator .

 What is "Regular Language Intersection"? 
 A  regular language , simply put, is the set
        of strings you can match with a given regular expression. The
        regular expressions you find in programming languages or
        command line programs, though, are often somewhat enhanced with
  tricks to extend the theoretical setup somewhat. 

 There is a correspondence between pieci</description>
    </item>
    <item>
      <link>/blog/2024-08/03.Tomatenauflauf_mit_Pane_Carasau.html</link>
      <title>Tomatenauflauf mit Pane Carasau</title>
      <pubDate>Sat, 3 Aug 2024 09:41:54 GMT</pubDate>
      <description>

 Dies ist kein richtiges Rezept, da wir das jedesmal nach Belieben etwas
  variieren und ich die Zutatenmengen nie wirklich abgewogen habe. 

  Pane Carasau 
ist ein traditionelles Flatenbrot aus Sardinien. Wir bekommen es
manchmal beim italienischen Lebensmittelhändler um die Ecke oder bei
  unserem Bioshop. Frisch gekauft ist es sehr knusprig, in dem
  Auflauf wird es schön flauschig. 

 Zutaten 

 Die Mengen sind Schätzungen. 
 
   
     1-2 Lagen pro Auflaufebene 
     Pane Carasau 
   
  </description>
    </item>
    <item>
      <link>/blog/2024-06/28.Java_Wishlist:_Non_Null_Type_Definitions.html</link>
      <title>Java Wishlist: Non Null Type Definitions</title>
      <pubDate>Fri, 28 Jun 2024 08:36:28 GMT</pubDate>
      <description>

 Previous entries in my Java Wishlist series:
   
      Union Types  
    Thread Safety  
 
 

 I hope I don't need to cite  the
billion dollar mistake  or mention that Typescript has
explicit  null  typing? 

 Neither do I need to mention that there are  various annotation
frameworks  which allow to annotate a field or parameter as to
whether it may be  null  or not. Though having half a
gazillion frameworks suggests that you want to use none of them for
compatibility reasons. 


 The consens</description>
    </item>
    <item>
      <link>/blog/2024-06/16.Java_Wishlist:_Union_Types.html</link>
      <title>Java Wishlist: Union Types</title>
      <pubDate>Mon, 24 Jun 2024 15:00:08 GMT</pubDate>
      <description>

 This is the 2nd entry in my series about my Java wishlist,
the Java features which I would like to see most. Some are already on
the  JEP  list, some are
not. The previous entry is:
 
    Thread Safety  
 
 

 Now lets talk about union types. When programming some non-trivial
code in Typescript, I quickly learned to like union types, something
  like 

 
type Stuff = number | boolean | { option: string }
 

 And the meaning is pretty much what you expect. When you write 

 
function f(stuff: </description>
    </item>
    <item>
      <link>/blog/2024-06/04.Raising_or_Lowering_an_Index.html</link>
      <title>Raising or Lowering an Index</title>
      <pubDate>Mon, 24 Jun 2024 14:57:27 GMT</pubDate>
      <description>
 $
  \def\ve{\vec{e}}
  \def\onef{\tilde f}
$ 
 First the Rant 

 "You can use the metric to raise an index"  is what I
  found in one or the other physics text book. Surely I missed some
  context each time, so I couldn't help to swear: WTF, I like
  the indexes where they are, what is the point of raising or
  lowering them. It felt like the text was suggesting there is a
  church of the Oooompf, where physicists gather for rituals during
  which indices are flipped. But what is the point?

 </description>
    </item>
    <item>
      <link>/blog/2024-06/04.Java_Wishlist:_Thread_Safety.html</link>
      <title>Java Wishlist: Thread Safety</title>
      <pubDate>Mon, 24 Jun 2024 14:49:31 GMT</pubDate>
      <description>

 In the 1990s I felt proud to know
  Plauger's  The
  Standard C Library  nearly by heart, as well as many of the tools
  C has ready for you to really screw up. Many of the latter gather
  around fails to do the right thing with bytes provided by memory
  allocation,  malloc() . 

 It was a revelation to start coding in Java. Suddenly I could
concentrate on the programming problem to solve, rather than
remembering shit like  you shall not use  scanf("%s",
buf)   because it may write over the </description>
    </item>
    <item>
      <link>/blog/2024-05/19.Fermi_Paradox,_Yet_Another_Hypothesis.html</link>
      <title>Fermi Paradox, Yet Another Hypothesis</title>
      <pubDate>Mon, 24 Jun 2024 14:46:45 GMT</pubDate>
      <description>

 The  Fermi
Paradox  describes the confusing fact that we don't have made
contact with alien civilizations despite there being gazillions of
galaxies, stars and planets in the universe and we don't have a reason
  to assume that Earth is extremely special. 

 As Fermi is reported to have put it: "Where is everybody?" 

 For an explanation, Wikipedia lists over 20 hypothesis, one of which
is the  Zoo
Hypothesis  whereby aliens avoid us similar to how people avoid
  wild animals in a zoo: to not</description>
    </item>
    <item>
      <link>/blog/2024-04/18.Geometrized_Units.html</link>
      <title>Geometrized Units</title>
      <pubDate>Mon, 24 Jun 2024 14:46:09 GMT</pubDate>
      <description>

 When reading about theoretical physics, like relativity or quantum
mechanics, sooner or later you come across statements like "... with
$c=1$ ..." meaning the speed of light is set to be $1$. And
  similarly, for example with the gravitational constant: $G=1$. 

 This always made me grind my teeth, because: "One? One what?" And also
I take some confidence from checking units in a formula for better
understanding. If $c$ and $G$ just disappear, this can be quite
confusing. Or,
as  Alan
    L M</description>
    </item>
    <item>
      <link>/blog/2024-03/06.Kidney-Bohnen_Chili.html</link>
      <title>Kidney-Bohnen Chili</title>
      <pubDate>Mon, 24 Jun 2024 14:40:57 GMT</pubDate>
      <description>

 Das Rezept habe ich selbst "erfunden", obwohl natürlich klar ist, dass
ich das in ähnlicher Form irgendwo gegessen oder gelesen habe. Die
Kombination von Bohnen, Tomaten, scharf gewürzt und etwas Sähmigkeit
  durch den Feta ist sehr lecker. 

  Aufpassen:  der Feta und je nach Marke auch die Bohnen aus der Dose
bringen bereits  Salz  ins Gericht. Wenn das nicht reicht, lieber erst
  auf dem Teller nachsalzen. 

 Zutaten für 2 Personen 

 
    2  Zwiebel  
    1  rote Paprika  
    1/2  Staude</description>
    </item>
    <item>
      <link>/blog/2024-02/24.Wickeln_wir_die_reelle_Achse_um_einen_Kreis.html</link>
      <title>Wickeln wir die reelle Achse um einen Kreis</title>
      <pubDate>Mon, 24 Jun 2024 14:39:47 GMT</pubDate>
      <description>

 Vorgeplänkel 


 Die reellen Zahlen, $\RB$, sind schon ein wenig komisch, im Vergleich zu
den rationalen Zahlen $\QB$. Zur Erinnerung, $\QB$ sind die Zahlen die
sich als Brüche von ganze Zahlen ergeben, sowas wie $7/9$, $1/3$ oder
$31415926/10000000$. Man kann sie auch dadurch beschreiben, dass ihre
Darstellung als Dezimalzahl hinter dem Komma nach hinten raus
periodisch wird, das heißt dieselbe Ziffernfolge wiederholt sich
unendlich oft. Die Zahl $1{,}3$ is formal gleich $1{,}30000....$ und
</description>
    </item>
    <item>
      <link>/blog/2024-02/19.Configuring_Java_formatting_with_Emacs_lsp-mode.html</link>
      <title>Configuring Java formatting with Emacs lsp-mode</title>
      <pubDate>Mon, 24 Jun 2024 14:38:39 GMT</pubDate>
      <description>

 Continuing the series about
  of  configuring
  Emacs as a Java development IDE , lets talk about code
  formatting. 

 Emacs' lsp-mode uses
the  Eclipse
  language server  to stay informed about the Java code being
edited. This also includes the server's service to format part or all
of the Java code according to some rules. It employs Eclipse's code
formatter which has lots of options. When using the Eclipse UI, these
  can be tweaked visually in an extensive settings screen. 

 To use thes</description>
    </item>
    <item>
      <link>/blog/2024-02/15.Starting_with_emacs_lsp-mode_for_Java_development.html</link>
      <title>Starting with emacs lsp-mode for Java development</title>
      <pubDate>Mon, 24 Jun 2024 14:36:02 GMT</pubDate>
      <description>

 First the Rant 

 In ancient times (the 1980s) I learned programming mostly using Emacs
and some key bindings got chiseled into my brain forever. When I
started Java programming in Emacs, support for coding actions based on
compiler output, like quick fixes suggestions, was not available,
sadly. So I switched to Eclipse for Java programming. But my first
  action was to enable Emacs key bindings as far as available. 

 Only recently, around 2019, I switched mostly to Intellij, because
around </description>
    </item>
    <item>
      <link>/blog/2024-02/12.Good_Log_Messages.html</link>
      <title>Good Log Messages</title>
      <pubDate>Mon, 24 Jun 2024 14:32:22 GMT</pubDate>
      <description>

 In my previous jobs I also had to analyse log messages for which I did
not have the code readily available. Besides intentionally idiotic
messages like "trouble in paradise", I had my fair share of message
  that made me grind my teeth. They read like: 

 
   could not open file 
   could not connect 
   error parsing 
 

 These were the full texts, seriously. Why does the idiot not list the
file it can't open? Why can't they just tell me which crap they can't
parse? Had the information been </description>
    </item>
    <item>
      <link>/blog/2024-02/03.Käsefondue.html</link>
      <title>Käsefondue</title>
      <pubDate>Mon, 24 Jun 2024 14:31:24 GMT</pubDate>
      <description>

 Das Rezept habe ich irgendwo gefunden, minimal abgewandelt und
  so funktioniert es für uns immer perfekt. 

 Zutaten für 2 Personen 

 
    200g  Greyezer/Gruyere eher mittelalt, etwas teurer  
    100g  Emmentaler  
    100g  Appenzeller eher mittelalt, etwas teurer  
    1  Knoblauchzehe  
    200ml  Weißwein trocken  
    20ml  Kirschwasser  
    1,5 EL  Mondamin  
    1 Messerspitze  Natron  
    1  Baguette  
 
 Zubereitung 
 
   Käse grob hobeln 
   Kirschwasser und Mondamin mischen un</description>
    </item>
    <item>
      <link>/blog/2024-01/15.Bolaggio,_italienischer_Eintopf,_Variation.html</link>
      <title>Bolaggio, italienischer Eintopf, Variation</title>
      <pubDate>Sat, 3 Feb 2024 18:42:46 GMT</pubDate>
      <description>

Im Original wird das Rezept mit Schweinefleich formuliert, Bauch und
Schulter.

 Zutaten für 4 Portionen 

 
    500g  Lammgulasch  
    2  Zwiebeln  
    250g  Möhren  
    1  Weißkohl (ca. 600g)  
    2 Zehen  Knoblauch  
    3 El  Olivenöl  
    400g-Dose  Tomaten stückig  
    360g-Glas  kleine weiße Bohnen  
    250ml  Fleischbrühe aus fertiger Rinderbouillon  
       Peffer, Thymian, Rosmarin, Paprika edelsüß, Chiliflocken  
    1 Bund  Petersilie  
 

 Zubereitung 

 
   Zwiebeln, Möhre</description>
    </item>
  </channel>
</rss>