Posts
-
Jul 30, 2025
Optimizing training a GPT style Tokenizer with C++
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Nov 5, 2022
The Magic of Lazy Lists
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 4, 2021
Monad Transformers - the prelude to ZPure
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 2, 2021
Monads in Scala 3 for the Genius
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 21, 2021
Functional Error Handling with Applicative in Scala 3
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 6, 2021
Handling Errors functionally with Scala 3
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Dec 6, 2020
Type classes with Scala 2
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Nov 18, 2020
Scala 3 Context Functions
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Aug 2, 2020
What's Ap with zio-prelude?
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 4, 2020
What's Ap?
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Mar 9, 2020
How to blog with Org-mode
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 20, 2019
Comonads for Life
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 10, 2019
Monoids for Production
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 5, 2019
Using 47 Degree's Fetch library with ZIO
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 7, 2019
Hacker News API Part 5
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Nov 19, 2018
Eredis - An updated Emacs Redis API
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 24, 2018
Radix trees, Dash and Company mode
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 5, 2018
Hacker News API Part 4
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 11, 2017
Hacker News API Part 3
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Aug 27, 2017
Roman numeral tool with Udash
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jul 30, 2017
Hacker News API Part 2
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jul 26, 2017
Hacker News API Part 1
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jul 16, 2017
Future with timeout
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 18, 2017
Future[Either] with Cats
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 2, 2017
Future[Either] and monad transformers
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 17, 2016
Using Python in org-mode
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 22, 2015
Including equations in a blogger post
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 17, 2015
Installing RPostgreSQL for R on Max OS Yosemite
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 29, 2014
Easy find
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 26, 2014
Sending notifications from Emacs (Mac OS X)
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 1, 2014
Watch
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Mar 12, 2014
Checkout out your DB tables
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 6, 2013
Configuring emacs to send iCloud mail on Mac OS X
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 29, 2012
find grep on Mac OS X
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Mar 22, 2012
Starting a program to run in the background from a DOS prompt
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Dec 26, 2011
Making a emacs lisp expression expand itself to XML
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jul 30, 2011
eredis update
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jul 25, 2011
eredis: a Redis client in emacs lisp
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 14, 2011
Emacs progress indication
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 6, 2011
More on duplicate file handling in emacs dired
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 2, 2011
Finding duplicate files in a dired buffer
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 26, 2011
Programmer tips for Mac OSX
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 26, 2011
MovieRatings
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 26, 2011
Talking to mysql from Python on Mac OS X 10.6
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 15, 2011
Grabbing Rotten Tomatoes movie ratings with Clojure
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 11, 2011
View Data from the Clojure REPL
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Dec 15, 2010
F# vs C#
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Nov 2, 2010
Just browsing
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 19, 2010
rgrep on windows 7 for emacs
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jul 30, 2010
Couple of mysql tips
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 8, 2010
Adjusting server logging level at runtime
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 17, 2010
Growling Mac
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 17, 2010
Using tar and gzip
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 24, 2010
Nice Code
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 2, 2010
Securing an ssh server with fail2ban
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 2, 2010
Using screen
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 13, 2009
Transparent emacs on windows
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 9, 2009
MSDOS iterating filenames in a file
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 23, 2009
Windows command window title
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 21, 2009
English quote in Common Lisp
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 10, 2009
Making emacs growl
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 8, 2009
Directional window movement in emacs
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 1, 2009
Handful of emacs tips
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Aug 27, 2009
Simple budget forecasts in emacs
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jun 17, 2009
1337 on StackOverflow
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 27, 2009
Linux: Looking at files changed recently
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 14, 2009
Linking MingW32 with psapi
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 14, 2009
Writing quick C++ programs in emacs without a makefile
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 13, 2009
Converting flac to mp3
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 8, 2009
emacs: Renaming multiple files at once with a regular expression
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 7, 2009
emacs: Searching programming API's with webjump
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 15, 2009
Running an elisp function on each marked file in a dired buffer
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Apr 2, 2009
Securely copying files to another machine
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Mar 18, 2009
Vancouver game companies
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Mar 9, 2009
Using tags in emacs on windows
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 20, 2009
Sending mail with emacs in Windows
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 17, 2009
Who uses the A* code
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 17, 2009
A* algorithm bug fixes
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 14, 2009
Setting up lispworks personal
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 14, 2009
Searching Reddit, Flickr, and Google from emacs = Rad
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 8, 2009
Fun with RSS
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Feb 7, 2009
Sending email via gmail in emacs
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 23, 2009
Simple perforce checkout in emacs using elisp
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 12, 2009
Finding writable files in a directory in a windows command line
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 8, 2009
Who changed the line your working on last?
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Nov 21, 2008
How to copy an SVN repository from sourceforge to google code
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Nov 9, 2008
Grabbing info from web pages
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 28, 2008
Using find and printf
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 13, 2008
Batch file tip ... %~dp0
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
May 1, 2008
Copying characters from the line above in emacs
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Mar 1, 2008
Is it a leap year
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Jan 29, 2008
emacs - a simple search and replace function
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Dec 8, 2007
emacs: how-many
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Dec 7, 2007
C: Passing on variadic function arguments to another function
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 24, 2007
Ubuntu 7.10
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 24, 2007
C and C++ function pointers
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Oct 9, 2007
Avoiding Ten Common Game AI Mistakes
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 27, 2007
11 Visual Studio tricks in Emacs
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 22, 2007
Word numbers programming puzzle
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 12, 2007
Commenting out a block of C++ in emacs
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 11, 2007
Adding C++ class names to a function name
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
-
Sep 7, 2007
Fixing up windows pathnames to use in cygwin
An in-depth look at how lazy evaluation in data structures like lists can lead to more efficient and elegant code, especially when dealing with infinite sequences or large datasets.
subscribe via RSS