http://github.com/xeoncross http://davidpennington.me
- One of the things I wish more people talked about isn't just the language or the syntax, but the ecosystem. Programming isn't just typing, it's dealing with dependencies and trying to wire everything up so you can have tests, benchmarks, code-generation and build scripts all working together well.
When I use modern languages like Go or Rust I don't have to deal with all the stuff added to other languages over the past 20 years like unicode, unit testing, linting, or concurrency.
I use Go where the team knows Java, Ruby or TypeScript but needs performance with low memory overhead. All the normal stuff is right there in the stdlib like JSON parsing, ECC / RSA encryption, or Image generation. You can write a working REST API with zero dependencies. Not to mention so far all Go programs I've ever seen still compile fine unlike those Python or Ruby projects where everything is broken because it's been 8mo.
However, I'd pick Rust when the team isn't scared of learning to program for real.
- Restrict data collection? It would kill all startups and firmly entrance a terrible provider monopoly who can comply.
Have the government own data collection? Yeah, I don't even know where to start with all the problems this would cause.
Ignore it and let companies keep abusing customers? Nope.
Stop letting class-action lawsuits slap the company's wrists and then give $0.16 payouts to everyone?
What exactly do we do without killing innovation, building moats around incumbents, giving all the power to politicians who will just do what the lobbyists ask (statistically), or accepting things as is?
- 1) for one-off scripts and 2) If you ignore memory.
You can make about anything faster if you provide more memory to store data in more optimized formats. That doesn't make them faster.
Part of the problem is that Java in the real world requires an unreasonable number of classes and 3rd party libraries. Even for basic stuff like JSON marshaling. The Java stdlib is just not very useful.
Between these two points, all my production Java systems easily use 8x more memory and still barely match the performance of my Go systems.
- I agree with a lot of what you said. I'm hoping Rust will warm on me as I improve in it. I hate nil/null.
> Go... extremely exhausting boilerplate error checking
This actually isn't correct. That's because Go is the only language that makes you think about errors at every step. If you just ignored them and passed them up like exceptions or maybe you're basically just exchanging handling errors for assuming the whole thing pass/fail.
If you you write actual error checking like Go in Rust (or Java, or any other language) then Go is often less noisy.
It's just two very different approaches to error handling that the dev community is split on. Here's a pretty good explanation from a rust dev: https://www.youtube.com/watch?v=YZhwOWvoR3I
- Yes, for me I've always pushed the limits of what kinds of memory and cpu usage I can get out of languages. NLP, text conversion, video encoding, image rendering, etc...
Rust beats Go in performance.. but nothing like how far behind Java, C#, or scripting languages (python, ruby, typescript, etc..) are from all the work I've done with them. I get most of the performance of Rust with very little effort a fully contained stdlib/test suite/package manger/formatter/etc.. with Go.
- I know they say that your programming language isn't the bottleneck, but I remember sitting there being frustrated as a young dev that I couldn't parse faster in the languages I was using when I learned about Go.
It took a few more years before I actually got around to learning it and I have to say I've never picked up a language so quickly. (Which makes sense, it's got the smallest language spec of any of them)
I'm sure there are plenty of reasons this is wrong, but it feels like Go gets me 80% of the way to Rust with 20% of the effort.
- What is the alternative though? In strongly typed languages like Go, Rust, etc.. you must define the contract. So you either focus on what you need, or you just make a kitchen-sink interface.
I don't even want to think about the global or runtime rewriting that is possible (common) in Java and JavaScript as a reasonable solution to this DI problem.
- I really liked the README, that was a good use of AI.
If you're interested in the idea of writing a database, I recommend you checkout https://github.com/thomasjungblut/go-sstables which includes sstables, a skiplist, a recordio format and other database building blocks like a write-ahead log.
Also https://github.com/BurntSushi/fst which has a great Blog post explaining it's compression (and been ported to Go) which is really helpful for autocomplete/typeahead when recommending searches to users or doing spelling correction for search inputs.
- I'm sure there are a lot of people like me that question if keeping bookmarks is actually worth it anymore. I personally found that taking action and writing a blurb about neat things I find helps me remember it more even if I never use the bookmark/paste/share directly again.
The more mental effort put towards something, the easier it is to remember.
- This is the difference between a good idea and the implementation.
People just act differently in "official" topic channels.
It's like when you buy that super secure door lock and the lowest bid handyman bends it while installing because it's such a pain to align correctly and now it's just as vulnerable as any other lock.
- Perhaps my last sarcastic line was a bit obtuse. Technology is certainly making it easier to enact control and with a tighter feedback loop.
Rabbit trail, it's interesting how the modern western evil is now branded as "fascist control" as opposed to the other forms common throughout history. I wonder if it's related to calling everyone "toxic". It seems culture is moving towards more vague definitions of evil/wrong instead of pin-pointing the actual faults. Perhaps this is an important part of "newspeak" that we're suffering from.
- > draconian oversight and censorship
This is just human nature. Any place where humans live in close proximity for hundreds of years suffers the same fate until a revolution or power restructure resets the counter through the removal of the previous structures vestiges.
Thanks to technology, it just keeps getting easier. Less time to put restrictive measures in place and a tighter feedback loop. Oh joy.
- I'm so glad to be out of the dark ages of parallelism. Complaining about Go's race detector or exactly which types of logical races Rust can't prevent is such a breath of fresh air compared to all those other single-core languages we're paid to write with that had threading, async, or concurrency bolted-on as an afterthought.
I can only hope Go and Rust continue to improve until the next language generation comes along to surpass them. I honestly can't wait, things improved so much already.
- Would be really interesting if microservices were limited to a manageable amount of code. I wonder if technical leadership has ever guided their org devs that services shouldn't be more than ___ lines of code (excluding tests). Obviously, more services would mean more latency, but I'm pretty sure this one I'm working on now that is over 11k LOC (ignoring comments) could be replicated with a few bash commands.
- I want to turn on audio or video recording in a way that is not reversible.
Being able to start the camera without unlocking the phone is a good step, but you can also delete the footage just recorded if someone apprehends your device. I would be interested in the option to not be able to delete that footage.
I would also be interested in being able to live-broadcast (maybe just audio?) to someone else's device to prevent the evidence from being destroyed also without having to unlock your phone.
- That is the difference between complex state and simple state.
I use a debugger when I've constructed a complex process that has a large cardinally of states it could end up in. There is no possibility that I can write logic checks (tests) for all source inputs to that state.
I don't use one when I could simply increase test situations to find my logical error.
Consider the difference between a game engine and a simple state machine. The former can be complex enough to replicate many features of the real world while a simple state machine/lexer probably just needs more tests of each individual state to spot the issue.
- If you enjoyed the state machine + parsing part and also I recommend the older "Lexical Scanning in Go" talk that Rob Pike gave: https://www.youtube.com/watch?v=HxaD_trXwRE
It's in Go, but you can apply most of it easily in other languages.
I'm so happy that modern languages like Rust, Zig, and Go support unicode/runes/graphemes natively. So many problem just disappear compared to Java, .net, C++, or scripting languages.
- I assume you mean https://github.com/pion/webrtc, I don't see any Go, I thought they just fixed a bug with compatibility with Pion.
- The article makes it sounds like Dang also helps with the codebase. There must be others, but Dang is the one I've seen for years at this point.
I've beeing a part of many online communities as both a member and moderator. However, Hackernews is the community that I've been apart of for the longest and the one that brings me the most joy.
Dang, is there anything random people like me can do for you? Can I at least buy you a coffee or something?
- > A large stdlib solves the problems the language is focused on
That's part of it, but it also solves the problem of vetting. When I use a Go stdlib I don't have to personally spend time to vet it like it do when looking at a crate or npm package.
In general, Go & Rust packages on github are high quality to begin with, but there is still a pronounced difference between OS packages and what is approved to be part of the language's own stdlib.
It's nice to know thousands of different companies already found the issues for me or objected to them in reviews before the library was published.
- This is why I created https://github.com/xeoncross/jr all those years ago
You don't need a backend.
Everything is literally built-in. It's the perfect scripting language replacement with the fast compile time and tiny language spec (Java 900 pages vs Go 130 pages) making it easy to fully train C-family devs into it within a couple weeks.