skysight-inc/HackerNews huggingface dataset:
I maintain hundreds of thousands of lines of Go code, for a few years now. I would not pick another language for that.

The important properties with maintaining code bases like that are language regularity (most code is written the same way and you don’t have to make personal “taste” decisions on things), good documentation and online communities, well-maintained libraries, tooling features for versioning and namespacing, deployment simplicity, etc. Go nails those things.

I agree that Python is great for interviews. I would not use it for a large codebase maintained by a bunch of people for years, unless there is a really compelling reason.
Looks like the robot has a windmill mounted on top, there’s a video about 1/3 of the way down the page.
Who created the barriers?
It's getting the job done, it's faster, and the developers are happy. It sounds like a success because it is.
> There are some cases where re-writes in Go or Rust are just so good that the "originals" become almost entirely obsolete.

Why's that?

I use Jekyll here and even with over 500+ articles (posts + drafts) it takes around 2 seconds to get live reload feedback in Jekyll while writing. Jekyll also handles the entire asset pipeline complete with md5 tagging of assets without using Webpack or any build tools. It also lets you write plugins with a few lines of Ruby to add new template filters and other things.

For example I wrote a custom Jekyll plugin that lets me write bullet lists like this after a specific type of header:

- 0:45 -- Something
- 1:45 -- Another thing
- 1:03:31 -- And another thing

And it automatically converts the timestamp numbers into clickable links that jump to that point in an audio player.

AFAIK Hugo has no way to do anything like that, at least no where near as easy as Jekyll. With Hugo wouldn't I have to compile a custom build of Hugo for such a thing? But with Jekyll it was adding 1 file into a directory and writing 20 lines of "business logic code" to add a new filter. Now I just do {{ content | audioseek }} when I want clickable timestamps.

I also wrote another plugin that automatically adds certain rel attributes to external links by adding {{ content | extlinks }}.

Things like the above are why I continue using Jekyll because personally I haven't found another SSG that comes close to how easy it makes it to add custom behavior. I don't mind the 2 second live reload wait and I wouldn't switch away from Jekyll for a speed boost alone. At some point the speed is "good enough". Sure I would love a 100ms reload but I wouldn't give up everything else for that.
Not sure why this is downvoted. It pretty clearly demonstrates the point that there is a such thing as being too simple, and that simplicity for its own sake is not a virtue.
Wow, awesome work on this!
Sure it’s really a bad thing - a network that consumes exponentially increasing resources but cannot change because the incentives for individual actors is to keep playing the same game is just a tragedy of the commons and nothing more.

Dislike of the ‘fed’ had no bearing on this.
A while back, I built a sync library for iOS storage <-> CloudKit (Apple’s iCloud storage system)! It features offline queuing, smart merge/deduplication, and uses NTP timestamps to make sure offline/online merges are handled reliably. It took quite a bit of time to get right, and is probably one of the projects that has helped me grow the most (technically) as an engineer.

- I built it because at the time, sync for iOS was a mess: Apple’s original CoreData iCloud sync was very buggy and often failed to sync. An open source alternative seemed nice but poorly maintained, and I wasn’t completely on board with the overall architecture of it. A paid library was great but also quite complex and I had no control over the direction, features, and longevity.

- Apple released their own alternative recently, although it’s only available on newer iOS versions. Additionally, I’m not in control of the CloudKit data schema, and I don’t have the ability to add more complex sync features if needed.

- underlying all of this: the need for control, reliability, and customizability.

So, I spent a few weeks writing my own system. It works well and despite a few hiccups that I’ve resolved, it currently provides reliable, seamless sync for an app with millions of downloads.

- My library is quite generic but I never open sourced it. It would be a nice contribution to the open source community, but I’m not sure I have time to consistently maintain it or review pull requests. I’ve considered it at times, but it’s just never been a priority.

- If sync ever goes wrong, I’m able to debug it and understand exactly what the problem is.

