jado
LightNews LightNews
banner
jadon.io
jado
@jadon.io
73 followers 230 following 52 posts
https://jadon.io
https://github.com/phase
Posts Replies Media Videos
jadon.io
gandi did not autorenew **again**
December 29, 2024 at 6:11 PM
jadon.io
there's now a sidebar for image/polygon layers, and you can export them as GeoJSON
December 28, 2024 at 10:33 PM
jadon.io
here's one from iOS dev -> Rustaholic with a bunch of Julia sprinkled in?
December 19, 2024 at 5:38 AM
jadon.io
I love that with some people you can see large transitions like switching from JS to Rust
December 19, 2024 at 5:30 AM
jadon.io
@nikiv.dev has starred 50k projects... i am astonished this is real data...
December 19, 2024 at 5:28 AM
jadon.io
building a github star calendar & it looks pretty good! you can hover over each day to get links to what you starred.
December 19, 2024 at 5:24 AM
jadon.io
🌠
December 16, 2024 at 11:19 AM
jadon.io
a more useful example. the point placing is wonky because the leaflet plugins are not playing nicely together.
December 9, 2024 at 6:45 AM
jadon.io
i tried a dozen different tools to do this & all of them could do 10-80% of *that one thing i needed*

QGIS might do this but it's nonfunctional for me - zooming is broken and everything is incredibly slow. the amount of icons on top is frightening
December 9, 2024 at 5:53 AM
jadon.io
a map with images that you can draw polygons on
December 9, 2024 at 5:40 AM
jadon.io
took a detour into making a new crate for jvm bytecode parsing & emitting
#[cfg(test)] mod tests { use super::*; use reader::read_class::read_class; #[test] fn test_write_class() { let mut expected_class = ClassFile::new(ClassVersion::JDK_11, "example/Foo"); expected_class.add_interface("example/IFoo"); let mut buf = vec![0; 1024]; write_class(&expected_class, &mut buf); let actual_class = read_class(&mut buf).expect("failed to read class"); assert_eq!(expected_class, actual_class); } }
November 27, 2024 at 7:30 AM
jadon.io
switched to byteyarn + a global intern map. small enough strings are inlined while large strings are interned
/// A thread-safe interner that requires a 'static lifetime. pub struct StaticInternMap { map: RwLock<StringInternMap>, } impl StaticInternMap { pub fn new(capacity: usize) -> StaticInternMap { StaticInternMap { map: RwLock::new(StringInternMap::with_capacity(capacity)) } } /// Intern a string, returning a yarn. /// The yarn is always 128 bits long and may be an inlined string (where len < SSO_LEN) /// or a &'static str pointing into a buffer. /// Safety: &'static self is required because the allocated strings the Yarns may point to /// need to live for the lifetime of the program. pub fn intern(&'static self, name: &str) -> Yarn { if let Some(yarn) = Yarn::inlined(name) { return yarn; } // Safety: Yarn is assuming this 'static lifetime we pass it will never be dropped. // The 'static lifetime within the StringInternMap is only valid // for the life of the map instance, because the String buffers // being pointed to are *owned* by the map. unsafe { // grab read lock, get existing interned string that matches let map = self.map.read().expect("can't grab lock"); if let Some(ptr) = map.find_existing(name) { return Yarn::from_static(ptr); } drop(map); // not already interned, grab write lock let mut map = self.map.write().expect("can't grab lock"); let id = map.store(name); let ptr: &'static str = map.lookup_unchecked(id); return Yarn::from_static(ptr); } } } static STATIC_MAP: LazyLock<StaticInternMap> = LazyLock::new(|| StaticInternMap::new(1024)); pub fn intern(name: &str) -> Yarn { STATIC_MAP.intern(name) } #[cfg(test)] mod test_intern { use super::*; use std::ptr; /// 16 (u128) on 64-bit machines, 8 (u64) on 32-bit machines const SIZE_OF_YARN: usize = mem::size_of::<Yarn>(); #[test] fn test_inline() { let a = "aa".intern(); let b = "bb".intern(); // check values assert_eq!(a, "aa"); assert_eq!(b, "bb"); assert_eq!(a.as_str(), "aa"); assert_eq!(b.as_str(), "bb"); // check addresses let a_addr: usize = ptr::addr_of!(*a).addr(); let b_addr: usize = ptr::addr_of!(*b).addr(); // these yarns are inlined, so they don't have the same address // (& are stored sequentially on the stack) assert_eq!(a_addr + SIZE_OF_YARN, b_addr, "yarns are not inlined"); } #[test] fn test_intern() { let value = "getInstanceOfSomeClass()Ljava/lang/String;"; let a = value.intern(); let b = value.intern(); // check values assert_eq!(a, b); assert_eq!(a.as_str(), b.as_str()); // the string is in the cache let len = STATIC_MAP.map.read().expect("cant get lock").map.len(); assert!(len > 0); // check addresses let a_addr: usize = ptr::addr_of!(*a).addr(); let b_addr: usize = ptr::addr_of!(*b).addr(); // these yarns are interned, so they have the same address // (& is guarenteed to be 'static) assert_eq!(a_addr, b_addr, "yarns are not interned to the same allocation"); }
November 23, 2024 at 4:34 AM
jadon.io
i think im yoking correctly?
/// Like a Cow<'a, str> but you can plug in your own type. #[derive(Yokeable)] pub enum Ident<'a, O> { Owned(O), Borrowed(&'a str), } impl<'a, O: Clone + From<&'a str>> Ident<'a, O> { pub fn new(s: &'a str) -> Self { Ident::Borrowed(s) } pub fn as_owned(&self) -> O { match self { Ident::Owned(s) => s.clone(), Ident::Borrowed(s) => (*s).into(), } } /// Any lifetime 'b is fine here because we're always returning an owned ustr. pub fn mutate<'b>(&mut self, f: impl FnOnce(&mut O)) -> Ident<'b, O> { let mut owned = self.as_owned(); f(&mut owned); Ident::Owned(owned) } } /// C is our cart, could be an Arc<[u8]> or something. pub struct ID<C>(Yoke<Ident<'static, Ustr>, C>); impl<C> ID<C> { pub fn as_str(&self) -> &str { let ident = self.0.get(); match ident { Ident::Owned(s) => s.as_str(), Ident::Borrowed(s) => s, } } } pub struct ClassFile<C> { name: ID<C>, }
November 21, 2024 at 3:09 PM
jadon.io
one of my favorite fun facts about arizona. took a roadtrip from flagstaff due north years ago and every clock u have swings like a pendulum
map of arizona showing the navajo nation follows DST but the hopi reservation inside it doesn’t follow DST
November 20, 2024 at 4:46 PM
jadon.io
once I have a ClassFile struct I can use as a base module, I can plug it into the relevant traits. (module_llvm here is the basic module unit, previously an LLVMModuleRef before it was abstracted out)
impl WriteBackendMethods for JvmCodegen { type Module = ClassFile; type TargetMachine = (); type TargetMachineError = (); type ModuleBuffer = ModuleBuffer; type ThinData = (); type ThinBuffer = ThinBuffer; pub struct ModuleCodegen<M> { /// The name of the module. When the crate may be saved between /// compilations, incremental compilation requires that name be /// unique amongst **all** crates. Therefore, it should contain /// something unique to this crate (e.g., a module path) as well /// as the crate name and disambiguator. /// We currently generate these names via CodegenUnit::build_cgu_name(). pub name: String, pub module_llvm: M, pub kind: ModuleKind, }
November 20, 2024 at 7:41 AM
jadon.io
oooo I see I don't want to run `./y rustc <test>` just `./y test`
it runs successfully and passes all the tests
November 19, 2024 at 10:35 PM
jadon.io
neat that you can define these lang items in rust, not neat that this bespoke build system is failing to find this file. there are also two copies of basic_math.rs
#![feature(no_core, lang_items, rustc_attrs, intrinsics, decl_macro)] #![no_core] #![allow(internal_features)] #[lang = "sized"] pub trait Sized {} #[lang = "copy"] pub unsafe trait Copy {} unsafe impl Copy for bool {} unsafe impl Copy for u8 {} unsafe impl Copy for u16 {} unsafe impl Copy for u32 {} unsafe impl Copy for u64 {} unsafe impl Copy for usize {} unsafe impl Copy for i8 {} unsafe impl Copy for i16 {} unsafe impl Copy for i32 {} unsafe impl Copy for isize {} unsafe impl Copy for f32 {} unsafe impl Copy for f64 {} unsafe impl Copy for char {} unsafe impl<'a, T: ?Sized> Copy for &'a T {} unsafe impl<T: ?Sized> Copy for *const T {} unsafe impl<T: ?Sized> Copy for *mut T {} pub mod libc { #[link(name = "c")] extern "C" { pub fn puts(s: *const u8) -> i32; pub fn printf(format: *const i8, ...) -> i32; pub fn malloc(size: usize) -> *mut u8; pub fn free(ptr: *mut u8); pub fn memcpy(dst: *mut u8, src: *const u8, size: usize); pub fn memmove(dst: *mut u8, src: *const u8, size: usize); pub fn strncpy(dst: *mut u8, src: *const u8, size: usize); } } //@ aux-build:mini_core.rs #![feature(no_core)] #![no_core] #![no_main] extern crate mini_core; #[no_mangle] pub fn main() -> i32 { 0 } #[no_mangle] pub fn foo(x: u8, _y: u8) -> i64 { x as i64 }
November 19, 2024 at 10:27 PM
jadon.io
getting close to building this

github.com/rust-lang/ru...
screenshot of a terminal showing me running `./y rustc examples/basic_math.rs` in the rustc_codegen_c repo. it fails with error[E0463]: can't find crate for `mini_core` --> examples/basic_math.rs:7:1 | 7 | extern crate mini_core; | ^^^^^^^^^^^^^^^^^^^^^^^ can't find crate which is odd because the author of the PR I link is also running on macOS but doesn't seem to have this issue?
November 19, 2024 at 10:24 PM
jadon.io
TIL this is in the rust-lang org! looks like a good starter I can fork
screenshot of the rustc_codegen_c github page
November 19, 2024 at 6:51 PM
jadon.io
wow this api for zero copy deserialization is really satisfying. guaranteeing the reified lifetime in &'a Cow<'a, str> is valid is 🤌🤯🤑

github.com/unicode-org/...
screenshot of the 'Basic functionality' section of the linked yoke design doc.
November 19, 2024 at 1:07 AM
jadon.io
Earlier this year I used #Zig to modify the #Pokemon Firered decompilation. Some parts of the game like text need unique preprocessing that can be simply translated to comptime expressions.

Full writeup here: jadon.io/blog/zig-pok...
A screenshot from carbon.now.sh showing this code: pub export const testZigString = mapStr("Zig"); /// Map a string to the character set used by FireRed. /// This will also append a sentinel value. fn mapStr(comptime str: []const u8) [str.len + 1]c_char { comptime var buffer = [_]c_char{0xFF} ** (str.len + 1); for (str, 0..) |ch, i| { buffer[i] = mapChar(ch); } return buffer; } fn mapChar(ch: u8) u8 { return switch (ch) { '0' => 0xA1, '1' => 0xA2, '2' => 0xA3, '3' => 0xA4, '4' => 0xA5, '5' => 0xA6, '6' => 0xA7, '7' => 0xA8, ... 'ä' => 0xF4, 'ö' => 0xF5, 'ü' => 0xF6, '$' => 0xFF, else => ch, }; } An opening screen from Pokemon Firered with some text has been changed to the string "Zig".
November 18, 2024 at 1:05 AM