If I’m writing code that isn’t clear, documentation can make it clearer. If I’m writing code that doesn’t work, tests can help me find how it should work. Tests, RFCs, and design docs can make it clearer and work better as well. This is one of the reasons I’m more than a little skeptical of people that claim code is self documenting, or clean code needs no documentation. You can re-write something to work the same way, but be cleaner, all while still increasing complexity. Or you could just document the first thing, and have it be cleaner, simpler, and above all, include of the non-functional information that goes with code.
I don’t know if everyone should learn how to code, but I think everyone should learn how to model something. And I think more people could learn how to do both not by taking some sort of course, or bootcamp, or whatever, but by doing code-like things in existing tools and software. Building filters for inboxes, embedding things in documents, or figuring out the regex-like features of search engines all seem like good places to start.
There’s something very satisfying about designing using bezels. It forces me to make distinctions about nesting components, and how they relate to one another. It also makes my components somehow feel more solid. I probably won’t end up shipping something that looks like this, but it’s a fun design game to play. I can always toggle it off.
GIFs will always be better than video or other formats for sharing screenshots because most platforms don’t compress them.
An idea for a spin-off of “Will It Blend?” but it’s for designing user interfaces, and it is called “Can I Click It?” We will review big corporate banking apps to see what is actually clickable.
What if there was a data analysis platform that just emails you a big spreadsheet once a day instead of offering a hugely complex UI that is impossible to build upon?
Watched the first episode of the new Foundation TV show, and I really liked it. Treating Asimov’s original series as a starting point, and not a strict text, gives the story some much-needed breathing room. Also, the more I think about how we interact with technology, the more I feel that some shows just get it right by not trying to explain everything too much. The scene with the lawyer and Gaal was particularly good – just turning on a device that casts some sort of privacy field is implied, it doesn’t need to be explained. So much of our current world is seemingly magic or inscrutable, that to create a full and complete sci-fi world is just an extension of that. Just imply what the device or technology does, rather than explaining it. If the narrative feels clunky, it’s because the “thing” doesn’t need to be there, or it doesn’t suite the story. The rest just sort of follows.
I was talking with a friend about open office plans, and they said that they wouldn’t mind an open office if they were simply allowed to do 40% less work. A loud conversation between coworkers is a good thing to get distracted by if you can simply do less work.
I’ve been using “Oblique Strategies” recently as a way to think through some of my ideas. It’s fun because I don’t know how to use them, so there’s more or less no wrong answers. Sometimes I think that tech companies might be better if instead of doing KPI stuff, they took like four cards from the stack and did those. What would Google Docs look like if they spent a month trying to figure out how “The tape is now the music” should be applied?
Having gone down the rabbit hole of “browser-server” code sharing, I think it’s only useful in a couple of cases. Most of the front end stuff I’m doing is pretty specific to the UI I’m building, so it’s really just sharing model definitions at most, which usually means just having serializable objects, and that’s easily enough handled with JSON. Writing models twice is so small compared to other tasks, that it’s not that difficult.
An underrated feature of SQLite is that it will use alternative strategies to execute your queries under memory constraints. Can’t allocate memory to complete the query? Great, it will try with the memory it does have.
ImageMagik is great, and it works well, but a cleaner way might be to use something like Skia (either directly or through Dart/Flutter) to render images, convert, them, etc. Something to look into.
If everything is a file, could we extend the usefulness of files by giving each one an accompanying
metadata file (eg:
my_data.csv.meta), and using a tool similar to git to track
the properties, allowing for comments, version control permissions, history, rules, and other info?
Not a day goes by that I think about the fact that the phone in my pocket is about as fast as my M1 MacBook, but I can’t run custom emulation software on it to use it as a desktop computer. Every sci-fi book ever has some concept of a “terminal” or “link”, and it serves as your phone/laptop, and here we are in the year 2022, but I can’t run what I want on my phone. Weird.
I’m so used to writing code in Goland that I try to select all and hit Cmd+Shift+L in other applications. I would love to have something like a code style for docs, or Figma, or other tools.
Messed around with Observable and Airtable yesterday and today. Airtable has made a lot of progress on their features. While their interface still looks like a Mario frozen yogurt shop, they’ve added features for building publicly accessible reports. This completes their database-like product, as it finally gives a way for the public to interact with it. While that’s interesting, it would be far more compelling if they offered it as a hosted OSS, backed by something like PG or SQLite. I could imagine it getting a lot of use and doing a lot of good as an open source thing.
Working on something that needs to allow runnable, sandboxed code on a users machine (eg: called from the application on a laptop). The obvious solution is some sort of cross-platform hypervisor that lets me run very a small linux distros inside a VM. But it’s hard to find anything like this that isn’t old, unmaintained, or just plain weird. This is one of the larger and technical advantages SaaS companies have had for decades now; everything is easier when you’re running it on your own servers.
Boggles my mind a bit that some popular programmers articulate their love for programming in terms of “making the customer happy.” Dude, you don’t need to frame things relative to how you get paid. It’s ok to say you like solving problems, or you like programming and a job well done. Expressing everything in a transactional way makes you sound like Robin Williams in Bicentennial Man; “One is glad to be of service.” You’re not in a job interview. Are you being held hostage? Like, blink twice if you’ve internalized your employers world view.
Declarative state for GUIs is a pipe-dream. An admirable one, but still. There’s no way around the fact that your program is in conversation with the native UI.
I’ve said it before, and I’ll say it again, 2D graphics programing (eg: GUIs) will be 100% better when we get a major, cross-platform WebGL/OpenGL/OpenGPU library that compiles to WASM. Shipping that to the browser will allow for optimizations that are way better than what we’re doing now with the DOM. Things like egui, glow, Flutter/Skia/CanvasKit are pointing in that direction, but we’re going to see cool things in the next couple of years on this front.
Jane Addams wrote that the “cure for the ills of Democracy is more Democracy”, a statement so true that it’s often borrowed if not literally, certainly in spirit, for a number of other ills. Is the cure for the ills of SaaS, more SaaS? The cure for the ills of software even more software? Some days it seems that Silicon Valley certainly thinks so. There’s dozens of SaaS companies selling group discounts for bundles of other SaaS products, or tools to organize your existing subscriptions, or turn-key solutions to start a SaaS company – with, yes, you guessed it, more SaaS!
The post https://blog.ploeh.dk/2019/11/04/the-80-24-rule/ seems pretty on point, but I think you can reach the same results by working backwards from “what’s the best way to express the purpose of this function?” or “what are the cleanest units to document what we’re doing here?” or even just a gut-level “is this readable?”
I don’t think we’ve reached the end of new and wild programming languages. But I do think any new language needs to have its own accompanying GUI library, and visual editor in order to debug and inspect changes to the codebase. Visualizing flow, memory management, concurrency, and memory access could make a language infinitely better.
Stumbled across https://tauri.studio where the creator does a literal fire-side chat about why he built Tauri. This is the stuff I love about nerds. Get weird, get corny, put on a hat and velvet smoking jacket and film yourself by a fire talking about code. Love it.
There are very few genuinely innovative things happening in desktop computing UI design. Which leads to the question: what have UX/UI designers for desktop applications been doing?
The SQLite session extension really is remarkable. With very little overhead you can just grab all changes to a set of tables, and write it to a file. It’s so easy to reason about, and extend, and use with your existing tooling. Just open connection, start session, end your transaction, stream the change-set out to a file, or save it to S3 or wherever, and you’ve got bidirectional versioning for your entire database.
cargo for building rust stuff seems like it’s a kitchen-sink solution to building stuff.
Cargo.toml you think, man there’s just too much here. But then you remember that the
alternative is passing in a million flags like with GCC, and you think, you know, I’d rather have it
written down somewhere rather than just floating around in a Makefile or bash script.
People talk about web-apps being really fully featured, and that you can do anything in HTML/JS/CSS, but I think that we’re at a brief plateau on our way back to native apps. Writing Rust that compiles to WASM, and has only very light bindings connecting mouse/keyboard in, and OpenGL out, and that seems pretty solid. Once WASI is solidified, and we have a good ABI for WASM, and WebGPU Dawn lands, anything that uses HTML will seem like a joke.
I once read a short story by Isaac Asimov (I think) about a substance that had a mass so high that you couldn’t get enough men around even the smallest piece of it in order to lift it. I think some people believe the inverse of this about software: that the more people you have working on a codebase the more you can get done. Just gather the men and have them lift the small chunk. I don’t think that’s true. Sometimes I think you need the smallest number of people possible who know how to lift things, and give them the time to figure it out.
To the tune of LCD Soundsystem’s “Get Innocuous!": “Get delusional!"
When I leave the vicinity of my Mac, and the screensaver is on, the display freezes. So if I go to bed with it on, instead of saving the screen, it burns the screensaver into my display for hours. That’s the biggest tech company on Earth baby! Good stuff.
You would think that with higher DPI screens we would have moved to a different unit system for design. But we’re still doing 1px or 2px borders on things, because the resolution gets messed up on older screens if you do anything different. Seems very strange to me that there’s a difference in 100% (or 50% depending on how you think about it) between the borders that we can do on application designs.
Orange site people love to go off about how code reviews are terrible, and it’s like, damn, that seems kinda like a symptom of having bad coworkers than anything else. Code reviews are for 1: catching bugs, 2: sharing knowledge, 3: forcing yourself to put the best of other people inside your brain. If you’re complaining about code reviews you’re missing more than one of these.
Big fan of huge files when programming. Putting an entire library inside a single 2100 line
file, and the tests in a 5000 line
lib_test.go is terrific. I don’t have to flick back and forth
between files, and it somehow feels more complete because I don’t have to worry about what units the
library should be split into; it is one unit, the Big Ol' File.
I think I’ve made this point before, but any significantly large code base has so much detail in it, and customization that the complexity outweighs whatever language it was written in, and interacting with it is less like writing code and more like understanding a gigantic machine; you tune this here, flip this switch there, but you don’t stop it or rebuild any significant part of it all at once.
Drawing triangles always blows my mind. Just literally drawing. Telling the painter to go from “this
point to that point to the next point”, or doing stuff with
quadraticBezierTo. Just plain cool.
I’m not super into the idea of GitHub’s copilot, but I would love for something as simple as a good
autocomplete that uses realistic heuristics. For example, when I’m working with a Dart class
Fields, and I type
Fei, you know, Goland should be able to guess that I am not
dart:svg, a variable and package I have used once, and
Protobufs seem like a good idea until you start using them near core-computational tasks. Then it changes. Every time you touch a field, it’s using an array index lookup, which is fast, but not as fast as a straight reference. In Dart using a plain apples-to-apples comparison, I’m seeing a 15% slowdown. Oof. So, if you are, for example, writing a document-like structure and using protobufs as the elements in the document, every lookup is slower. Now, again, performance is relative, so if you’re spending 110ms on something, and only 10ms of that computation is using protobufs, you’re loosing a 1ms, so who cares. But if you’re spending 100ms in protobuf-land, then you’re loosing 15ms.
Protobufs are a good start, but I straight up don’t get why a lot of languages haven’t moved beyond simple type constraints. Checking string length, clamping integers, floats, doubles, and more seems like something we should be able to define somewhere, I don’t know, better? Putting that inside protobufs seems like a start to me.
Whenever I feel weird about throwing errors or about thread-local I try to remember that they are
different sides to the same coin: a way of saying “boy I sure hope you know what you’re doing.” Sure
hope I remember to wrap it with a
try/catch or I remember to set the provider/static/whatever on
the thread context. If GOTO is considered harmful because it jumps around the program with
consequences that are hard to track, error recovery as to at least be considered neutral-evil. What
are the other alignments on this one?
Writing tests can be a virtuous cycle or a negative cycle. If your code is at least pretty good, you write tests easily and find bugs, fixing them as you go. It makes you want to write more tests. If your code is bad, tests are hard, and you find a ton of bugs, and they’re difficult to fix. It makes you want to write tests less, and, on some days, makes you want to write less code altogether. Occasionally it makes you want to throw you computer into the ocean.
I get why dart’s
_underscore private notation exists, but it seems like a
“please to not steal” sign. In repositories published to pub.dev I see the pattern of something
Object get thing => _otherThing; all the time, and then the
_otherThing is being accessed
outside the class, and could be mutated. Like, the underscore is effectively “please please please
don’t touch this”, and then you don’t even see it because all you see is a publicly accessible
GitHub bots that auto-close issues that are inactive for N days are the worst thing about GitHub. Honestly, who benefits from that? No one. It’s not like we need to save bytes or anything. It costs nothing just to keep it open. It’s not a bad thing. Open source projects have issues, and having a lot of them means your project is being used, not that it’s bad. It just kills me when I find an issue I’m having, go to report the bug, and find that several people have tried, but they keep getting closed because no one comments on them. It might have been solved by now if we loose the tree-falls-in-forest mentality to GitHub issues. Let it sit! Let it stew! We can all gather in the comment section on the 2, 3, or 5-year anniversary of the issue, and celebrate that we still care about it, and want it fixed.
Oof. In Dart, if your Iterable
map call returns
void, it just straight up won’t get compiled.
Listen, I’m writing code in a language based on C and Java. It’s not that I
want to throw an exception, it’s just that there’s no way to do multiple return types without
introducing a new class, or weird
["ok", "err"] ....  as Ok ...  as Err nonsense. So here I
am, shoveling poo over a fence, into a land in which I will soon live.
I’ve always thought that functional programming is fine, but object-oriented programming is where it’s at, because you can always do FP in OOP. But I’m not so sure anymore. Scope is difficult to capture as objects and classes, and it’s near impossibly to do FP in OOP without it. And at that point you’re writing objects and classes anyway, so you’re really taking what should be ephemeral state and codifying it as structure; in a weird way the only way to do FP in OOP is to do… even more OOP.
Dart is great, but I really want Rust’s mutability guarantees. I can’t guarantee I won’t mess something up by mutating an interior object.
Dart isn’t a very popular language, so it doesn’t show up much in Google results, like when I’m searching for “Dart implement IterableMixin” or something. But someone took the dart site https://dartlang.org, and created https://fartlang.org. Whenever I search for Dart stuff, if there are no results, there it is; FartLang.org. A hilarious canary in the coal mine, shrieking and cackling that no one uses Dart. An SEO case study for sure.
People rag on different programming languages all the time for being bad or whatever, but when you really put your mind to it, you can do bad engineering in any language. Shoot for the stars, or the toilet. The choice is yours.
All things considered, I’m all on board with Flutter. It’s a ridiculously solid way to write something that runs everywhere. Platform-specific stuff can be injected at build time, and you can do whatever you’d like outside of Dart with the bridging capabilities.
Flutter is cool - but there is a certain irony in having their profiler tell me the performance of my application is slow when the profiler itself takes 3 seconds to respond to my clicks.
With Flutter + Dart, I’m getting 11ms renders on a production build, 33ms when we do a 4x CPU slowdown. With plain JS+React I’m seeing numbers of about 11ms renders on a production build, and 34ms with a 4x CPU slow down. I’ll publish this if I get a chance later - but those numbers look pretty interesting. Flutter is about as fast as React is if you know what you’re doing.
The web is amazing. The best thing JS/HTML/CSS has done for developers has been to introduce the idea of the UI as being entirely separate from the rest of the app. once you start to think about that, writing a GUI in Flutter/Dart makes a lot more sense. Dart is a language for nothing but UI development. A lot of developers still look at GUIs as the last thing you do; you get your data model, and work your way back to front, ending with a UI that you slap on the front. that’s the opposite of how it should be. there’s so much that goes into thinking through how something gets used by a real person that you should start there, and work your way backwards.
Flutter is really solid, and I’m not sure if there’s much of anything preventing someone from using it to draw graphics on the backend, and stream them to the client. If you can get under 16ms round trip, you can get native speeds too.
Finishing up one week of using Flutter. Really solid. As long as you don’t touch anything platform-specific, it’s really good. And when you are writing platform specific code, you’re probably in deep water anyway, so a framework was never going to save you. I really like Dart. I can imagine setting up some sort of template that lets me build interactive models and shipping them by compiling to web-only. Neat stuff.
In Unix “everything is a file.” Which I like. But I think we could have done a lot more with " everything is an element”. If everything was an element in a sort of DOM-like structure, and each element has attributes and elements. You can achieve this with modern file systems, but can you imagine if it was the default? Tree structures everywhere. Projects that conform to " application-types” where elements are required or default-able. You could also have rules associated with what element parent-child relationships are allowed. Then you can allow for other applications to extend your application’s project, and vice versa. What a world.
Going back to the browser standards thing: once we have well-defined APIs for doing network access, FS access, camera access, GPU access and so on, we can absorb these into the OS. ChromeOS is already doing that, but there’s no reason to think the other browsers (each of which is controlled by a company that ships a major OS) can implement and absorb them. Then writing apps means interacting with these APIs rather than using OS C-headers, or raw sys calls.
Love it when business dudes say that they’re “a bit of a jack of all trades” because the full quote is “jack of all trades, master of none.” Like, imagine if every business idiot knew only one latin phrase, and it translated to “my brain is full of worms.” Love it.
I think once all browser ship versions of WebGPU, and a FileSystemAPI we’ll finally have browser apps that can act like native ones. More interestingly, I think we’ll see those APIs proliferate in native GUIs. Like, great, you can pick and choose these APIs as features when building a native app, so you can write an app in a collection of languages that all run anywhere, browser or not. The FS API will force Apple’s & Microsoft’s hand to solidify their permission-system to be clearer and easier to understand. And native apps will get better for it.
Why do people screenshot their code in blog posts? Who asked for that? Why would you do that? Why would you just screenshot that when you can just copy and paste, which is 1000X easier. On Twitter I get it - you want to show your work, and posting a link to a Gist to weird, so you post a screenshot. But on a Medium post?! Or on a blog you control?! Bonkers. Absolute madness. Get out of here with that nonsense.
Thinking about this licensing issue again. There are 8-10 semi-viable options for building a cross-platform app including Flutter, Mono, Cairo, GTK, QT, Electron, CEF. None are very good because either they’re incomplete in some dimension (weird language, poor documentation, licenses, too heavy, and so on.) Kinda wild that at the moment VC money is flowing like water and there aren’t any startups that are like, we’re going to build a slick UI thing that runs anywhere and skim 1% off every startups' revenue in the next decade. But on the other hand it makes sense. VCs would rather hear that you have a 1% shot at owning 100% of a market instead of 100% of 1% of the market, because if you own 100% of the market, you can make the market bigger just by raising prices.
It seems like there’s a lot of room for innovation in licensing when it comes to OSS. Unreal/Unity do something like $0 until you make $X, then it’s $Y. I think more OSS companies could do something like; free for open-source, free until you make $100k, logarithmically approaching 1% of revenue up to $10M, then free again. Not that billion-dollar companies should get it for free, but that most companies think they can get there. So the price becomes a sort of John-Steinbeck pass-through-tax, in that as Americans think they’re temporarily embarrassed millions, entrepreneurs think they’re temporary small-business owners on their way to greatness.
Every big tech company documentation site is built very strangely. An overwhelming amount of interesting text formatting, notices, wells, call-outs, bold, italics, monospaced text, collapsible menus on the left and right. Just an astounding amount of information that doesn’t relate to the core topic of the page. Just unfathomable nonsense written by people with serious cases of paint-by-numbers-brain.
No-code and lo-code tools love to be flow based. Even when most people think in terms of reactivity,
not flows. Everyone learns math in left-to-right eval, producing numbers, and setting variables.
2*3+a = 10 and
a = 4 makes more sense, even if you could model it as
a => 4
2*3+a => 10. Turns out Excel did get at least some things right.
Looking back on all the microservice nonsense that’s settled down a bit - seems like a huge part of it was, and still is, the idea that code is disposable; it’s something temporary to be used until our model of the world changes. I understand it, but I don’t agree with it. If you act like you’re building something that will be around for a while it probably will. it becomes a self-fulfilling prophecy of garbage code. You end up with people relying on patterns too much - worry about project structure, or code re-use, or refactoring. Because, well, if I’m writing this garbage over and over again, I should be able to do it faster next time. But we should aim to write software that has fewer next-times, less need for the perfect project structure. Look at any wildly successful project, and you’ll find a structure that is pretty specific to the domain and people. Skia, chromium, blender, sqlite. They’re all weird. and they work. It takes time to get started, but they’re projects that are anything but disposable.
Orange site people love to throw up xkcd #927 whenever someone remotely tries to improve something - standard or not. Like, if Louis Pasteur suggested germ theory on HN, they’d be like “oh great, #927, yet another theory about disease 🙄.” Or the wright brothers. They’d be like, “why bother? da vinci didn’t get it right.” Just a pseudo-intellectual way to cast doubt on something without remotely considering the idea on its own merits. As if you shouldn’t bother trying to fix something because the previous fixes didn’t work. As if UCB-C hasn’t caught on.
There are about a dozen Skia-based GUI projects on github. each one basically trying to get a cross-platform gui library working. Almost all of them were abandoned while heading in the direction of a chromium-like system, sans-v8. Would love it if any of them were close to functional. Or if any of them had a remotely functional component-tracking system so binding your own clicks is easier.
I’ve said it before, and I’ll say it again, I want a regular, modern IDE that knows less about my project, and more about the syntax. Just a dumb IDE that I can point to directories, and write code autocomplete that is very stupid, and narrow. Goland regularly tries to autocomplete from, like, C-lang headers and stuff when I want to fuzz-complete a css class name. absolute madness.
If an OS finally figured out how to do permissions based capabilities properly - like iOS/macOS but better, I think a lot of the other usability constraints and UI stuff would fall in line. We could finally ship cross-platform apps that look good and actually work.
Skia - the drawing engine that backs Chromium - is really good. It has a variety of bindings for GLs, and it’s very fast. Makes me think that there could be something there for a GUI library. Just a bunch of components that all call to Skia, and render to a window. Could be a solid alternative to Electron. Ship the Skia bindings in a variety of languages, so you can use whatever language you want for the main proc too, and ditch JS entirely. You’d still need an event system, but how hard could that be? :)
The desire to have a project + IDE that autocompletes everything has led us to a weird place. npm pulls in a thousand things, you tell your IDE to ignore this or that, and what does it get us? a slower IDE that doesn’t even give you good autocomplete suggestions. I’d love to have an IDE that has good fuzzing, but doesn’t try to complete anything. I’ll ask for a name, and it gives it to me, then we put it in. That’s it.
I would absolutely love a Rust async runtime that can run anywhere, because then we finally might be able to write apps entirely in Rust, and have them run in browsers as well as standard OSs. An async runtime + raw-drawing library would be even better.
Making TODO-list apps as the intro to a new UI framework is dumb. show me a full-fledged file-menu with keyboard nav, skip-ability, disabled, and hotkeys. Then I’ll be convinced that your svelte/solid.js/vue thing actually works.
Similarly, I think we need better words for the shape of code. Deep, shallow, flat, normalized, christmas-tree, and so on are a good start, but we need more. If we can come up with colors like sea-foam green and burnt umber we should be able to say that a library is mountainous, or celestial and have people be like “yeah, get that.”
I would pay a lot of money for a 500-page book on how someone organized their JS codebase for a large sized project. So much blog-spam describing the best way to organize redux actions or whatever that sounds good, but would collapse under the weight of an actual project. It would make me impossibly happy to see deep descriptions about why something is structured like it is, and what the alternatives were. Something like an operating room theatre, except instead of a doctor being like " check this out" it’s someone who is like “I know this looks bonkers, but here is a 5000-line JS file of code gen for our redux actions, and it exists because…”
An interesting read: https://github.com/facebook/react/issues/11171. It’d be neat to be able to use RAF with react, but the crux of the issue seems to be that you’re in conflict with a bunch of native browser interactions like scrolling and input registration, which makes it tough.
Don’t want to be too cynical, but I think 90% of UI/UX design is just making sure the users know what is clickable and what the click will actually do.
Being on “design twitter” is all about seeing people say stuff like “big things on the way!” and then they show a screenshot for a corporate banking app that looks impossible to use. good work everyone.
Seems like a lot of the little warnings or context hints inside my IDE are rarely useful. they’re things that should be in an auditing tool. you run the audit tool every once in a while to see if you’re using anything deprecated. yet another part of the development experience that doesn’t need to exist - another absolutist “we keep a clean code base” thing that creeps into the experience of writing code, making it a little worse.
Wrote a ton of Rust over the last year, and now I’m writing a ton of JS/TS. the change is jarring. going from something that cares about types so much to something that not only lets you treat anything as anything, but does so in ways that cause all sorts of performance issues is weird.
I remember people being surprised that SpaceX was using Chromium for rendering the UI on screens in their shuttle(s), but it doesn’t seem wild. Anything that needs to be run in realtime (ie, flight controllers) has its own hardware, so rendering non- and semi-critical systems in Chromium doesn’t sound terrifically hard.
If you built an ideal cross-platform GUI, you’d want something that can emulate native styles, but not too specifically, or you’d end up with incompatibilities. You’d also want something simple, and performant, with good input (keyboard, mouse, idk, midi?) support. You’d basically end up with a browser, and not necessarily chromium. Could easily be a wrapper, like Edge for Windows, WebKit for macOS, and Chrome for Linux.
When I wake up my Mac, and it’s connected to my monitor there’s a 50/50 chance of it working. Really weird odds from the biggest computer maker in the world. Top-notch work Apple.
Wild that we had notifications basically figured out with Windows 95. Taskbar buttons turned blue to notify the user of a pending message. seems better than the system we have now. Managing notifications through the system’s menu seems weird - more intuitive to just have the app idling if I want it tell me anything than telling the entire system what it can and can’t do.
Reworking my Makefile. Turns out having sources and targets as literal things is great because it forces me to actually build things, instead of having a bunch of abstract targets. If I’m building a binary, or a bunch of files, then we know exactly what we need to do it. Targets all the way down! Cool!
The phrase “hundreds if not thousands” really bothers me. Hundreds could be around a thousand, and thousands could at least be 2000, the difference being 200%. Or hundreds could be 200 and thousands could be 5000, a difference of 2500%. You get the idea. So which one is it? Someone on twitter insisted that they “interviewed hundreds if not thousands of developers.” Is it hundreds or is it thousands? You’d think they’d remember it if it was thousands. Seems like disingenuous way to say " about a thousand."
It kills me when I’m using Safari, and it tells me that “the page is using a significant amount of memory, and your computer may be more responsive if you close the page.” You gotta be kidding me! My computer would be so efficient if I didn’t use it at all, just letting it idle, but that’s not what computers are for! “Your chances of sinking will go down if you put your boat safely up on dry land.” Duh!
The idea of “best practices” in software development is dumb. Like, “if all your friends are jumping off a bridge” logic. Everyone is using Git-ops flow?! It must be good. A generous interpretation of best practices nonsense is that 50% of people are below average. A less generous interpretation is that good and bad, best and worst, are all relative to what you’re trying to build, and how you think of the nature of work. Work the way that makes sense to you, learn from others, but don’t do cargo cult stuff.
Would love to see an anonymous dump of private Makefiles. It’s so flexible and versatile, and is the truest record/document of how you think about building something.
Interesting idea: create something like a schema for a file-system, and use that as a db + programming environment as an alternative to spreadsheets or python notebooks. Allows for extension and tooling without being overly prescriptive.
Makefiles are so good. They just make so much sense - everything is a source, target, or prerequisite, and it’s just checking timestamps. Helps avoid the complexity of other build systems by treating things as what they are physically (files + dirs) instead of conceptually (apps, services, etc.).
The OT + CRDT debate often seems to miss the point that they’re compatible. You use OT for text, and CRDT for atomic fields on your document, which, by the way, is not the storage mechanism. It’s more like shared memory than anything else. You listen to it on the server to write to the db.
https://makefiletutorial.com is good, and well written.
While I’m at it; it’s funny that Rust’s goal is to make guarantees about safety, but when it comes to compilation it’s like the wild west. who knows what flags you gotta flip to get a static binary. Where’s the rust for compilers? Something like Nix + rustc + cargo + musl that is genuinely reproducible, and doesn’t break once a week.
Building rust target x86_64-unknown-linux-musl is a real chore; not for the faint of heart.
The quarterly issue of ‘Excel Pile-On Magazine’ is busy being printed over at HN: https://news.ycombinator.com/item?id=28595155
GitHub has made it easy to launch an OSS project, but it’s never been easier to not maintain it. If devs had to set up their own site, domain, DNS, and git server to launch a project would we be better off? We might. Maybe fewer projects, but they might be of better quality because a couple of hours worth of work weeds out engineers that are bad at writing code, or are resume stuffing.
I’d like to see all UIs base their screen and units off of a standard text size. from a user’s perspective. Wtf is a pixel? Who knows. But a character? I know how big that is or should be. after all, we’re reading on screens all day. A window bar? 2em. Close/hide/max icons in bar, 1em. etc.
Bonkers that NSO group is churning out zero days for iOS, and Apple, with like $200B in cash and securities can’t be bothered to hire a couple of researchers to find and fix the exploits first. They probably already do, but, I don’t know, maybe hire a couple more? Again, $200B in cash is a lot.
Been using iTerm2 for a long time now, and I love it. I’d love some sort of fusion terminal-IDE-browser app. iTerm’s tiling, an embeddable browser, and simple ways to render project files and open tabs. Something like that. You can get there with Emacs, but it’s a bear to put together.
Jumping in and out of yaml, bash, and whatever you’re writing GitHub actions in is dumb. Why can’t we just have a better shell that does this for you? The yaml part really just gives you named steps that github can parse into a nice UI, but there’s no reason they could not do that with the AST of an actually single language.
Wish there was an alternative to Grafana. Unless you know what you’re looking for, exploratory-metrics-finding is hard. It’d be nice to be able to explore a graph, having it serialize back out to a set of promql queries, with labels etc.
Rust’s async/await feels like the wrong way to do threaded programming. Too many gotchas around context, state, and lifetimes. It gets easier, and I’ve found some patterns I like, but I think that they should have allowed for pluggable lifetime checkers like with the mem allocation, instead of making each block its own lifetime.
GitHub actions seems okay, but it really bums me out to have to debug anything by editing yaml, pushing my code out, and watching the logs through a browser. Are there easier ways, yes, but they involve more time to get that easy-ness, so here we are, debugging bash through yaml strings.
“You best start believing in societies, ms turner. You’re in
There’s never been more software, and I think we’re not better for it. It’s always been turtles all the way down, but when they’re stacked precariously you start to wonder if we could replace some of those turtles with better, more stable turtles. Anyway, I’ve been debugging github actions lately.