- I can add features any time I like. I plan to do so soon to support a few things that even Apple’s new solution might not encompass.

There are quite a few downsides to it too:

- I need to maintain it myself

- It probably has had less testing than something like Apple’s new solution

- I’ve occasionally shipped a small sync bug, primarily due to lack of ability to test at scale

Overall I think it was worth it, especially given that Apple’s new solution wasn’t available at the time. I learnt a lot; building a generic framework is a great way to grow technically.

If I had to make the same decision again today, I’d heavily consider Apple’s new solution instead, although I’d only choose it if I was confident that it is much more reliable than the prior option they provided.
The strength of the Kraft branding allows them to sell the worst shit.
Repoint, a thingy for checking out and versioning your source code dependencies - for situations where you don't have a good language-specific source package manager to hand.

https://thebreakfastpost.com/2018/05/18/repoint-a-manager-fo...

https://github.com/cannam/repoint

I wrote this because, as is normal, I was slightly dissatisfied with all the options I could find that would work with the language and hosting combination I happened to be using. I use it for a number of projects now and I have to say that it's really quite good.

It's written in Standard ML, which might tickle a few HN readers.
What percentage of merchants accept cryptocurrency and what percentage of merchants accept cash? "Fiat currency" may not have inherent value in the same way as gold or pork bellies, but stable currencies (e.g. Euro, US dollar) are backed by governments which have incentives to be good stewards of their responsibility and if those currencies collapsed, I don't think the world would be in a state where cryptocurrency would retain any value.
I suspect the incumbents also want to minimize the number of precedent-setting municipalities that control their own broadband. Each one could potentially become a good example of the benefits of publicly owned infrastructure - and then inspire other cities to do the same.
If you want a statically typed language with Python-alike syntax but Nim is too "noisy" for you, then Lobster (http://strlen.com/lobster/) is likely spot-on.
Waymo's passengers are neither insured, nor necessarily licensed to drive a motor vehicle. The Waymo is driving, this isn't like Tesla "autopilot" where it's just pretending and actually all responsibility remains with you throughout so you need a license and insurance.
I agree. The problem is the tangential stuff _feels_ important and leads you to want to perfect it before even starting content.
I built a safe PostgreSQL driver for node from scratch with zero dependencies in about 1200 lines. I did this mostly because of the plumbing required to make the goto node driver tolerable to work with. In the process I made it 4-5 times faster as well.
https://github.com/porsager/postgres
The CSS still works in the browser so it isn't cleared just ignored. This is enough for me, I could use something like Parcel or Vite to observe folder with notes to reload changes in browser. This way (HTML Notepad + live reload) I can combine WYSWYIG + inline CSS to create good looking single page notes and replace Notion in some cases (it's slow and I don't own files as they are in cloud).
As a student of Dutch I empathize with some of these. Though it is pretty cool that, if you stick with it, your brain is capable of reshaping itself into these new forms. Even as an adult - I started learning it at around 35.
> Scala is one of the smallest typed languages in terms of syntax.

Eh, that slide isn't really worth looking into. None of the languages there have a uniform way to represent the grammar. If you look at the C# and Scala grammars you'll find that the Scala one is highly compacted, whereas the C# grammar is intentionally not compact. They're encoded in different formats.
> Out of curiosity, since I expect to give a short Rust introduction in the near future, what was your language background when learning Rust?

I have a background in lots of high level languages, like Python and Haskell, but never thought too much about how the types were represented.

But prior to learning Rust I spent some time writing C (I've never done C++), so I guess I came in with a simple idea of how pointers work.
https://hyperscript.org/comparison/

<div _="on click transition opacity to 0 then remove me">Remove Me</div>

Inspired by HyperTalk, of HyperCard fame..

hyperscript is a companion of htmx (which is the successor of intercoolerjs)
Front matter is the same with both Jekyll and Hugo, and it's certainly better than the alternative for per-post config which is an unavoidable constraint.

It's theoretically possible to do automatic-render-on-commit-and-sync with GitHub Actions, although I haven't investigated it. There wouldn't be much of a performance hit either.
Up to some limit that varies from device to device.
That looks absolutely terrible and amateurish on iOS Safari, strengthening the point about browsers needing a consistent justification engine.

It actually distributes space between characters rather than words as is the norm in print (and is partly why books and magazines don’t look like a teenage yearbook editor’s first day with InDesign).
It was also the #21 (37% of respondents) most dreaded. For context, the “love” rating was a 62% response, so that means it’s something like a 2:1 love to dread ratio. At my current company it’s definitely leadership pushing for Go and not the other way around, and lots of startups have chosen Go early and are stuck to it inflexibly.

Edit: I retract this. Looks like the metrics are simply inverses (even though they shouldn’t be).
Can you actually exit the system without scanning the card again?
In the USA, typically government agencies are prohibited from selling services that compete with private sector companies.
This isn't really fair. Despite requiring overly verbose code with lots of repetition and boilerplate, it is still quite powerful.
I had never heard that term before- so I had to look it up.

“ A blank check company is a development stage company that has no specific business plan or purpose or has indicated its business plan is to engage in a merger or acquisition with an unidentified company or companies, other entity, or person. These companies typically involve speculative investments and often fall within the SEC’s definition of "penny stocks" or are considered "microcap stocks."

In addition, a blank check company registering for a securities offering may be subject to additional requirements for the protection of investors, including depositing most of the raised funds in an escrow account until an acquisition is agreed to and requiring shareholder approval of any identified acquisition.

A type of blank check company is a “special purpose acquisition company,” or SPAC for short. A SPAC is created specifically to pool funds in order to finance a merger or acquisition opportunity within a set timeframe. The opportunity usually has yet to be identified.”

https://www.investor.gov/introduction-investing/investing-ba...
widening the canal has numerous benefits. Eyeballing it I think they chose this size so the current largest ships allowed (Suezmax) can pass each other with the additional width, allowing for 2-way traffic.

The accident is probably just a nice catalyst or PR move.
Is that boiling point at 1 atmosphere?
German has a difficult grammar (was a real pain when learning German as a kid) but at least when reading German you know how to pronounce it, English pronunciation like German gender must be learn by heart :)
I prefer easy things over complex things. Only a fool would prefer complexity for complexity's sales. Repetitive, boilerplate is easier to understand and work with than highly abstract, extremely clever code.

For personal projects I'd say write the code however you want. But for professional work, I think the emphasis should be firmly on code readability. I'd almost always forego some beautiful abstraction that's hard to grok without the necessary background in favor of dumb abstractions that are easier for most people to understand.
I'm strongly of the opinion that people make much too big a deal out of line counts and character counts. I'm very doubtful that there will be a significant difference in quality between two equally-complex programs which differ only in that one is more terse.
What I Learned in Space about the Climate Emergency
Learning the correct pronunciation of "th" was tough though. :)
I have 112 mostly-maintained released project listed on https://github.com/simonw/simonw/blob/main/releases.md now - most of which are tools for loading data into SQLite database files (a surprisingly under-served use-case given how ubiquitous SQLite is) and plugins for my https://datasette.io/ project for reading data back out of SQLite again.

