Lightnews — Scholar-powered news

Lani

@laniakita.com

_Ninja build hates this one weird trick!_

Context: I have finally stumbled upon a reason against setting `CMAKE_GENERATOR=Ninja` globally (...on Windows at least).

$``` if(NOT (CMAKE_VS_PLATFORM_NAME STREQUAL X64 OR CMAKE_VS_PLATFORM_NAME STREQUAL x64)) message(FATAL_ ERROR "This file is for Windows x64 only. Given: ${CMAKE_VS_PLATFORM__NAME}") endif() ```$

November 21, 2025 at 8:10 AM

Lani

@laniakita.com

This is a beautiful Rust feature explorer created by Systemcluster, and it has made my evening! I am grateful this exists.

unstablerust.dev

Screenshot of the unstable rust explorer application created by @systemcluster. It shows Rust 1.90.0 selected, with the New Language Feature, embed_source underlined, and its description below.

embed_source description:

This flag controls whether the compiler embeds the program source code text into the object debug information section. It takes one of the following values:

y, yes, on or true: put source code in debug info.
n, no, off, false or no value: omit source code from debug info (the default).
This flag is ignored in configurations that don't emit DWARF debug information and is ignored on non-LLVM backends. -Z embed-source requires DWARFv5. Use -Z dwarf-version=5 to control the compiler's DWARF target version and -g to enable debug info generation.

September 26, 2025 at 7:31 AM

Lani

@laniakita.com

I mean this is just genius

Fig. 2 Inertial sensors. (a) Representation of an inertial measurement unit (IMU) depicting the sensing axes and the corresponding yaw, pitch, and roll rotations. (b) Exemplar accelerometer profiles of two hand gestures (hand rubbing and key locking) for three subjects showing the similar periodic nature of the hand movements. (c) Operating principle of an MEM accelerometer. When a force is detected due to a compressive or extensive movement, it is possible to determine the displacement x and acceleration since the mass and spring constants are known. (d) Representation of a simple gyroscope model. (e) The magnetic field generated by electric currents, magnetic materials, and the Earth’s magnetic force exerts a magnetic force detectable by a magnetometer sensor

Highlighted: A sustained sequence of related hand gestures composes a hand activity.

context:

Whole body activities differ from fine-grained human actions, usually undertaken by the hands (see Fig. ). These hand activities are often independent of whole-body activity, for instance, sending a text from your smartphone while walking. A sustained sequence of related hand gestures composes a hand activity. Hand gestures like waves, flicks, and snaps tend to have exaggerated motions (used for communications), and hand activities are more subtle, discontinuous, and of varying durations [12].

July 17, 2025 at 12:09 AM

Lani

@laniakita.com

Once glassmorphism wears out again, I propose we return to the real apex of UI design trends: Flat.

Screenshot of a iOS 7 home screen with its infamous, beautifully minimalist, flat design.

June 10, 2025 at 4:33 PM

Lani

@laniakita.com

Could we create a real cat facts bot today? 🤔 I do think we have the technology…

Ancient cat facts meme. Transcript for column one:

green: Thanks for signing up for Cat Facts! You now will receive fun daily facts about CATS! >o<

grey: What is this

green: Cats use their tails for balance and have nearly 30 individual bones in them! <To cancel Daily Cat Facts, reply 'cancel'>

green: Would you like to receive a Cat Fact every hour? <reply 'Tyxt33358dggyf'
to cancel>
Tyxt33358dggyf

grey: Cancel

green: Command not
recognized. You have a ‹year subscription to Cat Facts and will receive fun <hourly> updates!

green: In ancient Egypt killing a
cat was a cnme
punishable by death.
Thanks for choosing Cat

grey: Cancel
grey: Shut the hell up

June 4, 2025 at 6:33 PM

Lani

@laniakita.com

Breaking from my usual software dev posts for a moment, I have an art to share.

I drew this cute little tiger on an ipad in procreate a long while ago. It turns out i’m still pretty proud of it. :3

[INFO]: This will replace my goofy headshot for a while.

A portrait of a cute tiger, against a sunset background, holding a milk carton (ミルク inscribed near the tab) with its paws, and a piece of ahi sashimi in its mouth. “Lani” appears above the tiger’s right ear.

The milk carton has the transcript for a scam call message that became a meme when i made this.

Full text:

We've been trying to reach you concerning your vehicle's extended warranty. You should've received a notice in the mail about your car's extended warranty eligibility. Since we've not gotten response, we're giving you a final courtesy call before we close out your file. Press 2 to be removed and placed on our do-not-call list. To speak to someone about possibly extending or reinstating your vehicle's warranty, press 1 to speak with a warranty specialist.

April 17, 2025 at 5:18 AM

Lani

@laniakita.com

omg Meteor even has the OG docs just as I remember them!! just look at those ground breaking features!

v2-docs.meteor.com/v1.4/

Four bullet points from Meteor.js 1.4 docs:

• Meteor allows you to develop in one language, JavaScript, in all environments: application server, web browser, and mobile device.
• Meteor uses data on the wire, meaning the server sends data, not HTML, and the client renders it.
• Meteor embraces the ecosystem, bringing the best parts of the extremely active JavaScript community to you in a careful and considered way.
• Meteor provides full stack reactivity, allowing your Ul to seamlessly reflect the true state of the world with minimal
development effort.

April 5, 2025 at 1:03 PM

Lani

@laniakita.com

I have no strong feelings one way or the other.

A screenshot of my results from ismy.blue. This appears to show a Half-normal distribution posed upon a green-blue gradient.

The text says “Your boundary is at hue 174, just like the population median. You’re a true neutral.”

March 18, 2025 at 9:34 AM

Lani

@laniakita.com

youre-goddamn-right.gif

February 21, 2025 at 7:42 AM

Lani

@laniakita.com

well, this was an adventure.

Screenshot taken 12 minutes after fixing my production sst deploy command / build action, showing the recent production build action runs for my website.

The first failed run happened 4 hours ago, with the commit titled “fix: preview card width on widescreen displays”. followed by 3 more failing attempts of the same job.

The 5th failed run is titled “chore: bump turbo + node in action” that happened 4 hours ago.

The 6th failed run is titled “chore: update bun.lock” which happened 3 hours ago.

The 7th failed run is titled “refactor: pin sst version” which happened 3 hours ago.

The 8th failed run is titled “fix: bun lock” which happened 3 hours ago as well.

The 9th failed run is titled “fix: sst deploy turbo tasks” (this did work locally, but not in the CI for some reason), which ran 34 minutes ago.

The 10th failed run is titled “chore: sst deps”, happening 21 minutes ago.

The 11th run, was the first passing run, titled “refactor: simplify task dependencies” which ran 12 minutes ago.

February 21, 2025 at 6:42 AM

Lani

@laniakita.com

I am become test…er, presser of all the buttons!

Screenshot of the iOS Bluesky update (1.96.3) with super secret developer tooling included. This shows the “storybook” view, which features a whole lot of buttons (among other very fun features).

January 3, 2025 at 10:52 AM

Lani

@laniakita.com

So. Much. TypeScript. #GithubUnwrapped

December 31, 2024 at 5:58 PM

Lani

@laniakita.com

I solved the "Print Queue" - Day 5 - #AdventOfCode 2024 challenge in Rust after a lot of thought, some reading into graph theory, and then a realization I could do something a lot more clever (read: lazy) and just do a simple comparison to perform the validation adventofcode.com/2024/day/5

Source code for my solution to part 01 of the Day 05 challenge. In short, it takes the input.txt, splits it up, inserting the instruction pairs into a HashSet of strings (instruction_set), and pushing the updates to a vector of strings, which is promptly collected into a vector of vectors holding usize elements (print_updates). This is then returned as an object resembling the Prints struct.

Once that's assembled, in the part_01 function, another vector of vectors of usize (good_updates) is created to hold validated updates. A for loop is used to run through the prints.print_updates object to check if each update is actually valid, before pushing it into the good_updates vec.

The actual logic behind the validation is this: we can assemble something resembling an instruction pair from the ith and i+1th element in a iteration of the update line (test_ins_pair). We can also assemble the inverse of that pair too (test_fliiped_ins_pair). From there, we can check if the inverse (flipped) exists in the HashSet. If the inverse pair does, we know the current update is invalid, and we can return false. To handle edge cases (partial matching) we can just continue the loop if neither pairs exist in the HashSet. If the loop completes successfully without returning false, the is_valid_print function returns true.

From there, it's possible to find the middle index of each "good" update, and a function find_middle_page finds the middle digit through dividing the update length by 2, flooring it, and getting the page number by using it as an index. Then it just returns that page number, and a total for the sum of all good middle page numbers can be assembled. The total is then returned via stdout as mid_count, and part_01 is solved.

Source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_05/src/part_01.rs

Source code for Part 02 of the Day 05 challenge. Similar to part_01, except the part_02 function collects the invalid updates instead into a vector of vectors usize (bad_updates). Then a for loop runs through each bad update and tries to fix it using a recursive function called fix_update.

Fix update works like this: it creates a copy of the input update vec, then a for loop runs through the update. Vars curr and next cache the ith and i+1th elements of the update, and the instruction pair and inverse instruction pair are assembled. When it comes across the inverse pair in the update, it tries to fix it, through updating the ith element of new_update to the next (i+1) element, and vice versa. Once that's done, it checks if the newly created update is valid, if it isn't it calls fix_update again, except with the newly created new_update vec as its input. Once the update is finally valid, it returns it.

Once the bad_updates are fixed, then it's possible to find the "correct" middle page number of each update, calling the same function find_middle_page() from part 01, with the newly returned fixed update as input. It again returns the page number, and that's added to a mutable called mid_count, which collects the sum total of all the middle page numbers. Once the loop has completed, mid_count is returned via stdout to solve part_02 of the challenge.

Source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_05/src/part_02.rs

December 11, 2024 at 1:22 AM

Lani

@laniakita.com

