Congratulations!

[Valid RSS] This is a valid RSS feed.

Recommendations

This feed is valid, but interoperability with the widest range of feed readers could be improved by implementing the following recommendations.

Source: http://www.perturb.org/rss.php

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <?xml-stylesheet type="text/css" href="/css/rss-browser.css" ?>
  3. <rss version="2.0">
  4. <channel>
  5. <title>Perturb.org - Scott's Geek Stuff</title>
  6. <link>http://www.perturb.org/</link>
  7. <description>Just Geek Stuff</description>
  8.  
  9. <item>
  10. <guid isPermaLink="true">http://www.perturb.org/display/entry/1424/</guid>
  11. <title>Vim: Insert a line of characters</title>
  12. <link>http://www.perturb.org/display/entry/1424/</link>
  13. <description>&lt;p&gt;I need an 80 character divider of text in Vim. I can never remember the sequence so I&#039;m writing it down:&lt;/p&gt;
  14. &lt;pre&gt;&lt;code&gt;80i/&amp;lt;ESC&amp;gt;&lt;/code&gt;&lt;/pre&gt;
  15. &lt;p&gt;Will generate:&lt;/p&gt;
  16. &lt;pre&gt;&lt;code class=&quot;language-text&quot;&gt;////////////////////////////////////////////////////////////////////////////////&lt;/code&gt;&lt;/pre&gt;</description>
  17. <pubDate>Tue, 01 Apr 2025 00:00:00 -0700</pubDate>
  18. </item>
  20. <item>
  21. <guid isPermaLink="true">http://www.perturb.org/display/entry/1423/</guid>
  22. <title>Comparing 32bit and 64bit performance on low end micro-controllers</title>
  23. <link>http://www.perturb.org/display/entry/1423/</link>
  24. <description>&lt;p&gt;Testing 32bit vs 64bit PRNGs on a 32bit ESP32-C3 &lt;a href=&quot;https://gist.github.com/scottchiefbaker/e4c87de8d6c1ad4a33b1ffe5a3ce707f&quot;&gt;I&#039;m seeing&lt;/a&gt;:&lt;/p&gt;
  25. &lt;table&gt;
  26. &lt;thead&gt;
  27. &lt;tr&gt;
  28. &lt;th&gt;PRNG&lt;/th&gt;
  29. &lt;th&gt;Iterations per second&lt;/th&gt;
  30. &lt;th&gt;Output Bits&lt;/th&gt;
  31. &lt;th&gt;Bytes per second&lt;/th&gt;
  32. &lt;/tr&gt;
  33. &lt;/thead&gt;
  34. &lt;tbody&gt;
  35. &lt;tr&gt;
  36. &lt;td&gt;pcg32&lt;/td&gt;
  37. &lt;td&gt;487802&lt;/td&gt;
  38. &lt;td&gt;32&lt;/td&gt;
  39. &lt;td&gt;&lt;strong&gt;1951266.7 b/s&lt;/strong&gt;&lt;/td&gt;
  40. &lt;/tr&gt;
  41. &lt;tr&gt;
  42. &lt;td&gt;xoroshiro64**&lt;/td&gt;
  43. &lt;td&gt;&lt;strong&gt;516023&lt;/strong&gt;&lt;/td&gt;
  44. &lt;td&gt;32&lt;/td&gt;
  45. &lt;td&gt;2050966.7 b/s&lt;/td&gt;
  46. &lt;/tr&gt;
  47. &lt;tr&gt;
  48. &lt;td&gt;xoshiro256+&lt;/td&gt;
  49. &lt;td&gt;487808&lt;/td&gt;
  50. &lt;td&gt;64&lt;/td&gt;
  51. &lt;td&gt;&lt;strong&gt;3878726.7 b/s&lt;/strong&gt;&lt;/td&gt;
  52. &lt;/tr&gt;
  53. &lt;tr&gt;
  54. &lt;td&gt;xoshiro512++&lt;/td&gt;
  55. &lt;td&gt;441735&lt;/td&gt;
  56. &lt;td&gt;64&lt;/td&gt;
  57. &lt;td&gt;3514373.3 b/s&lt;/td&gt;
  58. &lt;/tr&gt;
  59. &lt;tr&gt;
  60. &lt;td&gt;splitmix64&lt;/td&gt;
  61. &lt;td&gt;462290&lt;/td&gt;
  62. &lt;td&gt;64&lt;/td&gt;
  63. &lt;td&gt;3677033.3 b/s&lt;/td&gt;
  64. &lt;/tr&gt;
  65. &lt;tr&gt;
  66. &lt;td&gt;pcg64&lt;/td&gt;
  67. &lt;td&gt;&lt;strong&gt;416297&lt;/strong&gt;&lt;/td&gt;
  68. &lt;td&gt;64&lt;/td&gt;
  69. &lt;td&gt;3313060.0 b/s&lt;/td&gt;
  70. &lt;/tr&gt;
  71. &lt;/tbody&gt;
  72. &lt;/table&gt;
  73. &lt;p&gt;Very little difference on PRNGs that use 64bit operations vs 32bit operations. Even on limited hardware like this it makes sense to use a 64bit PRNG because you get more bytes per cycle.&lt;/p&gt;</description>
  74. <pubDate>Wed, 05 Mar 2025 13:47:09 -0800</pubDate>
  75. </item>
  77. <item>
  78. <guid isPermaLink="true">http://www.perturb.org/display/entry/1422/</guid>
  79. <title>Vim: Convert your syntax highlighted text into HTML</title>
  80. <link>http://www.perturb.org/display/entry/1422/</link>
  81. <description>&lt;p&gt;Vim is my code editor of choice as it has great features, excellent syntax highlighting, and a robust plug-in infrastructure. I&#039;m very used to look and feel of Vim. If you want to share some of your code online, converting things to HTML can be problematic. Luckily Vim has a built in code to HTML converter:&lt;/p&gt;
  82. &lt;pre&gt;&lt;code&gt;:TOhtml&lt;/code&gt;&lt;/pre&gt;
  83. &lt;p&gt;Simply run the &lt;code&gt;:TOhtml&lt;/code&gt; command in an open text file and your buffer will be redrawn in HTML which you can then save. Here is a quick sample of my pcg32.pl script &lt;a href=&quot;https://www.perturb.org/code/pcg32.pl.html&quot;&gt;converted to HTML&lt;/a&gt;.&lt;/p&gt;</description>
  84. <pubDate>Wed, 26 Feb 2025 00:00:00 -0800</pubDate>
  85. </item>
  87. <item>
  88. <guid isPermaLink="true">http://www.perturb.org/display/entry/1421/</guid>
  89. <title>What kind of number makes a good seed for a PRNG?</title>
  90. <link>http://www.perturb.org/display/entry/1421/</link>
  91. <description>&lt;p&gt;&lt;a href=&quot;https://en.wikipedia.org/wiki/Pseudorandom_number_generator&quot;&gt;Pseudo-random number generators&lt;/a&gt; use complex math to generate random numbers on your computer. These random numbers are used for all sorts of things: simulations, fractals, games, art, and even math experiments. Computers can &lt;strong&gt;only&lt;/strong&gt; do math, which makes generating a random number difficult. &lt;/p&gt;
  92. &lt;p&gt;PRNGs need a &quot;seed&quot; number to kick off the math that generates sequences of random numbers. Some PRNGs require a 32bit seed, and some require a 64bit seed. Some PRNGs require one seed, and some require four (or more). It is important to know what type of seed your PRNG needs.&lt;/p&gt;
  93. &lt;p&gt;A 32bit number is between 0 and 4.2 billion and a 64bit number is between 0 and 18.4 quintillion. The larger a number is, the more bits are required to store it, and the better a seed it will make. The closer your seed is to the upper end of the number range the better. As a general rule a good seed will be a decimal number with 18 or 19 digits.&lt;/p&gt;
  94. &lt;p&gt;&lt;code&gt;12&lt;/code&gt; is a small number and &lt;strong&gt;not&lt;/strong&gt; a good seed, &lt;code&gt;4611686018427387906&lt;/code&gt; is a big number but still not a great seed. Seeds should &lt;strong&gt;not&lt;/strong&gt; have large sections of zero/one bits. This is why small numbers do not make good seeds. Bits can be visualized by printing the number in binary:&lt;/p&gt;
  95. &lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;# Horrible
  96. $ perl -E &#039;printf(&quot;%064b\n&quot;, 4611686018427387906)&#039;
  97. 0100000000000000000000000000000000000000000000000000000000000010
  99. # Bad
  100. $ perl -E &#039;printf(&quot;%064b\n&quot;, 17770)&#039;
  101. 0000000000000000000000000000000000000000000000000100010101101010
  103. # Poor
  104. $ perl -E &#039;printf(&quot;%064b\n&quot;, 2850756010)&#039;
  105. 0000000000000000000000000000000010101001111010110001010110101010
  107. # Good
  108. $ perl -E &#039;printf(&quot;%064b\n&quot;, 11337502976607798025)&#039;
  109. 1001110101010110111001101110001101111000101001000100001100001001&lt;/code&gt;&lt;/pre&gt;
  110. &lt;p&gt;Good seeds should have a &lt;em&gt;roughly&lt;/em&gt; even mix of zero and one bits. &lt;code&gt;9223372036854775808&lt;/code&gt; is a large number and looks promising but it has 63 zeros, and only a single one bit. You can visualize the quality of your seed with &lt;a href=&quot;https://www.perturb.org/code/seed_quality.pl&quot;&gt;seed_quality.pl&lt;/a&gt;. Quality above 75% should make for good seed numbers.&lt;/p&gt;
  111. &lt;p&gt;Seeds should &lt;strong&gt;not&lt;/strong&gt; be predictable. Do not use dates, times, or phone numbers as they are potentially guessable. Combinations of numbers can be good sources. Process PID, UID, unixtime are good potential sources &lt;em&gt;if&lt;/em&gt; they are combined together in a non-predictable way. PID multiplied by UID multiplied by Unixtime is an example of combining values. Memory locations of variables, especially if &lt;a href=&quot;https://en.wikipedia.org/wiki/Address_space_layout_randomization&quot;&gt;ASLR&lt;/a&gt; is in use is a potentially good source as well.&lt;/p&gt;
  112. &lt;p&gt;Hashing numbers, strings, or combinations of numbers can be a good way to generate seeds. Hashing a value with &lt;a href=&quot;https://github.com/scottchiefbaker/perl-Crypt-Komihash&quot;&gt;Komihash&lt;/a&gt; or &lt;a href=&quot;https://metacpan.org/pod/Digest::xxHash&quot;&gt;xxHash&lt;/a&gt; will generate a suitable 64bit number. Hashing a value with &lt;a href=&quot;https://metacpan.org/pod/Digest::SHA&quot;&gt;SHA256&lt;/a&gt; will generate a 256bit value which can be &lt;a href=&quot;https://www.perturb.org/display/1415_Perl_Using_sha256_to_hash_strings_into_integers.html&quot;&gt;split&lt;/a&gt; into four 64bit values. Hashing functions also do a good job of ensuring the bits are mixed well and do not include large repeating sections.&lt;/p&gt;
  113. &lt;p&gt;The best source of seed numbers is directly from your OS. On Linux this is &lt;code&gt;/dev/urandom&lt;/code&gt; and on Windows you can interface with the &lt;code&gt;RtlGenRandom&lt;/code&gt; API. These are carefully curated sources of &lt;em&gt;true&lt;/em&gt; randomness, but they can be slow-ish. Using them as a source for a fast PRNG is best practice.&lt;/p&gt;
  114. &lt;pre&gt;&lt;code class=&quot;language-perl&quot;&gt;sub get_64bit_seed {
  115.    open my $urandom, &#039;&amp;lt;:raw&#039;, &#039;/dev/urandom&#039; or croak(&quot;Couldn&#039;t open /dev/urandom: $!&quot;);
  116.    sysread($urandom, my $buf, 8) or croak(&quot;Couldn&#039;t read from csprng: $!&quot;);
  118.    return unpack(&quot;Q*&quot;, $buf);
  119. }&lt;/code&gt;&lt;/pre&gt;</description>
  120. <pubDate>Thu, 20 Feb 2025 00:00:00 -0800</pubDate>
  121. </item>
  123. <item>
  124. <guid isPermaLink="true">http://www.perturb.org/display/entry/1420/</guid>
  125. <title>Perl: Multiply-Shift Hash</title>
  126. <link>http://www.perturb.org/display/entry/1420/</link>
  127. <description>&lt;p&gt;I&#039;ve been using the multiply-shift hash lately and have had good results. It&#039;s simple, fast, and well tested. &lt;/p&gt;
  128. &lt;pre&gt;&lt;code class=&quot;language-c&quot;&gt;// Multiply-Shift Hash
  129. static uint64_t hash_msh(uint64_t x) {
  130.    uint64_t prime = 0x9e3779b97f4a7c15; // A large prime constant
  131.    x ^= (x &amp;gt;&amp;gt; 30);
  132.    x *= prime;
  133.    x ^= (x &amp;gt;&amp;gt; 27);
  134.    x *= prime;
  135.    x ^= (x &amp;gt;&amp;gt; 31);
  136.    return x;
  137. }&lt;/code&gt;&lt;/pre&gt;
  138. &lt;p&gt;Whenever I find interesting code like this I like to try and implement it in Perl:&lt;/p&gt;
  139. &lt;pre&gt;&lt;code class=&quot;language-perl&quot;&gt;sub hash_msh {
  140.    my $x     = $_[0];
  141.    my $prime = 11400714819323198485;
  143.    $x ^= ($x &amp;gt;&amp;gt; 30);
  144.    $x = multiply_uv($x, $prime);
  145.    $x ^= ($x &amp;gt;&amp;gt; 27);
  146.    $x = multiply_uv($x, $prime);
  147.    $x ^= ($x &amp;gt;&amp;gt; 31);
  149.    return $x;
  150. }
  152. # Perl converts numbers larger than 2^64 - 1 to floating point so
  153. # we &#039;use integer&#039; to force integer math which retains any overflow.
  154. sub multiply_uv {
  155.    my ($one, $two) = @_;
  157.    use integer;
  158.    my $ret = $one * $two;
  159.    no integer;
  161.    # Convert signed IV to unsinged UV
  162.    if ($ret &amp;lt; 0) {
  163.        $ret += 18446744073709551615;
  164.        $ret += 1;
  165.    }
  167.    return $ret;
  168. }&lt;/code&gt;&lt;/pre&gt;</description>
  169. <pubDate>Mon, 27 Jan 2025 00:00:00 -0800</pubDate>
  170. </item>
  172. <item>
  173. <guid isPermaLink="true">http://www.perturb.org/display/entry/1419/</guid>
  174. <title>Perl: Calculate number of bits needed to store a number</title>
  175. <link>http://www.perturb.org/display/entry/1419/</link>
  176. <description>&lt;p&gt;Quick Perl function to calculate the number of bits required to store a given number.&lt;/p&gt;
  177. &lt;pre&gt;&lt;code class=&quot;language-perl&quot;&gt;sub bits_required {
  178.    my ($n) = @_;
  180.    # Handle special case for 0
  181.    return 0 if $n == 0;
  183.    # Use logarithm to calculate the number of bits
  184.    my $bits = int(log($n) / log(2)) + 1;
  185.    return $bits;
  186. }&lt;/code&gt;&lt;/pre&gt;</description>
  187. <pubDate>Mon, 27 Jan 2025 00:00:00 -0800</pubDate>
  188. </item>
  190. <item>
  191. <guid isPermaLink="true">http://www.perturb.org/display/entry/1418/</guid>
  192. <title>Implmenting PRNGs in Perl</title>
  193. <link>http://www.perturb.org/display/entry/1418/</link>
  194. <description>&lt;p&gt;I&#039;m a big fan of the &lt;a href=&quot;https://www.pcg-random.org/download.html&quot;&gt;PCG32 PRNG&lt;/a&gt;. It&#039;s simple, fast, and well documented. As is usually the case when I find interesting code I try and find a way to implement it in Perl. PCG32 poses an interesting problem when one tries to implement it in Perl because all the math is performed using &lt;strong&gt;unsigned&lt;/strong&gt; integers and overflow. Most PRNGs use large numbers and overflow to work, that&#039;s their secret sauce.&lt;/p&gt;
  195. &lt;p&gt;Perl does not have a native unsigned type so I had to learn the guts of how Perl does math so I could emulate it. I ended up coming up with two different implementations, a native Perl implementation, and a version that uses &lt;code&gt;Math::Int64&lt;/code&gt;. Surprisingly the native version was &lt;em&gt;significantly&lt;/em&gt; faster. &lt;/p&gt;
  196. &lt;p&gt;Both implementations with detailed comments are available in &lt;a href=&quot;https://www.perturb.org/code/syntax_highlight.php?file=pcg32.pl&quot;&gt;pcg32.pl&lt;/a&gt; if you&#039;re interested in learning more about how to do integer style math in Perl. &lt;/p&gt;
  197. &lt;p&gt;As a bonus I also ported the &lt;a href=&quot;https://www.perturb.org/code/syntax_highlight.php?file=xoshiro256.pl&quot;&gt;xoshiro256 family&lt;/a&gt; into Perl. &lt;a href=&quot;https://www.perturb.org/code/syntax_highlight.php?file=splitmix64.pl&quot;&gt;Splitmix64&lt;/a&gt; ended up being a little more complicated to port, but I got it as well.&lt;/p&gt;</description>
  198. <pubDate>Sat, 25 Jan 2025 00:00:00 -0800</pubDate>
  199. </item>
  201. <item>
  202. <guid isPermaLink="true">http://www.perturb.org/display/entry/1417/</guid>
  203. <title>C/C++: List all #define macros</title>
  204. <link>http://www.perturb.org/display/entry/1417/</link>
  205. <description>&lt;p&gt;I need to target a specific platform with some code I&#039;m writing. You can list &lt;strong&gt;all&lt;/strong&gt; of the &lt;code&gt;#define&lt;/code&gt; macros on a given platform with these commands:&lt;/p&gt;
  206. &lt;pre&gt;&lt;code&gt;gcc -dM -E - &amp;lt; /dev/null&lt;/code&gt;&lt;/pre&gt;
  207. &lt;pre&gt;&lt;code&gt;clang -dM -E - &amp;lt; /dev/null&lt;/code&gt;&lt;/pre&gt;
  208. &lt;p&gt;In this big list of macros you should find something to help you target a given platform.&lt;/p&gt;</description>
  209. <pubDate>Wed, 22 Jan 2025 00:00:00 -0800</pubDate>
  210. </item>
  212. <item>
  213. <guid isPermaLink="true">http://www.perturb.org/display/entry/1416/</guid>
  214. <title>FFMPEG: Limit the output to only the encoding stats for quieter scripting</title>
  215. <link>http://www.perturb.org/display/entry/1416/</link>
  216. <description>&lt;p&gt;FFMPEG is a great tool, but it is very chatty. If you want to encode a file you&#039;ll get about 40 lines of headers and track information, most of which you probably will not read. For scripting purposes you probably &lt;strong&gt;only&lt;/strong&gt; want to see the statistics. If you start FFMPEG, hide the banner, and set the loglevel low you can output only the stats you need&lt;/p&gt;
  217. &lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;ffmpeg -y -hide_banner -loglevel quiet -stats ...&lt;/code&gt;&lt;/pre&gt;</description>
  218. <pubDate>Tue, 21 Jan 2025 00:00:00 -0800</pubDate>
  219. </item>
  221. <item>
  222. <guid isPermaLink="true">http://www.perturb.org/display/entry/1415/</guid>
  223. <title>Perl: Using sha256 to hash strings into integers</title>
  224. <link>http://www.perturb.org/display/entry/1415/</link>
  225. <description>&lt;p&gt;I need 64bit integers to seed some PRNG work I&#039;m doing. I found out that you can easily create four 64bit numbers from any string by using SHA256.&lt;/p&gt;
  226. &lt;pre&gt;&lt;code&gt;use Digest::SHA;
  228. my $input = $ARGV[0] || int(rand() * 1000000);
  230. # Get raw bytes and convert to an array of uint64_t
  231. my $hash = Digest::SHA::sha256($input);
  232. my @nums = unpack(&quot;Q*&quot;, $hash);
  234. print &quot;SHA256 Hashing &#039;$input&#039; to: &quot; . join(&quot;, &quot;, @nums) . &quot;\n&quot;;&lt;/code&gt;&lt;/pre&gt;
  235. &lt;p&gt;&lt;strong&gt;Note:&lt;/strong&gt; We are using &lt;code&gt;sha256&lt;/code&gt; here, not &lt;code&gt;sha256_hex&lt;/code&gt; because we need raw bytes to convert to integers with &lt;code&gt;unpack&lt;/code&gt;.&lt;/p&gt;</description>
  236. <pubDate>Mon, 20 Jan 2025 00:00:00 -0800</pubDate>
  237. </item>
  239. <item>
  240. <guid isPermaLink="true">http://www.perturb.org/display/entry/1414/</guid>
  241. <title>Komihash is pretty amazing and simple hashing algorithm</title>
  242. <link>http://www.perturb.org/display/entry/1414/</link>
  243. <description>&lt;p&gt;I need a simple way to hash strings into 64bit integers so I started &lt;a href=&quot;https://en.wikipedia.org/wiki/List_of_hash_functions#Non-cryptographic_hash_functions&quot;&gt;some research&lt;/a&gt;. Initially I was focusing on &lt;a href=&quot;https://github.com/Cyan4973/xxHash&quot;&gt;xxHash&lt;/a&gt; but it&#039;s slightly harder to implement than other newer hashes. I ended up landing on the amazing &lt;a href=&quot;https://github.com/avaneev/komihash&quot;&gt;Komihash&lt;/a&gt; which bills itself as: &quot;a very fast 64-bit hash function, mainly designed for hash-table, hash-map, and bloom-filter uses&quot;.&lt;/p&gt;
  244. &lt;p&gt;Komihash is available as a single &lt;code&gt;Komihash.h&lt;/code&gt; file and is &lt;em&gt;extremely easy&lt;/em&gt; to implement into existing code.&lt;/p&gt;
  245. &lt;pre&gt;&lt;code class=&quot;language-c&quot;&gt;#include &amp;lt;stdio.h&amp;gt;
  246. #include &amp;lt;stdlib.h&amp;gt;
  247. #include &quot;komihash.h&quot;
  249. int main(int argc, char *argv[]) {
  250.    int seed        = 0;
  251.    const char *buf = &quot;Hello world&quot;;
  253.    uint64_t hash_num = komihash(buf, strlen(buf), seed);
  255.    printf(&quot;Komihash: %s = %llu\n&quot;, buf, hash_num); // 3745467240760726046
  256. }&lt;/code&gt;&lt;/pre&gt;
  257. &lt;p&gt;As a bonus it also comes with a PRNG which is equally simple to implement:&lt;/p&gt;
  258. &lt;pre&gt;&lt;code class=&quot;language-c&quot;&gt;#include &amp;lt;stdio.h&amp;gt;
  259. #include &amp;lt;stdlib.h&amp;gt;
  260. #include &amp;lt;time.h&amp;gt;
  261. #include &quot;komihash.h&quot;
  263. int main(int argc, char *argv[]) {
  264.    uint64_t seed1 = time(NULL) * 0x61c8864680b583ebull; // hash64
  265.    uint64_t seed2 = seed1      * 0x61c8864680b583ebull; // hash64
  267.    for (int i = 0; i &amp;lt; 5; i++) {
  268.        uint64_t rand64 = komirand(&amp;amp;seed1, &amp;amp;seed2);
  269.        printf(&quot;Komirand: %llu\n&quot;, rand64);
  270.    }
  271. }&lt;/code&gt;&lt;/pre&gt;
  272. &lt;p&gt;In fact, I liked it so much I ported it to Perl and called it &lt;a href=&quot;https://github.com/scottchiefbaker/perl-Crypt-Komihash/&quot;&gt;Crypt::Komihash&lt;/a&gt;.&lt;/p&gt;</description>
  273. <pubDate>Fri, 17 Jan 2025 00:00:00 -0800</pubDate>
  274. </item>
  276. <item>
  277. <guid isPermaLink="true">http://www.perturb.org/display/entry/1413/</guid>
  278. <title>Perl: Warning about non-portable numbers</title>
  279. <link>http://www.perturb.org/display/entry/1413/</link>
  280. <description>&lt;p&gt;If you get a Perl warning about non-portable numbers like this:&lt;/p&gt;
  281. &lt;pre&gt;&lt;code class=&quot;language-bash&quot;&gt;Hexadecimal number &amp;gt; 0xffffffff non-portable at /tmp/x.pl line 19.&lt;/code&gt;&lt;/pre&gt;
  282. &lt;p&gt;It means that you are using a hex number greater than 2^32. I dunno why this is a warning when everything is 64bit these days, but it is. There have been a couple of times I needed this in my code so you can disable these warnings with:&lt;/p&gt;
  283. &lt;pre&gt;&lt;code class=&quot;language-perl&quot;&gt;no warnings &#039;portable&#039;;&lt;/code&gt;&lt;/pre&gt;</description>
  284. <pubDate>Thu, 16 Jan 2025 00:00:00 -0800</pubDate>
  285. </item>
  287. <item>
  288. <guid isPermaLink="true">http://www.perturb.org/display/entry/1412/</guid>
  289. <title>Books of 2025</title>
  290. <link>http://www.perturb.org/display/entry/1412/</link>
  291. <description>&lt;p&gt;List of books I read in 2025. Also see the list of &lt;a href=&quot;/display/1392_Books_of_2024.html&quot;&gt;2024&lt;/a&gt;. The date indicated denotes the date I started reading the book.  &lt;/p&gt;
  292. &lt;p&gt;2025-01-06 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+9781250318541&quot;&gt;Mistborn&lt;/a&gt; by Brandon Sanderson - 643 pages&lt;br /&gt;
  293. 2025-01-17 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+0812550706&quot;&gt;Ender&#039;s Game&lt;/a&gt; by Orson Scott Card - 324 pages&lt;br /&gt;
  294. 2025-01-22 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+0451137965&quot;&gt;Thinner&lt;/a&gt; by Stephen King - 318 pages&lt;br /&gt;
  295. 2025-01-26 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+0670260770&quot;&gt;The Dead Zone&lt;/a&gt; by Stephen King - 426 pages&lt;br /&gt;
  296. 2025-02-02 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+9780140074314&quot;&gt;The Neverending Story&lt;/a&gt; by Michael Ende - 377 pages&lt;br /&gt;
  297. 2025-02-08 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+9781250318572&quot;&gt;The Well Of Ascension&lt;/a&gt; by Brandon Sanderson - 785 pages&lt;br /&gt;
  298. 2025-02-21 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+9780399130397&quot;&gt;Skeleton Crew - The Monkey&lt;/a&gt; by Stephen King - 32 pages&lt;br /&gt;
  299. 2017-02-21 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=9780812550757&quot;&gt;Speaker for the Dead&lt;/a&gt; by Orson Scott Card - 395 Pages&lt;br /&gt;
  300. 2025-02-27 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+0670855030&quot;&gt;Insomnia&lt;/a&gt; by Stephen King - 787 pages&lt;br /&gt;
  301. 2025-03-11 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+9781250318626&quot;&gt;Hero Of Ages&lt;/a&gt; by Brandon Sanderson - 752 pages&lt;br /&gt;
  302. 2025-03-23 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+0812509250&quot;&gt;Xenocide&lt;/a&gt; by Orson Scott Card - 592 pages&lt;br /&gt;
  303. 2025-04-01 - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+9781984820709&quot;&gt;Tainted Cup&lt;/a&gt; by Robert Jackson Bennett - 410 pages  &lt;/p&gt;
  304. &lt;p&gt;2025-xx-xx - &lt;a href=&quot;//www.google.com/search?tbo=p&amp;amp;q=isbn+9780345314253&quot;&gt;The Sword Of Shannara&lt;/a&gt; by Terry Brooks - 726 pages  &lt;/p&gt;</description>
  305. <pubDate>Wed, 08 Jan 2025 00:00:00 -0800</pubDate>
  306. </item>
  308. <item>
  309. <guid isPermaLink="true">http://www.perturb.org/display/entry/1411/</guid>
  310. <title>C: Nanoseconds since Unix epoch</title>
  311. <link>http://www.perturb.org/display/entry/1411/</link>
  312. <description>&lt;p&gt;I needed a function to use as a simple seed for &lt;code&gt;srand()&lt;/code&gt;. Unixtime in nanoseconds changes very frequently and serves as a semi-decent random seed.&lt;/p&gt;
  313. &lt;pre&gt;&lt;code class=&quot;language-c&quot;&gt;#include &amp;lt;time.h&amp;gt; // for clock_gettime()
  315. // Nanoseconds since Unix epoch
  316. uint64_t nanos() {
  317.    struct timespec ts;
  319.    // int8_t ok = clock_gettime(CLOCK_MONOTONIC, &amp;amp;ts); // Uptime
  320.    int8_t ok = clock_gettime(CLOCK_REALTIME, &amp;amp;ts);  // Since epoch
  322.    if (ok != 0) {
  323.        return 0; // Return 0 on failure (you can handle this differently)
  324.    }
  326.    // Calculate nanoseconds
  327.    uint64_t ret = (uint64_t)ts.tv_sec * 1000000000ULL + (uint64_t)ts.tv_nsec;
  329.    return ret;
  330. }&lt;/code&gt;&lt;/pre&gt;
  331. &lt;p&gt;See also: &lt;a href=&quot;/display/1409_Perl_Get_microseconds_since_Unix_epoch.html&quot;&gt;Microseconds&lt;/a&gt; since epoch in Perl&lt;/p&gt;</description>
  332. <pubDate>Tue, 31 Dec 2024 00:00:00 -0800</pubDate>
  333. </item>
  335. <item>
  336. <guid isPermaLink="true">http://www.perturb.org/display/entry/1410/</guid>
  337. <title>Git: Show all changes to a given file</title>
  338. <link>http://www.perturb.org/display/entry/1410/</link>
  339. <description>&lt;p&gt;If you want to view the history of all the changes you&#039;ve made to a specific file in Git you can use the &lt;code&gt;log&lt;/code&gt; command in Git. This will show you all the commits that touched that file, and the associated commit message. &lt;/p&gt;
  340. &lt;pre&gt;&lt;code&gt;git log README.md&lt;/code&gt;&lt;/pre&gt;
  341. &lt;p&gt;If you want to see a diff/patch for each commit you can run:&lt;/p&gt;
  342. &lt;pre&gt;&lt;code&gt;git log --follow --patch README&lt;/code&gt;&lt;/pre&gt;
  343. &lt;p&gt;This can be very useful to track down when a specific piece of code went into (or was taken out of) a file. Be careful as this command only shows you the diff/patch for the file you request. If the commit contains changes to other files you will &lt;strong&gt;not&lt;/strong&gt; see those unless you view the full commit.&lt;/p&gt;</description>
  344. <pubDate>Tue, 31 Dec 2024 00:00:00 -0800</pubDate>
  345. </item>
  347. </channel>
  348. </rss>
  349.  

If you would like to create a banner that links to this page (i.e. this validation result), do the following:

  1. Download the "valid RSS" banner.

  2. Upload the image to your own server. (This step is important. Please do not link directly to the image on this server.)

  3. Add this HTML to your page (change the image src attribute if necessary):

If you would like to create a text link instead, here is the URL you can use:

http://www.feedvalidator.org/check.cgi?url=http%3A//www.perturb.org/rss.php

Home · About · News · Docs · Terms

 
Copyright © 2002-9 Sam Ruby, Mark Pilgrim, Joseph Walton, and Phil Ringnalda