I realized a few years ago that SQLite was the perfect tool for doing data analysis at the small-data scale, where small data is less that 10GB which is pretty much everything you might want to analyze - especially for personal projects.

So I've been building tools to fill that niche!
In this case the idea that 100% of the app lives in the HTML document seems like the reason just another JS framework wouldn't accomplish their goals.
That's a take alright. I wouldn't say it's particularly good though.

Why shouldn't all languages be easy to understand? Why would anyone want a hard to understand language unless it provides benefits significant enough to offset that? Newsflash, most don't. Go has your cross platform, it has your simple code, it has your single executable and it has your performance. That suits the needs of most developers should they be interested in Go at all.

The fact that someone with little knowledge can contribute easily to any Go project is a huge benefit to the language. It's simple enough and the code most people write is idiomatic enough that you can drop into any project and know where to start. That is something I can't say of any Java or C# project I've looked at before.
Unsurprisingly, there are many articles published about "The Awful English Language", such as: [1], [2], [3]

Some examples from [2]:

Let's face it -- English is a crazy language. Besides the above,
there is no egg in eggplant, nor ham in hamburger; neither apple
nor pine in pineapple. English muffins weren't invented in England
or French fries in France. Sweetmeats are candies while
sweetbreads, which aren't sweet, are meat.

