nrvn

Same. But we are probably just a subset of those who prefer narrow fonts. Pragmata Pro and Iosevka are top. The majority of new fonts that have popped up in recent years are all “wide”.

Yes, they are skipping.

The more important question is what is the reason behind.

Options are:

- ignorance and inexperience of their teams in containing/sandboxing/airgapping the test environments.

- intentionally leaving “escape doors” open that in turn can have its own motives which are speculated upon all over the internet.

Both are indicators of negligence. The latter might be classified as computer fraud and abuse.

Will be curious to know if any of the victims sue the owners of “rogue agents”. Until there is a court precedent ruling in favor of a victim it will be all fun and games for these “ai” companies and incidents will hit the news more. Regarding news, remember the golden rule of public relations: court attention at all times, scandals and “incidents” statistically attract more attention than “boring good news”…

I do realize that this is the opposite of a solution defined as an ugly hack. Someone asked, I decided to share my personal experience. Also, replying to other two unhappy hners who accuse me of something immoral: ios 27, no writing tools found in context menu, local model is gone and doesn’t consume expensive iphone storage. I don’t see genmoji and other shit like that. The rest I have not checked. If apple devices will ever start to interfere with my peace of mind because of “siri” “ai” I will not bother either and will just throw them out the window and call it a day. Wish you the same. We as customers vote with a wallet.

You can indeed disable it on ios and ipados. Turn off siri and change the language to the one that does not match your phone language and the models will be removed.

Did the same in 2012 with hp 2510p that had windows vista pre installed on it. I could literally brew a cup of coffee and make it halfway through while this poor boy was booting up.

Bit the bullet, installed arch and dwm. I remember my initial impressions on how fast the boot went, how silent the hdd is, how the whole things works reporting just a fraction of RAM in use(right after boot).

It was the first hands-on YAGNI experience. Windows(and macos and the likes of ubuntu) loads and starts everything it has and keeps the system busy at all times in terms of cpu, disk io, network io.

Barebone linux without beefy desktop environment was like “I boot into essentials and will lazy load anything upon request”.

Voyager program and the team behind it will always serve as an example for me. Over-the-space software updates, 50 years support life. Debugging and patching devices with no room for a mistake. How many of 2026 devices connected to internet will have that luxury in 2076?..

In my uni years bachelors, masters and PhDs required thorough research resulting in a huge opus printed and stitched together but the only thing that really mattered was the presentation of the work in front of the committee and oral defenses. To this day I have been living in full confidence that this is the academic standard that has been in place and effective (with variations) over centuries, if not millenias…

Even intermediate exams were a combinations of practical work in some written form and the theoretical grill sessions in the end of every semester.

All in all, if I had to put a professor’s hat today I would not give a sh.. if my students would use LLMs to write text. What would matter (and what does for me as a hiring manager at $WORK) and a human being with decency is the results of the _natural neural network_ training so to speak. IF whatever prompts and interactions with LLMs result in sharp knowledge of the subject and ability to apply the knowledge to solving real problems, well done and congrats!

LLVM’s policy is that contributors can use whatever tools they would like to craft their contributions, but there must be a human in the loop. Contributors must read and review all LLM-generated code or text before they ask other project members to review it. The contributor is always the author and is fully accountable for their contributions.

https://llvm.org/docs/AIToolPolicy.html

LLMs are just tools. Humans are always accountable and in the end whatever tool is used the human is the one powering on the computer. Banning LLM is like banning compilers themselves or linters with auto fix capability, or anything else that appends new characters to text files without humans pressing keyboard buttons.

Hence, nonsense.

Also:

https://forge.sourceware.org/redi/gcc-wwwdocs/src/commit/4d0...

“ The commit message for any contribution of LLM-generated content must include an “Assisted-by:” tag.”

You serious?!

Maybe projects that announce such anti-“ai” policies seek reducing slop and spam. But come on. Policy is a text doc. The real deal is enforcing it. Ban idiots, not humans using whatever tools to get things done.