This took me way too long, but I finally solved the "Ceres Search" Day 4 #AdventofCode 2024 puzzle (adventofcode.com/2024/day/4) in Rust. Welp, at least I learned something about Graph traversal.

Source code for the Day 04, part 01 solution. In short, it uses a recursive, DFS approach to find each "XMAS" string. From the input.txt, I constructed a 2D grid of vectors, each holding a vector of chars. Then I assembled the directions as a vector of i32 tuples. Then I looped through every row and every column, and then iterated within the directions vector. Then a function called check_word() runs the input uv through a function called valid_coord. If uv is valid, and the current index of the word, is the same char of the grid at uv, it runs the check_word() function again, this time with the index incremented by one, and with uv modified by the input directions. If the index reaches the length of the word "XMAS" (4 in this case), then the check_word() function returns true, and the mutable count variable, is incremented by one. Once it finishes looping through everything, the (total) count is finally returned via stdout. Source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_04/src/part_01.rs

Source code for the solution to Day 04, part 02. This approach is much simpler. From the assembled grid, it loops through once again, until it stumbles upon an 'A' char. From there, I created i32 vars that hold each diagonal direction (DL, UL, DR, UR), and test them via the valid_coord function from part_01. Then the left and right diagonal's of the cross can be constructed . If both those diagonals happen to resemble either "MAS" or "SAM", the cross can be counted, as count is incremented by one. The total count is then returned via stdout when the loop is done. Source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_04/src/part_02.rs

December 7, 2024 at 6:18 AM

Lani

@laniakita.com

Day 3 (Mull It Over) was, thankfully, much easier. Regex (and the Regex crate) really did most of the heavy lifting, so writing the logic to solve the puzzle was pretty straight forward. These are my solutions in Rust.

Rust code for part 01 of the solution to the Day 03 challenge. The mul_validator function takes the corrupted input.txt, and uses a regex to match valid mul(XY, ZA) occurances in the string. Capture groups made it easy to source the actual multipliers (m1, m2), which were unwrapped as strings and collected as a tuple within a map closure, within a vector of borrowed string slice pairs, in a immutable variable called instructions. With that, it became possible to iterate through instructions, deconstruct the tuple, parse the m1/m2 string slices as signed 32 bit intergers, and summed together. That sum was then added to a running total (a mutable variable called total_sum), which was promptly printed out to the console via stdout. Source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_03/src/part_01.rs

Rust code to solve part 02 of the Day 03 challenge. This time, a function aptly named mul_validator_complex takes the corrupted string input, and runs it through another regex (which matches for do(), don't(), or mul(XY, ZA)) which is the collected as a vector of borrowed string slices into an immutable variable called instructions. A simple is_enabled boolean flag is assumed to be true, and a for loop iterates through the collected instruction set. If the current iteration is looking at a borrowed string slice called "do()", it enables the is_enabled boolean flag. If it's "don't()" instead, it disables the boolean flag. Finally, if loop is looking at the mul(XY, ZA), and the is_enabled flag is true, then it uses the function from part 01 mul_validator to perform the multiplication. The returned sum then added to a running total sum in a mutable variable called total_sum_2. That total is then printed out to the console vs stdout to solve the puzzle. Source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_03/src/part_02.rs

December 4, 2024 at 5:36 AM

Lani

@laniakita.com

Day 2 (Red-Nosed Reports) was ... a bit of a challenge. Admittedly, I had to find some "inspiration" after getting way too stuck. Anyways, here's the end result of that in Rust.

Rust code to solve part 01 of the Day 02 challenge. In short, it takes the input.txt of reports and loops over it line by line (a single report). Then, that single string line is split, parsed as a signed int, then collected into a vector of signed 32 bit ints. Then a function which returns a bool determines if it's "safe" by checking if the current level and previous level in a report are within safe operating limits. Simultaenously, it's determined if the direction (increasing/decreasing/neutral) is safe. If it is, another +1 is added to a mutable int called safe_num. safe_num is then printed to stdout and the total number of safe reports can be revealed. source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_02/src/part_01.rs

Rust code to solve the second part of the puzzle. This again breaks the reports in input.txt into a single report as a iterable vector of signed 32 bit intergers. The difference is a function to determine if the report is safe using the dampener via is_safe_damp(). A brute force approach generates all possible "dampened" reports from a single report line. Then a for loop goes through those generated reports, and determines if this now "dampened" report is safe using the function from part 01 (is_safe_report()). If it is, the safety_flag is set to true, the loop immediately breaks, and the safe_flag can be returned. If it's not, it keeps iterating through the generated reports. Using the returned boolean from the safety_flag, it's then possible to add a tally to the total reports that are safe to a mutable int: safe_num_damp, which is promptly printed to stdout via the console. source code: https://github.com/laniakita/advent-of-code-solutions/blob/master/2024/day_02/src/part_02.rs

December 4, 2024 at 5:36 AM

Lani

@laniakita.com

I'm a day late, but I solved the "Historian Hysteria" - #AdventOfCode Day 1 challenge. So behold, my unoptimized solution, in not-so-idiomatic Rust (I'm still learning btw). adventofcode.com/2024/day/1