We tend to take English for granted. But if we explore its
paradoxes, we find that quicksand can work slowly, boxing rings are
square and a guinea pig is neither from Guinea nor is it a pig. And
why is it that writers write but fingers don't fing, grocers don't
groce and hammers don't ham?

If the plural of tooth is teeth, why isn't the plural of booth
beeth? One goose, two geese. So one moose, two meese? One index,
two indices? Doesn't it seem crazy that you can make amends but not
one amend? If you have a bunch of odds and ends and get rid of all
but one of them, what do you call it? If teachers taught, why
didn't preachers praught? If a vegetarian eats vegetables, what
does a humanitarian eat?

[1] - https://www.angelo.edu/faculty/kboudrea/cheap/cheap3_english...

[2] - https://neth.de/Interact/Sprachspiele/homowords.html

[3] - https://ronaldyatesbooks.com/2017/03/the-awful-english-langu...
As fake as the american dream!

I like how this guys became successful by literally lying
If there's an actual case where evidence on stored on a law-enforcement operated Cellebrite machine gets destroyed or corrupted, and if further forensics shows that it happened due to e.g. an aesthetically pleasing file with a specific payload being deployed on that phone, then the state is likely to charge the people involved in this particular act for tampering with evidence. And if it happens, then Moxie's original blog post would help prosecution a lot.
Smart engineers underrate, and are even insulted by (I.e this comment) simplicity. If the language is simple enough that a manager can write in it, maybe it also means that smart engineers can dedicate their limited brainpower to solving business problems not language puzzles. I assert that this is true in gos case.
It's suggest gatsby. You'll need javascript at some point and you don't want to deal with generated javascript or some hacked together javascript.

Anything else that's not js, imo you're making the biggest mistake... Eventually you'll need js...
Most of my blog posts (at chriswarbo.net ) are about programming, so I wanted a way to run code embedded in markdown, and to include the results in the rendered document. I wrote a couple of scripts to do this via pandoc:

- https://hackage.haskell.org/package/panpipe

- https://hackage.haskell.org/package/panhandle

They're described in more detail at http://chriswarbo.net/projects/activecode
Introverts can make good leaders, but it can be difficult.

Note I'm using what I feel is the most common definition of introversion/extroversion even if it is somewhat of a "pop" psychology definition, i.e. introverts recharge by quiet time alone, extroverts by being around others.

When you are a leader, a huge part of your job is being around other people a lot, and communicating with them, often times having difficult conversations. I'm introverted, I think I have fairly good (or at least OK) social skills and I'm emotionally introspective, I was an engineering director and I think I was pretty good at it. However, it left me feeling completely exhausted. Every day I would come home and basically crash because I was spending a huge portion of my day talking to people. It negatively affected my relationship because it was hard for me to be available to my partner when I was so tired from interacting with other people all day.

Contrast this with an extrovert, who actually gets energized by all of those daily interactions. It's very difficult to compete with that behavioral mindset in a job where a majority of work is person-to-person interactions.

Not saying my experience is the same across all introverts, just expressing my frustration at a lot of these "introverts have super powers!" type articles that have an underlying message that some jobs (i.e. "leaders") are intrinsically more valuable than others.
I build a logging library for Go, because I couldn't find one that logs to stdout AND stderr. If you used a logging lib on GCP for example, all log output went into the same pile of junk and it was hard to find "real" errors: https://github.com/emvi/logbuch