I am the one who had been using g suite before it became google workspace for more than a decade.. Last year I changed my email provider, cancelled workspace subscription and deleted the google account only to create a new one with the same email address as a normal user. Used google takeout to transfer all valuable assets out.

I lost access to literally nothing! SSO binds your email address as the primary account idenitifier in all known to me services. Does not matter what IDP you use to “sign in with”.

I find this twitter thread misleading. Unless the affected account was using @gmail.com as their primary identity.

Buy a domain and set up email on custom domain. backup emails periodically outside of the provider to be able to switch easy if needed. Same applies to other data stored in SAAS of any kind. This is the rule of thumb if the risk of losing access to tour primary IDP is critical.

Assess the risk and act accordingly.

This!

Unfortunately, the term “reproducible” can be interpreted in many ways because there is no strict and complete definition. People and projects bend it to their liking.

Your approach is correct.

https://www.bootstrappable.org/

Should I freeze my plans to migrate from `poetry` to `uv` at "${WORK}"?

Exactly my thoughts immediately after reading the word “just”. Also, PITR.

The whole article is tongue in cheek. And I struggle to find any comment here that would actually verify and confirm (or not) the results of the author.

So here I am, random hacker news links verifier.

Scrolling to the image below "So, for example, grabbing it here does not work:" text and reproducing the issue with a small caveat: just moving cursor 1 (ONE) pixel right turns the cursor into the "diagonal resizing mode" cursor. Overall, the resizing area of the window corner is comfortably bigger than the author draws. Dragging empty space outside the rounded corner is weird but what isn't in today's user interface designs?

All in all have never experienced difficulties resizing windows in macos.

Miss the times of windows 95/98 and macos 9 (as some other commenters here) when OS UI was designed by humans and for humans and everything was explicitly clear including the area for window resizing.

Exactly. You can “have a vision” to accelerate full speed and hit the hard wall and just before going full throttle you are offered an opportunity to enter an open door around the corner which you have never even thought about. And that door helps you discover a new vision, that might stick for lifetime.

Also, while the original advice about “vision” sounds reasonable, it also sounds a bit dogmatic. The filpside of “career vision” is “tunnel vision”. And life is not deterministic, it has a much more probabalistic nature. Hence, curiosity and open mind.

Not being able to give granular permissions to folders is not the problem of an app which regardless of being open or closed source may be compromised. Remember that the risk is zero if and only if you avoid the risk, i.e. in this particular case do not install Obsidian.

Macos:

- does not have a granular permissions model as far as I know;

- deprecated sandbox-exec that allowed to achieve the above;

- macos appstore is a very strange phenomenon, I would not put much trust in it by default.

Obsidian:

- has a system of community plugins and themes which is dangerous and has been discussed multiple times[0]. But the problem of managing community plugins is not unique to them. Malicious npm packages, go modules and rust crates (and you name it) anyone?.. you are on your own here mostly. And you need to perform your own due diligence of those community supported random bits.

Obsidian could hugely benefit from an independent audit of the closed source base. That would help build trust in the core of their product.

[0]: https://www.emilebangma.com/Writings/Blog/An-open-letter-to-...

Website with background-color: #FDDB29 talking about color choices.

Irony at its best.

One of the worst things about Environment variables among others discussed here is the implicit and opaque nature of them. Majority of applications rely on them in the *nix world. Even if more explicit and obvious ways of configuration files or remote services (consul/etcd, et al.) and command line arguments are supported env vars are traditionally supported as well.

But as mentioned in the article it is just a global hashmap that can be cloned and extended for child processes. Maybe in 1979 it was a good design decision. Today it sometimes hurts.

For example, kubernetes by default literally pollutes the container’s environment with so-called service links. And you will have fun time debugging a broken application if any of those “default” env vars conflict with the env vars that your app might expect to see.

https://kubernetes.io/docs/tutorials/services/connect-applic...

They are ubiquitous and we are living in the world of neo-conservatism in IT where legacy corner cuts are treated as a standard and never challenged (hello /bin, /usr/bin, /lib, /usr/lib)[0]

[0] - https://askubuntu.com/a/135679

