cynik_

Most recently, I've been building a small server for myself to track my day, todos, and just act as a frontend for some easy scripts (eg. just a direct line to running date to get timestamps). It's been a joy to use htmx and flask and just crank out features quickly.

I wrote about this a long time ago too: https://explog.in/notes/units.html. Units are critical, particularly when crossing language/engineer boundaries.

I took a stab at generating a visualization of all the solutions with one brute force based approach: https://twitter.com/kunalbhalla/status/1486189627644035078

Org Babel is the computational bit

you should always bias heavily for buy/download over build, That's a good point; I haven't spent much time thinking through this based on the work I've done so far (heavily leaning towards build over buy, with an existing complex internal tool ecosystem).

I think I might still push for build (or maintain the ability to heavily customize) for things that are particularly important for areas the company aims to have a strong advantage in/are business critical.

That was a really fun post to read: I really like the approach you're taking with abbot -- making it easy to write new tools quickly by only adding the business logic while having fun. Not needing to worry about UIs is also excellent, and I suspect one of the biggest time sinks otherwise.

This is cool, but I'd love to see a plot with all the axes (including color gradients) held constant across all charts so that they can be directly compared.

I installed arch linux on my personal macbook air (2012) and it's given a new lease of life to the laptop; and I enjoyed it enough to switch from a macbook to a Thinkpad at work as well. (I like more minimal UIs, so I ended up going with dwm/dmenu instead of dealing with Gnome).

I tried to do a 100 days of writing a few months into the pandemic for exactly the same reason (petered out around ~90 days in, but now I write without tracking religiously) -- https://explog.in/notes/100days.html. It was definitely worth it in terms of making writing easier, and also in helping me get better at thinking through writing.

Now trying to make it a permanent daily habit.

Alternatively, are there any specific resources / attorneys you recommend reaching out to for EB1 evaluations? [particularly in/around NY for my case, but I guess that's not very important anymore]

Yeah, I was thinking along those lines. A more readable version of this library that I sketched out might be something like --

An eagerly executing coroutine to consume the original generator and put it in a queue, and a new simple generator that yields values from the queue till it's told to stop.

I'm not sure if this matches the behavior of the original library for task cancellation though.

    def eager_gen(gen):
        end_marker = object()
    
        queue = asyncio.Queue()
    
        async def consumer():
            try:
                async for val in gen:
                    await queue.put(val)
            except Exception as e:
                await queue.put((end_marker, e))
            else:
                await queue.put((end_marker, None))
    
        async def new_gen():
            while True:
                item = await queue.get()
                if isinstance(item, tuple) and item[0] == end_marker:
                    break
                yield item
    
            if item[1]:
                raise item[1] from None
    
        _task = asyncio.create_task(consumer())
        return new_gen()

I wrote and open sourced something very similar recently: https://github.com/kunalb/panopticon. I don't think it's as sophisticated as function trace, but it generates chrome/catapult compatible traces instead and has some additions for async coroutines/generators.

Firefox's profiler looks pretty cool, I wish it could also accept catapult traces as is -- it doesn't seem to be the case. Now I know of:

- chrome://tracing - Firefox's profiler - Perfetto: https://ui.perfetto.dev/#!/ - Speedscope: https://www.speedscope.app/ - Brendan Gregg's flamegraph generator

to help visualize traces. Are there other good ones?

I started writing daily: exploring different things, but particularly asyncio and event loops. Also built a small library to visualize python code execution (to be open sourced soon).

https://explog.in/notes/100days.html#org0b7f5fd

I bought a Surface Go and found out Drawboard PDF to comfortably read large books and annotate them with the stylus.

I've been maintaining a list of books I've read over the past years at https://explog.in/books/list.html; some that come to mind –

1. Small Gods, Terry Pratchett (this might actually be more than 10 years ago, but I'll still list it)

I really like this one because it emphasizes the value of caring about the _core_ of anything instead of the _trappings_ that will spring up around it. Keeping this book in mind reminds me to focus on the thing instead of the appearance of the thing.

2. On Writing Well, William Zinsser

I'm a programmer, and I've often found that improving my ability to write clearly translates directly to programming well: On Writing Well is the best – and warmest – book I've read on writing nonfiction.

3. Incerto, NN Taleb

This series forced me to revisit several assumptions. Something that still resonates is valuing anything – particularly books – that has aged well across several years, because it's clearly valuable; and to discount the new shiny.

4. The Pragmatic Programmer, Andy Hunt & David Thomas

I started an open source project in my 3rd year at college – as part of Google Summer of Code; inevitably every release would break something and I started hungering for skills that would let me create new releases _without_ breaking the world every time. I stumbled across the pragmatic programmer in my 4th year, and immediately started applying it on my project. This carried through to work and helped me a lot early in my career.

5. The Art of Doing Science and Engineering, Richard Hamming

There are so many gems in this book: from the emphasis on fermi numbers for quick approximations, to a simple demonstration of the distance covered by a random walk as opposed to the distance covered by choosing a direction, to asking the question: "Am I working on the most important thing I could be? If not, why not?". He also predicted that great programmers will have one thing in common with great writers – clarity of thought.

There are some books I'm reading right now that I suspect will end up on this list: Psychology of Intelligence Analysis (available at https://www.cia.gov/library/center-for-the-study-of-intellig...) – for making better decisions with limited data; and The Power of Choice – to allow me to pay attention to the non-technical parts of doing valuable work.

I started in rust but switched over to C (just because I get to apply NIH and have fun writing out things I wouldn't have any reason to otherwise) – currently doing 15; will try to wrap up before the year ends.

This is my first time trying and I'm enjoying it a lot.

Been working there since :). I got a better/full answer after joining from one of the security engineers giving one of the starting training talks.

When I interviewed at Facebook as a new grad 7 years ago, I used my "Ask your interviewers a question" time to ask precisely this because I'd been trying to play around with the client side javascript and the constant infinite for loop always stood out to me.

This was my favourite quote from the mythical man month too: https://www.facebook.com/photo.php?fbid=10151890981137214&se...

This is pretty neat!

I didn't test it personally because flash / chrome but from the video I'd strongly recommend changing the selection animations / dialogs; at the cost of a bit more jarring UI I'd much rather have instantaneously available selections to choose so that I'm not bound by sliding windows, etc.

Probably a play on papyrus (http://en.wikipedia.org/wiki/Papyrus)

https://github.com/kunalb/PressTest - Unit testing framework for wordpress wrapping phpunit. It mocks out functions (by parsing the existing php files + plugin files you might have and generating stubs) unless you explicitly require them and makes it actually possible to write tests. Alpha a couple of years ago, not sure if it still works.

https://github.com/kunalb/PressTest/blob/master/screenshot-3... https://github.com/kunalb/PressTest/blob/master/screenshot-2... etc.

Deft in emacs synced over dropbox. I get notational velocity like UI for searching/manipulating notes, evil mode so I have vim key bindings and I can pull stuff up on my phone whenever required. It's also easy to just send a link to someone to share a file because it's all on Dropbox.

Pen and paper when I'm thinking through something.

I'd really recommend using `set -x` or `bash -x script` to sanity check all the commands and expected output.

See http://www.tldp.org/LDP/Bash-Beginners-Guide/html/sect_02_03...