Then there is "null", also because I couldn't find one that got both, marshalling to JSON and be able to store null values in db: https://github.com/emvi/null

And finally, our "flagship" open-source project Pirsch, an embedded library for web analytics: https://github.com/pirsch-analytics/pirsch
And if that fully-internalized cost did not negatively impact other uses of the market. In the same way, the post office forbid the sending of the Send a Dime chain letter[0], even though the senders paid full postage. It was a use that interfered with the intended outcomes of the post office, and prevented the end goals of the post office.

[0] https://www.mortaljourney.com/2010/11/1900-century/1930-tren...
Examples which use "mouseover" to explain something usually forgets that we use smartphones too
The last software team I was on used Zola for a lot of our internal documentation publishing. It worked great and we were really happy with it!
Hyperscript is a cool attempt at providing declaration to HTML and UI development in general. 90% of what happens in a UI is ubiquitous across software. Buttons are clicked, images are positioned.

Not going to wax on, but recently spent some time on boarding a new hire. Level 1 developer. The amount of time I spend explaining things like async processes, prototypal inheritance vs class structure, how to debug anything, etc. are all problems because our documents aren’t explicit enough. I think a more declarative language (in respect to UI) that maintains simplicity will cut through the cruft of a lot Of modern JavaScript exhaustion.

Very cool project from the HTMX crew.
Easy is not the opposite of complex. Simple is the opposite of complex.

Once systems grow, 'easy' quickly turns bad because of lack of abstraction capability.

EDIT: A good video on this is 'Simple Made Easy' by Rich Hickey.
This has always been a favorite. I also enjoyed this one about Chinese, which my wife sent me recently: http://pinyin.info/readings/texts/moser.html
It's a dynamic error if you access a let-bound variable before it is actually initialized. In most other languages that have lexically-scoped declarations, it simply would not be visible. So I think JS's choice is actually a regression.
http://archive.is/vgHCm
Past related threads:

Bette Graham, the inventor and founder of Liquid Paper (2019) - https://news.ycombinator.com/item?id=22533312 - March 2020 (13 comments, pretty bad)

Bette Nesmith Graham, Who Invented Liquid Paper - https://news.ycombinator.com/item?id=17513500 - July 2018 (16 comments, better)
Responding to this pathetic trolling was a mistake: https://news.ycombinator.com/item?id=27174525 and I would have known better if I'd looked at giardini's posting and commenting history: https://news.ycombinator.com/item?id=27174521
Dbmate: https://github.com/amacneil/dbmate

I found most database migration tools tried to be too smart (I'm not a fan of automatic migrations), were too tightly integrated with specific languages or frameworks, or didn't support basic developer workflow pleasantries such as dropping and recreating the database.

I created a simple single binary migration tool that runs migrations (sql files), and keeps track of applied migrations in a table (inspired by Active Record migrations). Dbmate works with any language or framework, and generally tries to be useful while staying out of your way.

Comparison against other tools here: https://github.com/amacneil/dbmate#alternatives
Fun idea, but inline scripting only works for the simplest things. I could write my handlers inline with JS as well, but I really would rather not.

Maybe a bigger question is why not have this as a JS library, but its own language. Because it's kind of almost there (here using jQuery):

<button _="on click toggle .big-text">
Toggle the "big-text" class on me on click
</button>

<button onclick="$(this).toggleClass('big-text')">
Toggle the "big-text" class on me on click
</button>
Is this because they tend to heat up when you use a GL context? And the UI toolkits composite to the screen less often?

I'm not a mobile developer so this is all new to me. Thanks for the info.
A language isn’t going to save you from a bad codebase. And the longer I work in this industry the more this has become apparent to me.
Panics are prevented by culture, and I fail to see how a c# dev complimenting go invalidates gos competitive edge over c#?
AT&T nears deal to create $150bn streaming giant with Discovery
I would personally love to use something other than JS for making web pages, so there is at least me.