Design system as any other human-built system requires to be documented and described in order to maintain integrity where the integrity will be described in clear terms via foundational principles that the rest of the system is built upon. I am surprised to see how some things in today's world fall apart despite in mere seconds despite enormous amount of prior art and experience and lessons learnt.

As they say, YMMV.

My personal journey:

2010-2014 - sublime text

2014-2017 - vim and later neovim (bunch of plugins to resemble IDE-like experience)

2017-2024 - jetbrains (intellij idea with language plugins mostly)

2024-now - neovim (with lazyvim)

I tried helix in 2023 but it did not stick. Do not remember details but remember the final impressions of having to train muscle memory to “awkward” vim-like key bindings and dealing with various annoyances and bugs. End of trial and error I left it as a terminal $EDITOR for quick and adhoc tasks while doing all the heavylifting in intellij. Ditched it finally when vim muscle memory and hx muscle memory made my brain short circuit several times in a row.

Now I am back to neovim and it is surprisingly as productive (when equipped with proper plugins) as the beefy jetbrains IDEs.

That said, helix looks promising. Maybe it’s the next big thing, who knows)

To honor the memory of this noble man I am using a single bladed razor.

I used the following sources to create an RFC template (and promote the document culture across the engineering documentation):

- https://www.industrialempathy.com/posts/design-docs-at-googl...

- https://github.com/rust-lang/rfcs

- https://github.com/kubernetes/enhancements/blob/master/keps/...

- https://blog.pragmaticengineer.com/rfcs-and-design-docs/

Hint: tailor the process and template structure based on your org size/maturity and needs. Don’t try to blindly mimic/imitate.

> The image attached to this blog post is a stock photo of a nude pregnant woman. Absolutely nothing sexual.

maiesiophilia (pregnancy fetishism), maschalagnia (armpit fetishism)…

cybersecurity 101:

- know your threats

- assess your risks based on identified threats

- backup 3-2-1 strategy (3 copies of your data on 2 independent storage places with 1 copy offline and offsite)

- "build the world from scratch" plan with the assumption that all infra is completely and irreversibly destroyed.

- assume you have already been hacked but you don't yet know about it. Build your indicators of compromise based on that simple assumption.

Observing how some "groups of people" act in a totally ignorant fashion is amusing.

also a great guide for building production-ready containers using uv:

https://hynek.me/articles/docker-uv/

this is my new fav for running small executable scripts:

  #!/usr/bin/env -S uv --quiet run --script
  # /// script
  # requires-python = ">=3.13"
  # dependencies = [
  #     "python-dateutil",
  # ]
  # ///
  #
  # [python script that needs dateutil]

In my org I have enforced linear history, squashing all commits into one in PRs and roughly following the rule from [1]:

> If the request is accepted, all commits will be squashed, and the final commit description will be composed by concatenating the pull request's title and description.

One less thing to think about.

Less is more, not vice versa.

[1]: https://go.dev/doc/contribute#review

Synonym search is rocket science. It will take 20 years after they figure out n-gram search (i.e. “srceen time”, “cellluar”, et al.) and keyword search (“Set charge limit”)

And it applies to all apple operating systems.

Basic UX is not sexy nowadays.

I have been using the "bare git at $HOMEDIR"[0] approach for several years.

Benefits:

1. no extra tools.

2. one off task for setting up the git repo and alias `dotfiles='/usr/bin/git --git-dir=${HOME}/.config/dotfiles --work-tree=${HOME}'`

3. all files are where they are, no symlinks, copies, etc.

Caveats:

1. $HOME/.gitignore just ignores everything because it contains a single "*" char[1]. So adding new files must be done with dotfiles add -f ~/.newfile to track.

Refs:

[0] - https://www.atlassian.com/git/tutorials/dotfiles [1] - https://github.com/nrvnrvn/dotfiles/blob/main/.gitignore

exactly. I am surprised by the amount of comments in this and similar threads praying for github to add more complexity to an already over-complicated and fragile solution.

CI must be local-first and platform-agnostic.