Kagi search exposes me to a lot more blog based solutions

I’ve found that searching for solutions to technical problems in Kagi brings me to many more blogs. Recently I’ve been learning Zig, coming from a mainly Rust/C++ background. As with any language, I’ve been searching for the idiomatic approach to solving different problems to make sure I understand the Zig “philosophy.” With Kagi I feel like I get taken to more blogs where I can read the struggles and solutions of real human beings.

One recent example was my struggle with parsing JSON in Zig, particularly around the std.json.Parsed type. Nice posts from Karl Seguin¹ gave me a good overview as well as a deeper dive into the Parsed type. Most helpful was that it seemed like he had the same distaste about passing around a Parsed(T) instead of T and gave a decent solution. This was a better solution than what ChatGPT recommended which I really appreciated.

Human connection through blogs

In addition to reading the actual unique voice and experience of a human being, I found that most blogs (including mine) have a reply by email option. I really wish I had saved the source, but some time ago I read a blog post telling people to respond via email when you see a good blog post. I’ve been making an effort to do it when I find a post that has been very helpful. Most times it’s just a short “Thank you for your post on X, it really helped me out with my issues!” Every time I’ve done this, I get a short response from the blog owner mentioning that they are happy their blog was helpful. It’s a pretty small bit of human contact, but I feel like it’s just a small positive interaction that brightens the internet wasteland. Now for my maybe more controversial take.

Why I don’t think LLMs are a good search replacement

I’ve refined a simple philosophy around LLMs after using them pretty much full time and trying to go down the Agentic Engineering™️ rabbit hole². In my view, use of LLMs is a direct trade between current velocity and long term growth, with continual reliance dropping you down to the mean without you even realizing it. This trade is obviously not straightforward. I use LLMs and agentic tools daily in my job because keeping up velocity is important. Gone are the days when you can spend 1 week searching online/reading your code for the 100th time to try and find the issue (for better or worse). But I try to pull out the moments where the task offers growth potential and I have the time budget to spend.

In general, I think the safest use of LLMs is when you already know exactly what you want and you just need the clanker to implement or find the small tidbit of missing info. In the context of learning Zig, I’m not satisfied using LLMs because I don’t know what I want. I may know that I need to parse a specific JSON payload, but I don’t know what the right way to implement that is. With that in mind, I hesitate to just ask ChatGPT/Codex “How do I parse this specific JSON to get this result” for the following reasons:

• LLMs are designed to convince you. Many studies³ exist that show an LLM can basically convince anyone of anything.
• If you don’t have a strong opinion coming into LLM usage, you likely will just accept the LLM solution. Even if you have issues and try to refine the solution, you are still locked into the solution space provided by the LLM/your knowledge.
• That combined solution space is not necessarily the correct solution space.

That’s why I think doing real search and finding real sources has a better chance of giving you an optimal solution, since you are exploring a potentially larger solution space. You also avoid the whole issue of getting your understanding psyoped by the sycophancy machine. This only works though if the search provider is focused on providing good search instead of providing good ads or forcing LLM interactions⁴. Thank goodness for Kagi.

This only matters if you care

There are plenty of situations where I have to do something that I really don’t care about. Maybe I need to write a one-off script quickly, create a custom file parser for an atrocious file format, or just need some answer even if it isn’t the best answer. In those situations I use LLMs without hesitation. But I’m always honest with myself that using LLMs is sacrificing growth for convenience. And the particularly insidious part of this, is that you don’t know what you are giving up. While researching solutions for one specific problem, you may accidentally come across a transformative idea or a technical concept that may help with another problem.

It seems like there are a lot of people either leaving or talking about leaving Github, a very prominent one being Mitchell Hashimoto. Fragmentation seems inevitable, as people/companies start to distribute among the various options (Codeberg, self-host Forgejo, Gitlab, etc…). I think the decision Hashimoto makes with ghostty will potentially set the tone for how the death of Github will happen. I have some scattered thoughts about the situation:

• Tracking activity across providers
• Some kind of trust system is needed to stop AI slop
• Get your username locked in NOW
• Is self-hosting the right tool to stop AI slop?
• Mirroring self-hosted repos to Github for engagement
• Conclusion

Tracking activity across providers

I hope to someday be a 10x bathroom tile developer with a git contribution heatmap being a solid color. I have already had an issue with tracking my progress working on repositories split between my self-hosted Forgejo instance and Github. I’m a simple man that wants to see my contributions measured on a public heatmap for both satisfaction and motivation. So I solved this problem for myself with a go script and hugo module that you can use to create a git heatmap combining data from multiple hosting platforms. Just takes one go command to generate the activity file, some hugo config changes, and a simple shortcode embedded in your hugo markdown.

[Github repo available here]

This is my unified git heatmap from my Forgejo and Github

I also have some random thoughts I wanted to write out about the whole situation.

Some kind of trust system is needed to stop AI slop

I think the years of allowing contributions from anyone with an account is over for open source. Maintainers are drowning in AI generated PRs/issues from unvetted sources. Even though AI contribution quality is reported to be improving¹, the core volume issue isn’t. The current system is requiring maintainers to wade through PRs/issues that potentially took 0 human effort/time to produce. Even if some of them are useful/correct, the sheer volume makes the entire system intractable. You guys already probably know this.

Hashimoto has a solution to this called vouch that is currently being developed. It tracks approved/blocked contributors on a repo basis using a Github actions workflow by appending usernames to a VOUCHED.td file. The syntax of the file is:

# Vouched contributors for this project.
#
# See https://github.com/mitchellh/vouch for details.
#
# Syntax:
#   - One handle per line (without @), sorted alphabetically.
#   - Optional platform prefix: platform:username (e.g., github:user).
#   - Denounce with minus prefix: -username or -platform:username.
#   - Optional details after a space following the handle.
aselimov
github:aselimov

This is a step in the right direction, but I still think a trust system needs to be built into the forge platform. Ideally you would also be able enable vouch chaining somehow. Effectively

aselimov VOUCHED by user1 on repo1
user1 VOUCHED by user2 on repo2
aselimov indirectly VOUCHED for repo2

I think we need a web with some barrier of entry to ensure contributors are high quality and motivated instead of bots that will write hit pieces².

Get your username locked in NOW

If we are transitioning to a vouching based trust model you are going to want to lock in a consistent username across the main platforms. That way, if a cross-platform trust chain is established, you will have fewer issues from username squatters impersonating you. Seems like the main Github alternatives are:

• Codeberg
• Gitlab
• Bitbucket

Personally I think Codeberg/self-hosted Forgejo is the best option, but you probably should make an account on each just in-case.

Is self-hosting the right tool to stop AI slop?

Self-hosting Forgejo is the maximally guarded vouching system. In most cases³, the host disables account creation to not get inundated with spam/malware. To get account access, you have to reach out to either the host or a known admin to get registered. Probably this means sending an email, LinkedIn message, DM on x, etc… I’m not completely opposed to this concept if I ever spin up a project successful enough to be targeted by the slopocalypse.

Mirroring self-hosted repos to Github for engagement

My current workflow does involve mirroring all of my repos to Github to enable some level of community engagement. The main motivating factor is to enable some sort of issues tracker, but receiving PRs is a nice bonus. Migrating the PR from Github to Forge requires manual effort on my part which acts as a hardening step. It ensures that I need to approve the PR before it gets anywhere close to my CI. This could be a layer of protection if my brain stops working, and I start introducing vulnerable actions⁴ by mistake.

Conclusion

• Add a unified git activity map to your hugo site!
• Establish your username/identity on all of the major forges.
• I have no idea where things are going from here or if Github can recover.

I came across a video by Simple Lucas describing a routine to improve focus and productivity. The routine was basically:

1. Don’t use any screens/entertainment when trying to focus on work.
2. When you start to feel mentally drained, sit and stare at a wall for x minutes to recover focus.

I’ve been trying it, and it’s a very effective (but hard) routine.

The problem

The core problem is that most people by default are in an information overload. A paper published in 2012 showed that in 2008 the average person was receiving 34 GB of information daily, with a daily information exposure growth rate of about 5.4% per year ¹. Extrapolating that trend, we would be at about 87 GB worth of data today. This calculation includes audio, visual, and text data and incorporates quality into the measurement, i.e. 10 minutes of HD video has more information than 10 minutes of 480p video. It’s unclear to me exactly how the quality impacts things, but regardless it is obvious that we are all being drowned in a sea of information.

I certainly go through periods of “brain fog” and lack of focus/motivation. These periods usually go something like:

1. Get a bad night of sleep (up late for an event, kids keep waking me up).
2. Wake up very tired so consume large amounts of caffeine.
3. Have trouble focusing after 2/3 cups so use media while working to dull the pain (music/podcasts) or take more “breaks” (reading hackernews).
4. Stay up late because I’m wired on caffeine and dopamine from scrolling.
5. Go back to 2.

I find these cycles very hard to break out of when I’m in them. The media consumption constitutes a small dopamine hit. Large numbers of small hits puts you in a hole, where you need even more/stronger hits to feel good.

Disconnecting

The obvious solution is to disconnect from scrolling, but that doesn’t overcome the biggest issue. When I’m in this “brain fog” cycle (and sometimes outside of it), I will find that around 1/2 pm I hit a wall. My head will start hurting, my motivation will be trash, and my productivity significantly degrades. My first instinct is to go for more coffee. That usually lets me keep working, but at a slow/painful pace. While looking for focusing strategies I came across the life-changing solution…

Stare at a Wall!

After watching Simple Lucas’ experience, I decided to try it when I hit my focus wall.

It worked.

In my attempts, I combined wall staring with a few other concepts I had heard about. First was activating the parasympathetic nervous system by staring at the wall “out-of-focus” and using peripheral vision. Second was incorporating mind blanking which means trying to think of nothing. I tried intervals of 5-10 minutes and when I was done, my focus was back!

What I didn’t expect was how difficult it would be. Sitting for 5-10 minutes staring at a wall without thinking of anything is hard! I relate it somewhat to the feeling I have with working out. Often times I want to avoid it because it’s hard, but I’m always happy when I push through and complete it. It was the exact same experience with the wall staring.

So far I’ve been feeling significant focus/productivity improvements. I’ve also been using some other strategies to improve focus, which I’ll be talking about in a future post. I plan to continue this routine and will update to see how much it has impacted productivity/focus. Thanks for reading!

Let no good crisis go to waste
-- Winston Churchill ¹

I’ve been thinking about the above quote lately. Normally this is applied in political contexts, but I think it does a good job describing the last couple of months for me. For example, today I’ve been sick as a dog (probably with that new covid variant). Normally I would be trying to speed things along by rotting my brain on YouTube or other pointless entertainment. While there was some of that, I was really surprised to find myself wanting to write some code for a project I’m working on! And this wasn’t Agentic Engineering™. I was enjoying writing good old-fashioned, organic, artisanal, free-range, handwritten code. I knew I had to summarize (at least for myself) how exactly I got here.

The “crisis”

Around last September I started working pretty hard in my free-time on a startup idea (state of idea still tbd). Even though I’m anti-social media, I decided to swallow the poison pill and get on LinkedIn to try and build some early traction/validation. When I got on, I started getting drowned by

• “AI has made programmers obsolete.”
• “Agentic engineering is the future”
• “If you aren’t orchestrating agent swarms you are falling behind.”

That started to raise some hairs and my anxiety. Now at the time I was using Claude Code daily at work and for my personal project. I noticed that Claude Code was decent at my work tasks but not very good at my more innovative personal tasks. Then my feed started hitting me with news about the “inflection point” with Opus 4.6, full agent dev teams, mandated agentic engineering in big tech. The news about Gas Town and Ralph Loops made me feel like I was falling behind.

Personally I saw big workflow and productivity improvements with AI tools. This was particularly around search and boilerplate generation. Biggest use-case was copying patterns (although I always had to double-check it was actually implemented correctly). When I tried doing more complex changes, I saw the LLMs struggle. None of this suggested that full agent dev teams were actually feasible long-term. So I thought this was a skill issue.

Now I have two kids and my wife raises them full-time. This means it’s on my shoulders to make sure we can eat and that we have a roof over our heads. I really had to figure out some way of getting through the AI apocalypse intact. I was mainly experimenting with different projects, different types of AI vibe coding (spec-driven, human in the loop, human-less Ralph loops). I’ve seen articles suggesting it wasn’t just me.

The realization that I’m spiraling

After several months of grinding with steadily growing anxiety, I came across Mitchell Hashimoto’s workflow. I wrote another post about it here. This was the first time I was exposed to a serious guy who wasn’t on the AI will replace us hype train. After this, I started paying attention to a lot more news that was also anti-hype:

• Mo Bitar, guy that talks a ton about AI code quality and, more importantly, the impact of AI on our own brains.
• Commentary on Metr article suggesting code quality from LLMs isn’t actually getting better.
• Metr article suggesting AI doesn’t actually improve productivity.
• Armin Ronacher post about comprehension debt and AI psychosis among vibe coders.

Those resources, among others, talked me down from the doomer cliff I was on. I’m a lot more pragmatic now. Current AI can’t replace a good dev (it’s not a skill issue). There is no guarantee one way or another that future AI will be able to replace a good dev (I lean towards it won’t be able to). Regardless, the only thing I can do is continue to keep my coding skills sharp and keep using/exploring Claude code/codex, but without the anxiety. I don’t think it’s worth learning the modern advanced agent orchestration techniques since best practices around LLM techniques are constantly changing. In the last 6 months since I started paying attention, I’ve seen a lot of noise with different approaches. Two major changes I can recall off the top of my head are:

1. Claude.md is important, you can have claude generate it² → agent generated Claude.md worsens results. Only good approach is minimal human generated³
2. MCP is the best standard for calling external tools → clis are the best standard for calling external tools⁴.

There is no guarantee that the prompting/orchestration skills relevant now will be relevant to a future LLM that can fully autonomously generate robust, secure, and production ready code. Those skills are also not relevant if LLMs continue to have the same issues they have today. Either way it’s still useful to continue writing code manually. If LLMs don’t get much better than demand for a dev that can actually write robust, secure, and production grade code will be high. If they do get better, then at least I will have refined my taste. I can always learn the advanced prompting/orchestrating skill-set later.

The change

Was this roller-coaster of anxiety pointless? I think the answer goes back to the quote of never letting a good crisis go to waste. I used the stress and anxiety induced by all of this to develop a habit of daily project work and generated a backlog of projects to explore. To try and find alternative approaches to surviving the AI apocalypse I decided to try publishing more writings (which I’ve been enjoying greatly). These have replaced the ways I used to waste my time, which I think is a huge net positive. The biggest change is just genuinely enjoying programming again. I’m no longer spending my cognitive capacity on the soft LLM prompting skills⁵. Instead, I’m working on things I enjoy more like exploring new languages, developing my taste for code architecture, and solving hard technical problems myself.

If you are worried about AI and the links I included above haven’t convinced you otherwise, that’s okay! Just don’t let a good crisis go to waste. Use the motivating power of stress and anxiety to drive you instead of letting it stop you. No matter how things play out, you will be better off!

I wrote a little system called upvoters in Rust to handle anonymous upvotes, and it’s compatible with Hugo! In fact, you should see a little chevron at the bottom of this post to upvote if you like it. Check it out if you need something like it!

Motivation

I’ve been working on some website refactors/design changes lately. My taste has been influenced recently. I may at some point write something about my taste evolution. The tl;dr for that article is that I came across an article on Armin Ronacher’s blog and was hugely affected. I’ve been trying to use my little piece of internet land to serve an aesthetic, technical, and minimal blog and his site is what I wish mine was.

While I don’t have all of Armin’s experience or skills, I thought I could at least try to give off a similar vibe with my own site. I use Hugo to generate my static blog, so my first try was searching through existing Hugo themes to get a starting point. The rest of the story I think works better as an enumeration:

1. Came across the hugo-bearcub theme by clente.
2. Looked up Bear Blog.
3. Looked up the creator of Bear Blog, Herman Martinus.
4. Read through some of his posts and noticed his little anonymous upvote button.
5. Thought the anonymous upvote button was super cool and wanted my own.

Upvoters

I then spent a couple hours putting together upvoters, a little Rust web server to handle this functionality. I picked postgres for the db because I run this site (and a few other services like email, matrix, forgejo, etc…) using a VPS that already had a postgres setup. Probably could’ve just done SQLite to make it easier on everyone but didn’t think about that until later.

This service just tracks votes in a single table with the following important variables in the schema:

1. slug: A unique identifier for each post that is just created from the URL.
2. voter_id: A unique identifier for each voter.

Since this is just a personal blog, and exact upvote count doesn’t matter, the voter_id is a UUID assigned to each user as a cookie upon the first vote. Obviously all it takes to “break” the system is clearing your cookies. This would allow you to upvote the same post multiple times but the only risk there is me getting delusions of grandeur.

Getting started with it

I wrote some instructions in the upvoters readme, but also feel free to email me if you need help setting it up!

I fell for the siren’s song of low effort output

I’ve been wanting to output more content. Main reason is that a lot of people I respect have blogs that span years. I also wanted to share some perspectives I’ve had and issues I’ve resolved in case anyone was ever looking/to keep them as a log. The blog post about CUDA on void linux has been particularly helpful as I’ve set up multiple void linux machines that all had the same issues.

The issue for me was that creating content takes away from other things I could’ve been working on. I thought that this was the point of AI acceleration so I leveraged ChatGPT to help automate the generation of some posts. In most cases I went in and manually edited for style and formatting, but there are many examples of ChatGPT generated sentences that made it to my blog. This helped me to get useful (at least to me) posts out, but in hindsight I don’t think the trade-offs were worth it. What I gained in posting velocity I lost in:

• Posts are not authentic. While I always picked the post topics (No “what should I post” prompts), it’s hard to separate what thoughts are genuinely mine versus what is just background noise added by the LLM. The best example of what I mean comes from image generation models. The tree in a human created painting was placed for a reason and has some kind of meaning. The tree in an image generation model created painting was placed there just because and has no meaning. I kind of feel the same way about LLM generated text.
• I miss on developing my writing skills. I personally think this is the most important reason to not rely on LLMs for writing. I’ve written a lot of academic/technical documents (see publications) but that kind of writing is fake/performative. I’ve been trying to embrace Paul Graham’s write like you talk. Outsourcing to LLMs as a first step means adopting the interpolated average writing style instead of finding my own unique voice and style.

Seeing the light and fighting the slop

What helped me see the light was Mitchell Hashimoto’s writings. In particular his article on vibing a ghostty feature. In it, I found a workflow that made more sense to me. I think I’ve been on the internet too much and was trying to convince myself Gas Town and endless Ralph Loops were actually the future. I haven’t convinced myself yet, and I think I will stop trying to. Instead, I’m going to be more intentional about doing things manually for both the love of it and the skill-set growth potential.

This does not mean I will go back to the “halcyon” pre-AI workflows. LLMs have been transformative for me. I just plan to use them as tools where they belong and not buy the developer –> agent manager transition that is being sold. The exact role of agents in my work is still something that is evolving.

Commitment to ensure all writings on this blog are fully human generated

Moving forward anything I write on this blog will be fully human generated, with some assistance from LLMs. For writing that means using it as an editor to help with tone, structure, and grammatical errors. In general, I also use it as a sounding board to help me develop ideas. Claude-Code and Codex still have a big role to play in automating certain tasks (tedious edits, research on specific topics, even code changes once I know exactly what I want) but I no longer think they should have a primary role in something as personal as publishing my own thoughts.

Will close with the quote that really hit me from Mitchell Hashimoto:

I believe good AI drivers are experts in their domains and utilize AI as an assistant, not a replacement.

Quick Facts

• Father of two and husband of one
• Scientific and Backend Software Developer
• Computational Materials Science PhD from Georgia Tech
• Favorite programming language is Rust 🦀

Technical knowledge

• Programming Languages: Rust, Fortran, Python, C++, Java, Typescript
• Parallel Programming: MPI, OpenMP, Rayon, etc…
• Good at Algorithm design, performance tuning
• AI: Did work with Active Learning and traditional models (small data) before ChatGPT.
• LLMs: Messing around with them, use codex mainly, planning a write up on my thoughts.

Curriculum Vitae

Click here for my CV

What motivated me to try it

I somehow recently accidentally stumbled across the Pillars, Pipelines, and Vaults (PPV) system by August Bradley. In a nutshell, this system is a way to align your daily efforts to the pursuit of goals that contribute to core areas of your life (the pillars). As a husband and the father of a toddler and an infant, the free time that I previously had in excess has been scarce. My routines and schedules were extremely disrupted as I transitioned from my life as a PhD student to working a 9-5 and raising a family (my first child was born exactly one week after my dissertation defense). These routines never truly recovered. As a result, when I do come across some free time I find that I often don’t know what to do with it. I also am guilty of jumping from project to project without focus, leaving things half finished or skills incompletely developed.

I’ve tried a few different methods for improving focus and alignment, but nothing ever really stuck.

I’ve been learning about the PPV system and have noticed some positive effects already. Primarily around self-reflection, ensuring daily tasks are aligned to what is important, and ensuring that my effort towards things important to me is getting tracked. I’m halfway through the PPV playlist and have started building out my personal PPV system. So far I recommend it. I definitely think that it needs per-user customization as I am not August Bradley, and his priorities won’t directly translate to me. But some of the overarching concepts I find extremely useful:

• You should define a small set of “pillars” that hold up your life (e.g. career, family, learning, personal projects, etc…)
• Ensure that your daily actions and goals are aligned to those pillars
• The action zone concept is fairly genius and has certainly led to improved focus for me.

I, of course, am not actually implementing these systems in Notion directly

Instead, I found a FOSS alternative called anytype. I tried some other FOSS options like AppFlowy and AFFiNE. AFFiNE struggled from:

• UI that was cramming in their AI service everywhere, and it couldn’t be disabled.
• Some concerns about how their telemetry works, see this github issue

AppFlowy was pretty clean but I wasn’t able to get the self-hosted AppFlowy-Cloud setup. I’ve yet to self-host a node for anytype. It uses a P2P protocol to synchronize spaces between devices which seems to make the self-hosting more complex. I plan to upload an additional guide if I find it difficult to set-up.

Conclusion

If you haven’t heard about PPV, definitely check it out here! It isn’t for everyone, but I’ve seen the benefits already in my limited time using it. I may do a dive into my personal flavor of PPV and how I deviated from the original once it is fully completed. Hopefully this is helpful to someone!

I’ve been a suckless software user for a long time because the software was superior to a lot of other options out there. If you have never experienced the blazing fast speed of st opening, you are definitely missing out. Sadly it was time for me to leave st behind and move on to a new terminal that I think offers a lot of benefits.

Why I Liked st

• Speed. st launches instantly
• Config as code is cool. That combined with the patching culture really provides some fun puzzles. Who knew reading your terminal source code to fix a broken patch could be so fun.
• DWM swallow patch compatibility. If you use the swallow patch, st works flawlessly.

Why I Switched to ghostty

• Time constraints. Two kids means no time to debug patches and code when I want modern features like ligatures.
• Modern niceties. Ligatures and images in terminal are supported out of the box. I spent way too long trying to unsuccessfully get sixel support in st.
• Cross-platform config. Same configuration file on both Linux and work Mac. Reduces burden of swapping dev environments.
• Swallowing compatibility. Unlike WezTerm and others, ghostty plays nice with DWM’s swallow patch. Since WezTerm uses existing terminals to create new terminals, the process tree for the swallow patch gets messed up. This leads to the wrong terminal windows getting swallowed which is very frustrating.
• Fast enough. Noticeably slower to start than st but faster than everything else I’ve tried.

I definitely think I’m losing cool points by swapping from my handcrafted st build, but priorities change and the ghostty guy is pretty cool. Hopefully this doesn’t commence my slide down the slippery slope straight into an Apple Store shudder.

                ==**=*x=====================ox*=**==xo                                                  
              ox==**=*x                     ox*=**==xo                                                  
            ++**+=                                =+**++                                                
          ====         ~+%$@@@@@@@@@@@@@@$%+~         ====                                              
        ===+       x%@@@@@$$$$$$$$$$$$$$$$@@@@@%x       +===                                            
      ===+      +@@@@$$$$$$$$$$$$$$$$$$$$$$$$$$@@@@+      +===                                          
    ++=+      %@@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@@%      +=++                                        
  ox==      %@@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@@%      ==xx                                      
  ==+x    x@@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@@x    x+==                                      
xx==     %@$$$$@@@@$$$$$$$$$$$$$$$$$$$$@@@@$$$$$$$$$$$$$$@%     ==xo                                    
++++    %@$$$@@+~o=@@@@$$$$$$$$$$$$$$@@+~o*@@@@$$$$$$$$$$$@%    ++++                                    
==+·   x@$$$$$       ~*@@@@$$$$$$$$$$%       o*@@@@$$$$$$$$@x   ·+==                                    
==     @$$$$$$           ~*@@@$$$$$$$%           o%@@@$$$$$$@     ==                                    
==     $$$$$$$@=·            =$$$$$$$@@=             *$$$$$$$     ==                                    
==    ·@$$$$$$$@@@@+          $$$$$$$$$@@@@x          $$$$$$@·    ==                                    
==    ·@$$$$$$@$x            o$$$$$$$@@$x            x$$$$$$@·    ==                                    
==    ·@$$$$$$            x$@@$$$$$$$$            +$@@$$$$$$@·    ==                                    
==    ·@$$$$@$        x%@@@@$$$$$$$$@%        x$@@@@$$$$$$$$@·    ==                                    
==    ·@$$$$$@$~  x%@@@@$$$$$$$$$$$$$@%·  x%@@@@$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$@@@@@@$$$$$$$$$$$$$$$$$$@@@@@@$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ·@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@·    ==                                    
==    ~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$~    ==                                    
==     @@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@@     ==                                    
==+·    %@@@$$$$$$$$@@@$$$@@@@$$$$$$$$@@@@$$$@@@$$$$$$$$@@@%    ·+==                                    
x+==      +$@@@@@@@$+       o%@@@@@@@@*~       =$@@@@@@@$+      ==xx                                    
  ===+                                                        +===                                      
    ====              ==%%++            ++%%==              ====                                        
      ++**=***++==%***==++***%**++++*=%**=++==***%==++**%=**++                                          
          x+++==++++        x+++++==++xx        ++++++++++                                              

Another quick post that may be useful to somebody else. I’ve been working at UKG for about 4 months now. In my work I use a Mac laptop. I’ve tried my best to unify my configurations between my personal Linux system and the Mac dev machine provided by UKG to reduce headaches when having to switch from professional to personal projects. This even went as far as trying to configure OpenBox to be more like the MacOS desktop environment (HA a big failed endeavour). While I ultimately found peace with differences in desktop environments, there was another thing I found very hard to deal with.

Differences in Keybindings!!

I made a lot of changes and compromises when setting up my Mac system and configuring my personal machine. One notable change was swapping my main modkey for dwm from Meta to Alt to better mimic the Mac setup. I tried doing the reverse of swapping Option and Cmd in Mac, but that was a really rough time. I’ve also tried to keep many other keybindings, associated with things like moving windows or changing workspaces, consistent. One thing that was causing endless headaches was copy and paste. I don’t know the exact count of times I’ve pressed Alt+C or Alt+V at home in vain, but it is certainly significant. As a result I spent some time to figure out how to do this.

Final Solution

I configure my dwm specific keybindings in my config.h, but for everything else I use sxhkd. This allows me to more easily reload keybindings instead of having to cycle dwm and lose all of my window placements. I highly recommend this kind of setup. My final solution, added to my sxhkdrc is:

alt + c   
     xclip -selection primary -o | xclip -selection clipboard -i
 alt + v    
     sh -c 'xclip -selection clipboard -o | xclip -selection primary -i && xdotool click 2'

I tried several other ways, most notable being just trying to send Ctrl+C when I pressed Alt+C, but nothing else worked.

How it works

A quick description of how it works:

• Alt+C takes the primary selection and copies it to the clipboard
• Alt+V takes the clipboard and copies it to the primary selection and then emulates a middle mouse button click to paste.

I was hoping for a more elegant solution but ¯_(ツ)_/¯

I run Void Linux on a Thinkpad T480 with Integrated Intel graphics and a discrete Nvidia MX150. I’ve decided to start working with more CUDA development and was running into an issue where my Nvidia GPU would suddenly stop being detected by CUDA applications. The only way I could figure out to get it back online was by rebooting my computer. Eventually I became so frustrated that I decided to dive in and find a solution.

The Problem

Here’s what I was experiencing:

• GPU appeared normal in nvidia-smi
• All NVIDIA kernel modules were loaded correctly
• Device files in /dev/nvidia* existed with proper permissions
• But testing CUDA availability using Pytorch, by running the following command would return FAlSE:

1 python -c "import torch; print(torch.cuda.is_available())"

The root cause was eventually found in the kernel logs (dmesg):

NVRM: Xid (PCI:0000:01:00): 31, pid=1596, name=modprobe, Ch 00000003, 
intr 10000000. MMU Fault: ENGINE HOST6 HUBCLIENT_HOST faulted @ 0x1_01010000. 
Fault is of type FAULT_PDE ACCESS_TYPE_READ

NVRM: Xid (PCI:0000:01:00): 154, GPU recovery action changed from 0x0 (None) 
to 0x2 (Node Reboot Required)

The Root Cause

The issue stems from NVIDIA GPU memory management during sleep/resume cycles. When the system suspends:

1. The GPU’s memory mappings and contexts can become corrupted
2. The GPU’s Memory Management Unit (MMU) enters a faulted state
3. While the driver stack appears to reload correctly, the GPU hardware itself is in an inconsistent state
4. CUDA runtime fails to initialize because it can’t establish proper memory contexts

This seems to be common on mobile NVIDIA GPUs (like the MX series) in laptops with hybrid graphics setups running Linux. At least, I’ve seen a few postings about this.

The Solution

The fix is to add these parameters to your kernel command line in /etc/default/grub:

1GRUB_CMDLINE_LINUX_DEFAULT="... nvidia-drm.modeset=1 nvidia.NVreg_PreserveVideoMemoryAllocations=1"

Then update GRUB:

1sudo update-grub

And reboot to apply the changes.

What These Parameters Do

• nvidia-drm.modeset=1: Enables kernel mode setting for the NVIDIA driver, providing better integration with the display subsystem and more robust power management
• nvidia.NVreg_PreserveVideoMemoryAllocations=1: Tells the NVIDIA driver to preserve GPU memory allocations across suspend/resume cycles, preventing the MMU faults

Why This Works

These parameters ensure that:

1. GPU memory contexts are properly preserved during sleep
2. The kernel’s display management system maintains better control over the GPU state
3. Memory mappings remain consistent across suspend/resume cycles
4. The GPU’s MMU doesn’t enter the faulted state that breaks CUDA

Conclusion

Haven’t had an issue since making this fix! Hopefully someone else can benefit from this as well!

If you know me personally, you know that I’ve been pretty slow on the LLM/GenAI uptake. At this point, however, if you are a software developer that isn’t integrating GenAI tools into your workflow I think you are probably going to be left behind. I’ve been playing around with these tools a lot more lately, and I’ve come to a few conclusions.

1. Models that can be run locally (I’ve used a lot of different Ollama models) are mainly just ok. The best results I’ve had is with Gemma3:27b on an m4 macbook. Haven’t tried qwen3 coder yet.
2. The amazing metrics you see referenced require 100b+ models that are not going to be feasible to run locally for most people.
3. Your application matters a lot. I find that these tools are extremely useful for java spring boot microservices but a lot less useful for scientific projects in Rust.
4. I really enjoy using the expensive LLM tools provided at work and enjoy using the free version of tools less.
5. Claude has given me the best performance so far.

I’m still debating which subscription to get for personal projects. I know Claude is my favorite, but it’s also much more expensive. I also have a newborn right now and not much time for side projects, so I’m delaying the decision.

AI has NOT become an irreplaceable tool

I am not a vibe coder and don’t think I will ever give in to the vibes. Even when I prompt claude code to make changes, I always know exactly what I want done and how I want it done. Many times I’ll make the changes myself because it’s faster than trying to prompt Claude. LLMs have definitely improved my efficiency, but I would be fine if all the GPUs in the world suddenly melted down. I’m not a viber for a couple reasons:

1. I enjoy coding and problem solving.
2. I’m not convinced models are capable enough to be fully trusted.
3. I want to keep my own skillset because the future of AI is uncertain to me

How does the economics of AI work?

From my very limited understanding, the fact that major AI companies are still requiring funding rounds indicates that AI is currently not profitable. That makes sense to me since ChatGPT and Claude are available for free even though inference is certainly not free. I think the significant portion of cost is due to model training. It seems like model training costs won’t be stopping anytime soon as companies race towards general and then “super” intelligence. I’m not convinced either of those are a given. As a result, prices will have to increase or ads will be introduced to recuperate investor money. I’m also not sure how this applies to providers of open weight models. Those prices can seem more reasonable, but are those subsidized as well? Finally, the current datacenter power consumption for model training seems entirely unsustainable. If I recall correctly, Elon Musk is powering some of his datacenters with a constant flow of diesel fuel into generators because he can’t get enough power from the power grid. The scale of everything at the moment seems to border absurdity. I think we are in for a bumpy ride for the next few years as the impact of GenAI technology and infrastructure works itself out.

Please let me know if I’m wrong about anything or with better predictions!

This is a reminder to backup consistently.

Of course after thinking everything went fine, I tried to install a new package and libcrypt ends up getting removed leaving me unable to login to my server. Luckily I had backed up before this which saved all of my bespoke configurations. I’m sure no one noticed the down time but I did use this as an opportunity to make the followjng changes:

• matrix-synapse upgrade to dendrite for better performance.
• Gitea to forgejo just to try something different.
• Properly set up actions to auto build and deploy site on push.
• Rework website and swap to the terminal hugo theme

So far, I have positive opinions of all of my changes and highly recommend dendrite and forgejo.

Note to self: Never consider it upgrading Debian version. Always structure it as a migration to newer Debian version to avoid downtime

1. Download the installation files: Go to the CUDA toolkit installation website. Select Linux->x86_64->Debian->11->runfile (local)
2. Set executable permission: chmod +x ./cuda_version.run
3. Install using the correct flags:

   1sudo ./cuda_11.8.0_520.61.05_linux.run --silent --override --toolkit --no-opengl-libs --tmpdir=/home/aselimov/down/tmp

4. Add to path: Build should now be installed at /usr/local/cuda-version. Add the following to your bashrc or zshrc:

   1export PATH="$PATH:/usr/local/cuda-version/bin"
   2export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda-version/lib64"

The reason I had to add the --tmpdir command was because I was getting an error message about the default tmp directory not having enough space. Hopefully this helps someone else out!

Problem 1: jdtls exiting with status code 13

I use jdtls through Mason with the built in nvim LSP and was recently having an issue where jdtls would immediately crash when opening a file. The solution to this problem was just deleting the cache for jdtls:

1rm ~/.cache/jdtls

Edit 05/14/2024: This also solves the problem of jdtls not attaching on neovim startup. May solve other problems as well, so should be first thing to try if jdtls isn’t working.

Problem 2: Could not set executable permissions for .gradle

When attempting to build with a gradlew script I was running into the following error:

Could not set executable permissions for: ~/.gradle/wrapper/dists/gradle-7.6-bin/9l9tetv7ltxvx3i8an4pb86ye/gradle-7.6/bin/gradle

After spending some time trying to find a solution, I found a suggestion of setting an environment variable:

1 export JAVA_TOOL_OPTIONS="-Djdk.lang.Process.launchMechanism=vfork"

The above environment variable was all I needed and the gradle script was able to assemble the project successfully. Hopefully this is helpful to someone!

1. Just Works™ build system and crates.io makes drawing in libraries painless
2. Guaranteed memory safety is pretty nice
3. Syntax is much cleaner and succinct than C++, with lots of nice syntax sugar to sweeten the package
4. Easily integrable with C (and therefore C++ with some massaging)
5. Proc macros are pretty nice as well
6. Built-in test framework

I think that point 3 is potentially the biggest factor for me as the C++ modern syntax is not what I would consider clean, especially if you are trying to use a more functional programming style. A simple example highlighting the difference:

C++

1vector<int> v(10,1);
2std::transform(v.cbegin(), v.cend(), v.begin(), [](int value){ value + 1;})

Rust

1let v = vec![1;10];
2let v = v.map(|val| val + 1).collect()

I think that speaks for itself…(Although I prefer the C++ lambdas which don’t auto capture)

I’m not sure that I consider myself a Rustacean though as some seemingly simple programming tasks can become huge mountains due to the borrow rules Rust enforces. Once you learn the borrow rules and some of the tricks, the language itself ends up being very clean to write and easy to test. I probably won’t be writing C++ in the future unless I have a very specific/niche reason to. I recommend checking Rust out if you haven’t yet, it may surprise you!

tmux setup

As a note, all of the below settings should be added to your ~/.tmux.conf if you are interested in using them.

Some nice settings

I wanted to start out with some nice settings for tmux that I generally like. First and foremost I remap the send-prefix key.

unbind C-b
set -g prefix C-p
bind C-p send-prefix

I also rebind the pane splitting commands:

bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"
unbind '"'
unbind %

And finally, I enable vim key binds in scrolling mode

set-window-option -g mode-keys vi
bind-key -T copy-mode-vi v send -X begin-selection
bind-key -T copy-mode-vi V send -X select-line
bind-key -T copy-mode-vi y send -X copy-pipe-and-cancel 'xclip -in -selection clipboard'

Integration with neovim

Here by integration, I mean seamlessly transitioning between tmux and neovim splits. To do this we want tmux to figure out if the current tmux split contains a vim process (and potential vim splits). We then can then bind the same motion keys in tmux and nvim so that we can seamlessly move from a tmux split into a vim split and back all using the same keys! We can do this with the following code snippet in our ~/.tmux.conf.

is_vim="ps -o state= -o comm= -t '#{pane_tty}' \
    | grep -iqE '^[^TXZ ]+ +(\\S+\\/)?g?(view|n?vim?x?)(diff)?$'"

bind-key -n C-h  if-shell  "$is_vim"  "send-keys C-h"  "select-pane -L"
bind-key -n C-j   if-shell  "$is_vim"  "send-keys C-j"   "select-pane -D"
bind-key -n C-k  if-shell  "$is_vim"  "send-keys C-k"  "select-pane -U"
bind-key -n C-l   if-shell  "$is_vim"  "send-keys C-l"   "select-pane -R"
bind-key -n C-\   if-shell  "$is_vim"  "send-keys C-\\"  "select-pane -l"

is_vim defines a command to determine whether the current pane is running vim. If so, we send the key codes directly to vim, otherwise process the key binding with tmux. For this case we utilize <C-{vim_keys}> for motion to make things easy.

Neovim setup

Now we need to make sure we can go from a neovim split smoothly to a tmux split. To do this we utilize the christoomey/vim-tmux-navigator plugin. First add it to your plugin manager,

Lazy.nvim:

require("lazy").setup({
    "christoomey/vim-tmux-navigator"
})

or Vim-plug:

call plug#begin('~/.vim/plugged')
    Plug 'christoomey/vim-tmux-navigator'
call plug#end()

and that’s it! It should automatically add the <C-{vim_keys}> for motion and handle moving out of vim splits to tmux panes. Hopefully this is useful to someone else!

Bonus

Gruvbox is everywhere even tmux gets a nice theme.

Problems with Artix

The biggest reason for me leaving Artix was an issue of stability/compatibility. I have a previous post describing one issue that I ran into regarding incompatibility between the Artix debuginfod server and their shipped glibc version. In general, after 2/3 years Artix gives me the impression of simply a patched version of Arch linux to remove systemd instead of it’s own OS. Package compatibility sometimes has issues when Arch linux core repositories move slightly ahead of Artix linux core repositories. For the most part, Artix Linux ran very well but towards the end of my time with it I found significant accumulated debt on my system with mixtures of Artix and Arch packages which lead to annoying configuration problems that took way too much time to fix. After being unsuccessful in addressing some issues and with fresh installs for some reason having issues on my systems, I decided I need to figure out something new.

Void Linux saves the day

This is when Void Linux came in to save the day. I find that void offers a few benefits over Artix Linux:

• Stability- VoidLinux in my experience has been much more stable over updates than either Artix or Arch.
• Vision - Not sure if vision is the right word, but void linux is an independent OS not forked from any other. As a result the OS feels more cohesive as it doesn’t have to deal with conflicting visions.
• Package Manger - XBPS is an extremely fast and easy to use package manager.
• Init System - runit was my preferred init system on Artix, and finding an OS which defaults to runit is a positive indication for me.

The obvious issues with void are:

• No AUR
• Less documentation, arch linux guide works most but not all of the times

I’ve found that in practice, I do not significantly miss the AUR as any software I need is packaged in the void repositories. For the very rare cases that the software I need is not packaged, I can just clone the software repo and build/install from source. The documentation factor is a little bit of a bigger deal. There have been a few cases where I’ve spent far too much time trying to address some seemingly basic configuration because of lack of documentation. This doesn’t bother me as much as the issues I had with Artix as the time I spent is learning how to use Void Linux, familiarity with your tools, as opposed to trying to bandage broken systems. If you install a desktop environment such as KDE or Gnome, you probably won’t run into this issue as much as I did.

Overall I find that the following meme captures my current feelings pretty well:

Hopefully this is helpful to someone else as I personally have not regretted my switch for a moment.

What should’ve worked but didn’t

Artix linux is hosting a debuginfod server at https://debuginfod.artixlinux.org. They have this set up so that you can add it to your /etc/pacman.conf as a custom repository. All you have to do is append:

[system-debug]
Server = https://debuginfod.artixlinux.org/$repo/os/$arch
[world-debug]
Server = https://debuginfod.artixlinux.org/$repo/os/$arch
[galaxy-debug]
Server = https://debuginfod.artixlinux.org/$repo/os/$arch
[lib32-debug]
Server = https://debuginfod.artixlinux.org/$repo/os/$arch

to the bottom of the file, run a quick pacman -Syu, and then you should be good to go. The issue that I ran into was that the debug package for glibc was old compared to the version of glibc I had installed. This meant that even though I had the glibc-debug package, valgrind still didn’t work. My only gripe with the Artix Linux team is that if you are going to switch to a debuginfod setup and not allow us to install packages from the core repositories that have debug symbols enabled, please at least keep it up to date with the other core repositories.

What does work and isn’t ideal

Once the Artix specific solution didn’t work, I switched over to figuring out the more general Arch Linux solution with the hope that it didn’t involve systemd. It turns out that the Arch Linux team has not exposed their debug repositories the same way that the Artix Linux team has which means you have to dig a little bit more. I ended up finding in the Arch Linux wiki, that there are Arch Linux sponsored mirrors which contain the debug packages. To enable these you just add:

[core-debug]
Server = https://geo.mirror.pkgbuild.com/$repo/os/$arch
[extra-debug]
Include = https://geo.mirror.pkgbuild.com/$repo/os/$arch

[multilib-debug]
Include = https://geo.mirror.pkgbuild.com/$repo/os/$arch

to the bottom of your /etc/pacman.conf. Now you are actually good to update with pacman -Syu and install debug symbols for glibc, pacman -S glibc-debug. Just watch out for incompatible versions again. It may be that on another upgrade, Arch linux will move further ahead on the debug package version number than the Artix Linux version of glibc. A workaround for this is to just install glibc from the Arch Linux [core] repository from https://geo.mirror.pkgbuild.com instead of the [system] repository on Artix. Be warned though that this might mess up other Artix programs which depend on the current Artix version of glibc. For now I’ve left it this way so I can get back to figuring out CUDA. Hopefully this helps someone out, happy valgrinding!

content
    |-- section1
            |--_index.md
            |--section1Post.md
    |-- section2
            |--_index.md
            |--section2Post.md
    |-- section3
            |--_index.md

In my header partial I created a menu by looping over the entries in [[menu.main]] defined in the hugo.toml. It’s important here to end the url with a /. Hugo adds an ending /, to the urls of the pages that it creates. While this might not be necessary to make the hyperlink work, it will be necessary to get the highlighting correct. The definition of the menu looks like:

[menu]
  [[menu.main]]
    name= "section1"
    url= "/section1/"
    weight= "1"
  [[menu.main]]
    name= "section2"
    url= "/section2/"
    weight= "2"
  [[menu.main]]
    name= "section3"
    url= "/section3/"
    weight= "3"

The original header partial is pretty simple. I just loop over the range .Site.Menus.main and insert a <div class="item"> which is my div class for a navbar menu item. I populate the text and link from the variables associated with the main menu item. This is all wrapped within a <nav> element with other items and stylings that create the overall navigation menu. The loop for insertion of menu items is below:

{{ range .Site.Menus.main }} 
    <div class="item">
            <a href="{{ .URL }}">
                {{ $text := print .Name | safeHTML }}
                {{ $text }}
            </a>
        </div>
{{ end }}

As I mentioned before, there were a few different solutions but the one I went with was to save the menu item url and the current page url into two separate variables. I can then compare these to determine whether the current page corresponds to a menu item and if so I change the class of the div from a normal menu item to the activated menu item class. This concept can be seen in action in the following code snippet:

{{ $currentPage := . }}
{{ range .Site.Menus.main }} 
    {{ $menu_item_url := .URL | relLangURL }}
    {{ $page_url:= $currentPage.RelPermalink | relLangURL }}
    <div 
         {{ if eq $menu_item_url $page_url }}
            class="active-item"
    {{else}}
            class="item"
    {{ end }}
    >
            <a href="{{ .URL }}">
                {{ $text := print .Name | safeHTML }}
                {{ $text }}
            </a>
        </div>
{{ end }}

I hope that this is helpful to somebody else as it took me a decent amount of time to try the different recommended methods before I found this one. As always shoot me an email if you have any thoughts or comments!

Setting up the database

I already use PostgreSQL to manage my matrix-synapse database and configured Gitea to use the same. First, following the Gitea documentation, I set the listen_address and password_encryption in my postgresql.conf at /etc/postgresql/11/main/postgresql.conf:

listen_addresses = 'localhost, 203.0.113.3'
password_encryption = scram-sha-256

You should then restart PostgreSQL. Now you can log into the database console:

su -c "psql" - postgres

Then create a database user, gitea:

CREATE ROLE gitea WITH LOGIN PASSWORD '{ReplaceWithStrongPassword}';

Then you can actually create your gitea database:

CREATE DATABASE giteadb WITH OWNER gitea TEMPLATE template0 ENCODING UTF8 LC_COLLATE 'en_US.UTF-8' LC_CTYPE 'en_US.UTF-8';

The last step is adding authentication rules to your pg_hba.conf at /etc/postgresql/11/main/pg_hba.conf. As a note, the following line should be added near the top of this file as authentication rules are evaluated sequentially. As a result, any generic rule at the top of this file may be used instead of the inserted rule if not inserted first.

local   giteadb gitea   scram-sha-256

Installing and setting up gitea

Since my server is on debian, I didn’t have access to a gitea package. Instead, I downloaded the executable:

wget -O gitea https://dl.gitea.com/gitea/1.18.5/gitea-1.18.5-linux-amd64
chmod +x gitea

You should then create a git user account on your server:

adduser \
   --system \
   --shell /bin/bash \
   --gecos 'Git Version Control' \
   --group \
   --disabled-password \
   --home /home/git \
   git

A few directories need to be created for gitea and file permissions set:

mkdir -p /var/lib/gitea/{custom,data,log}
chown -R git:git /var/lib/gitea/
chmod -R 750 /var/lib/gitea/
mkdir /etc/gitea
chown root:git /etc/gitea
chmod 770 /etc/gitea

You can then copy gitea to a directory on your path, i.e.:

cp gitea /usr/local/bin/gitea

The last step for setting up gitea is downloading the example systemd service file and placing that in /etc/systemd/system. At this point you should be able to enable and start the service:

sudo systemctl enable gitea
sudo systemctl start gitea

Gitea and Nginx configuration

There are a few configurations options you need to set for Gitea and Nginx that I’ll outline here. First as a note, I wanted my git server to be accessible at alexselimov.com/git. It’s possible to set gitea up as a subdomain, i.e. git.some.site, but I won’t go into that. First you want to configure nginx so you can access your Gitea instance. You can also simply go to your.web.site:3000 to skip the Nginx configuration. Adding Gitea at your.web.site/git is extremely simple and if you have SSL certificates with certbot, access to your Gitea instance will also occur over HTTPS. All you have to do is add:

location /git/{
        proxy_pass http://localhost:3000/;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
}

in your primary server block for your website. Now if you restart Nginx you should be able to navigate to your.web.site/git. The first time you access your Gitea instance, it will ask you several configuration questions which then populate the default configuration file for Gitea that you can then adjust. Answer to the best of your knowledge and then we will go over the most important ones in your configuration file.

Gitea configurations are available in the /etc/gitea/app.ini file. You want to double check that your [database] section is correct, especially the NAME variable.

[database]
DB_TYPE  = postgres
HOST     = 127.0.0.1
NAME     = giteadb
USER     = gitea
PASSWD   = '{SOME SECURE PASSWORD}'

If you want you can set your default branch name in the [repository] section:

[repository]
DEFAULT_BRANCH = master

Finally to make sure your site works properly, you want to go to your [server] section and make sure that [SSH_DOMAIN] is set to the domain that you use to ssh into your server. For example, I ssh into alexselimov.com so my app.ini has:

[server]
SSH_DOMAIN = alexselimov.com

Your ROOT_URL should however be set to the url that maps to your Gitea instance, i.e.,

ROOT_URL = https://alexselimov.com/git

To finish setting up ssh, you just have to add your public key to your user account in the Gitea under settings->SSH/GPG keys. Then as site admin you have to go to the Site Administration menu and run the “Update the ‘.ssh/authorized_keys’ file with Gitea SSH keys.” option. At this point you should be good to go with Gitea and using ssh to access your repositories. The final option I though was useful was:

[sevice]
DISABLE_REGISTRATION = true

I am making this repo for personal use. Disabling registration still allows people to clone my public repositories, but I want to be sure that I screen potential contributors or other people that can have accounts on my instance.

Conclusion

I hope these instructions were useful to someone, let me know if I missed a step or got something wrong and I’ll be sure to correct it. Thanks for reading!

Assume I have a git repo as below:

test
├── README.md
├── main.cpp
├── test.cpp
└── test.h

If I wanted to pull out the test.cpp and test.h files on their own with all the history for only those commits, the command is:

$ git filter-branch --force  --prune-empty --index-filter \
 'git rm --cached --ignore-unmatch $(git ls-files | grep -v "test.h\|test.cpp")'

A couple notes should be mentioned. First when you run the git filter-branch command it will give you a message saying that you shouldn’t use filter-branch and should instead use filter-repo. I don’t know how to do this with filter-repo and didn’t have the time to figure it out. The --prune-empty flag deletes all the commits that aren’t associated with the files of interest so that you don’t have to do a rebase. Finally to specify the files you want, you need to pass them to the grep command as:

grep -v "file1\|file2\|file3"

The -v flag inverts the match, returning all files to the git rm command which don’t match the files you specify. The file names must be separated with \| for matching multiple different tokens. Once this command completes, you should be left with just the files of interest and the associated history. All that’s left is simply setting a new remote url and then push, i.e.

$ git remote set-url origin submodule.git.url
$ git push

Final Important Note: If this goes wrong you may get worried as all of your git history is wiped out. To fix this you can use git reflog. If you run git reflog after you mess up the git filter-branch you should see something like this (dummy commits from my fake repo):

$ git reflog
790c883 (HEAD -> master) HEAD@{0}: filter-branch: rewrite
3b3c8b8 HEAD@{1}: commit: Update test library
93cfbd4 HEAD@{2}: commit: Add main function
18259bc HEAD@{3}: commit: README update
aba8323 HEAD@{4}: commit: init test files

You can then reset your git repo to a state before your filter branch command by running:

$ git reset --hard HEAD@{1}

Hopefully this helps someone out!

If you want to check out how it looks like on my site before we get started, just shrink the width of your browser!

Fundamental approach

I decided that the simplest way to do what I wanted, was to design two completely separate navigation bars. One is used for larger screen widths while the other is used for smaller screen widths. This might not be the most elegant method but it certainly is simple. The <nav class="primary">, which is the default navigation bar, is therefore styled using the following code (excluding all actual styling code):

nav.primary{
    display: flex;
}

@media screen and (max-width: 768px){
    nav.primary{
        display: none;
    }
}

Now that we have briefly touched the primary navigation bar, let’s move on to styling the mobile navigation bar.

Designing a mobile navigation bar

The mobile navigation menu that I am using is simple. What I wanted was a menu with items that would reveal itself after the user clicks the hamburger menu icon. To start, we need to style a menu that is hidden. The CSS for this menu is:

nav.mobile{
    transition: left 0.4s ease;
    position: fixed;
    top: 0;
    left: -50%;
    width: 50%;
    height: 100%;
    background: #665c54;
    z-index: 9999;
}

The z-index, height, top, width, and background properties create a rectangular block that is laid over the site. The transition property allows for smooth sliding when we move this element around when we open the menu. The final important property here is that we set left:-50% to hide the menu. We can then easily add items to this menu using a list, or just an item div (which is what I prefer) i.e.

nav.mobile .mobile-item{
    margin: 20px 10px;
}

Creating a hamburger menu icon to open our menu

Now we need an icon that we can click to open our menu. It turns out that it is possible to create a hamburger menu just using html and CSS. We won’t need Font Awesome for this. The html code for the hamburger menu is:

<div class="hamburger" id="Ham">
    <div class = "bars" >
        <span class="bar"></span>
        <span class="bar"></span>
        <span class="bar"></span>
    </div>
</div>

We put our <span class='bar'> inside of a <div class = "hamburger">. By default we have <div class="hamburger" hidden while the <span class="bar"> is what actually forms the icon. The CSS code for this is:

.hamburger {
    display: none;
}

.bar {
    display: block;
    width: 25px;
    height: 3px;
    margin: 5px auto;
    -webkit-transition: all 0.3s ease-in-out;
    transition: all 0.3s ease-in-out;
    background-color: #FFF;
}

.bars{
    display : block;
    position: absolute; 
    top: 20%; 
    left: 20%;
}

I was not able to create a close symbol that looked nice so I ended up using Font Awesome as shown below:

html:
<div class = "hamburger">
    ....
    <div class = "close">
        <i class="fa-solid fa-xmark fa-2x"></i>
    </div>
</div>

CSS:
close{
    display: none;
}

It should be noted that <div class="hamburger">, contains both <div class="bars"> and <div class="close">. This icon is activated at smaller screen sizes, i.e.

@media screen and (max-width: 768px) {
    .hamburger{
        display: block;
        margin: 20px 0;
        position: fixed;
        top: 15px;
        left: 45px;
        height: 45px;
        width: 45px;
        text-align: center;
        border-radius: 3px;
        cursor: pointer;
        transition: left 0.4s ease;
        background-color: #696969;
        z-index: 9999;
}

Opening the menu using javascript

Now that we have a hidden menu and the hamburger icon to open it, we need to add a javascript function that activates on click. I won’t describe how to link .js files, this is a pretty simple thing to look up. To enable our responsive menu, we need one javascript function described below.

/* Toggle between adding and removing the "responsive" class to 
the nav when the user clicks on the icon */

function myFunction() {
    var x = document.getElementById("Nav");
    if (x.className === "primary") {
      x.className += " responsive";
    } else {
      x.className = "primary";
    }
    var x = document.getElementById("Ham");
    if (x.className === "hamburger") {
      x.className += " responsive";
    } else {
      x.className = "hamburger";
    }

    var children = x.children;
     if (children[0].className === "bars") {
      children[0].className += " responsive";
    } else {
      children[0].className = "bars";
    }     
     if (children[1].className === "close") {
      children[1].className += " responsive";
    } else {
      children[1].className = "close";
    }     

    var x = document.getElementById("Navmobile");
    if (x.className === "mobile") {
      x.className += " responsive";
    } else {
      x.className = "mobile";
    }

}

This function simply toggles the class of the divs that comprise our mobile navigation menu. By default, these divs start out with just a mobile class. This function then adds the responsive class when called. If the class already has the responsive class, it removes it. We can then define additional styling for the responsive elements. The most obvious step of opening the menu can be done simply by setting the left margin to 0, i.e:

nav.mobile.responsive {
    left: 0;
}

As a note we also want to adjust the hamburger menu to a red close symbol by changing the position and color of the menu and also setting display none to the bars which make up the original hamburger menu.

.hamburger.responsive{
    left: 55%;
    cursor: pointer;
    background-color: #ff6347;
}

.bars.responsive{
    display: none;
}

.close.responsive{
    display: block;
    color: #FFF;
    position: absolute;
    top: 4px;
    left: 10px;
}

I am certainly not an expert in javascript and am self-taught in html and css so this code might not be optimized, but it gets the job done and makes me happy!

Conclusion

Hopefully this is helpful to someone. I figure I’m probably just tossing this into the void but maybe it will end up being useful to someone. If you have any comments or find any errors shoot me an email! Would love to know if anyone actually is using this stuff.

In my time online I once came across a talk titled The Website Obesity Crisis. Since I’m already obsessed with minimalist systems, obligatory “I use Artix Linux and run dwm,” I internalized everything immediately and searched for the best way to design a modern and actually minimalist website (both design and size). I decided to try and serve a website which followed the design paradigm of the web pyramid graphic shown below:

I found that using Hugo combined with the Skeleton CSS boilerplate was the solution to a modern, minimalist, and “responsive” website. Read on to learn how I did it!

Website design paradigm

The rest of this article describes the different components and how I’ve adjusted them to suit my purposes. There exist a plethora of themes with complex Hugo shortcodes that allow easy customization from the config files. My personal site’s Hugo theme does not bother with attempting to offer endless customization options. Instead, if you want to use this theme you should be ready to adjust the CSS files and the Hugo HTML templates. With that in mind let’s get started.

Skeleton CSS

The most important component of this site is Skeleton CSS, which is a simple CSS boilerplate that serves as the foundation of my site. Detailed documentation can be found at the link previously mentioned but I’ll describe the layout succinctly. The fundamental container that everything should go into is <div class=container> which responsively scales it’s width based on the size of the browser/screen. The next important div is <div class='row'> which is a row that contains the<div class="columns">. This layout is shown below:

<div class="container">
|   <div class="row">
|   |   <div class="columns">

The Skeleton CSS grid has 12 columns, you can specify the number of columns by changing the class, e.g. <div class="one column", <div class="two columns">, ,<div class="eleven columns">, etc. These divs will automatically stack instead of being shown side by side when the browser gets small enough, enabling a nice responsive layout. I use this whenever I need to place items horizontally.

Note: You have to add:

<meta name="viewport" content="width=device-width, initial-scale=1">

to get this working properly for mobile devices.

Notes on some CSS styling I use

I won’t go into too much detail into the styling that I use, but I do want to mention a few things. First, if you want to learn how I wrote the responsive, navigation menu that I use for mobile, see my other post. The colors for my website are selected from the Gruvbox color scheme, shown below:

Since I probably am the only person that will actually be browsing my website, I want some sort of consistency between my terminal and my site. For fonts, I decided to copy Sakura CSS since those fonts looked very nice. If you have any questions about how I style a specific element shoot me an email or just read through the css stylesheet!

Using Hugo to fill in content

Now here comes the final step, which is utilizing Hugo. I again won’t write the full guide on how to use Hugo. You can check out the official Hugo guide for how to setup Hugo and some basic concepts. You can also check out the intro to Hugo by Luke Smith. I didn’t actually use this video to learn Hugo, but his stuff is usually pretty good so if video format works better for you maybe you can try that. The primary uses I have for Hugo are:

1. Listing posts
2. Tagging
3. Table of Contents

To me these three topics are the biggest strengths of Hugo and justify the hours spent learning this new technology. So lets address each of these in order:

1. Listing posts

By default, for each of the directories containing .md files (such as content/posts) Hugo will create a list page containing all posts within that directory. If you click on either the “Posts” or “Recipes” link at the top of this website you will see what such a page looks like. The one thing that wasn’t as clear was how to include something like your five most recent posts on the front page. I had the additional requirement that I only wanted posts from the actual “Posts” directory and not all posts from my site. Specifically I didn’t want my homepage including my latest recipes. The solution is pretty simple, is shown below, and should be included in your base index.html at /path/to/site/themes/{theme}/layout/index.html:

{{ range ( where .Site.RegularPages "Type" "posts" | first 5 ) }}
       <a href="{{ .Permalink }}">
           <h4>{{ .Params.title }}</h4>
           <p style="font-size:1.6rem">{{ dateFormat "Jan 2, 2006" .Date }} </p>
           <p style="font-size:1.8rem">{{.Summary }}</p>
       </a>
{{end}}

You will notice that the important part is the range statement which selects only pages with Type "posts" and selects the first five of them. The rest of the code pulls out the various frontmatter of the post being display. I like to show the date of the post as well as a brief summary.

2. Tagging

The full guide to taxonomies is on the Hugo site. I use two types of taxonomies that I define in my config.yaml:

taxonomies:
  tag: "tags"
  topic: "topics"

The format for a taxonomy is that you have to specify the taxonomy as the key and the plural of the taxonomy as the value. I use the tags taxonomy for organizing my recipes and the topics taxonomy to organize my posts. You can list all values for a specific taxonomy in the list page by including the following code in your list.html for the specific topic. Each value for the taxonomy will link to a page that lists all post with that specific value. The example below lists the topics taxonomy for my posts, so this is included in list.html at themes/personal/layout/posts/list.html:

{{ range .Site.Taxonomies.topics }}
    <a href="{{ .Page.Permalink }}">{{ .Page.Title }}</a> {{ .Count }} ·
{{ end }}

3. Table of Contents

This is another neat little feature that I really enjoy from Hugo. First, I always use ## to denote section headings while # is used only for the page title. To ensure the Hugo table of contents captures the hierarchy correctly, I set the following code in my config.yaml:

markup: 
tableOfContents:
  startLevel: 2

The table of contents command creates a <nav Id="TableOfContents"> element which you can then style. I also want the table of contents to show only when I have toc: true in the pages frontmatter. This can be done pretty simply by adding the following code to your single.html:

{{ if .Params.toc }}
    {{ .TableOfContents }}
{{ end }}

Conclusions

I hope that this provides a decent enough introduction into what I’m using to keep my site looking modern while remaining minimal with regards to size. If you haven’t heard of Skeleton CSS before, you should definitely check it out in more detail, especially if you are linking to create a simple and responsive site that isn’t full of endless bloat like some of these bigger CSS frameworks. I also highly recommend Hugo to generate static sites as it has a lot of useful functionality. As always, shoot me an email with any thoughts, comments, or to point out my mistakes. Thanks for reading!

“Effects of interdiffusion on shear response of semi-coherent {111} interfaces in Ni/Cu”

which was conducted using XSEDE allocation TG-MSS150010. XSEDE resources were critical for running these simulations as it required significant computational resources.

Headings

The following HTML <h1>—<h6> elements represent six levels of section headings. <h1> is the highest section level while <h6> is the lowest.

H1

H2

H3

H4

H5

H6

Paragraph

Xerum, quo qui aut unt expliquam qui dolut labo. Aque venitatiusda cum, voluptionse latur sitiae dolessi aut parist aut dollo enim qui voluptate ma dolestendit peritin re plis aut quas inctum laceat est volestemque commosa as cus endigna tectur, offic to cor sequas etum rerum idem sintibus eiur? Quianimin porecus evelectur, cum que nis nust voloribus ratem aut omnimi, sitatur? Quiatem. Nam, omnis sum am facea corem alique molestrunt et eos evelece arcillit ut aut eos eos nus, sin conecerem erum fuga. Ri oditatquam, ad quibus unda veliamenimin cusam et facea ipsamus es exerum sitate dolores editium rerore eost, temped molorro ratiae volorro te reribus dolorer sperchicium faceata tiustia prat.

Itatur? Quiatae cullecum rem ent aut odis in re eossequodi nonsequ idebis ne sapicia is sinveli squiatum, core et que aut hariosam ex eat.

Images

Figure with a caption

Blockquotes

The blockquote element represents content that is quoted from another source, optionally with a citation which must be within a footer or cite element, and optionally with in-line changes such as annotations and abbreviations.

Blockquote without attribution

Tiam, ad mint andaepu dandae nostion secatur sequo quae. Note that you can use Markdown syntax within a blockquote.

Blockquote with attribution

Don’t communicate by sharing memory, share memory by communicating.
— Rob Pike¹

Buttons and links

Button Link Link

Tables

Tables aren’t part of the core Markdown spec, but Hugo supports supports them out-of-the-box.

Inline Markdown within tables

Forms

Code Blocks

Code block with backticks

 1<!doctype html>
 2<html lang="en">
 3<head>
 4  <meta charset="utf-8">
 5  <title>Example HTML5 Document</title>
 6</head>
 7<body>
 8  <p>Test</p>
 9</body>
10</html>

Code block indented with four spaces

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Example HTML5 Document</title>
</head>
<body>
  <p>Test</p>
</body>
</html>

Code block with Hugo’s internal highlight shortcode

 1<!doctype html>
 2<html lang="en">
 3<head>
 4  <meta charset="utf-8">
 5  <title>Example HTML5 Document</title>
 6</head>
 7<body>
 8  <p>Test</p>
 9</body>
10</html>

Code block with custom built-in {{ < code > }} shortcode

Hey, this is a code block title

 1pre {
 2  background: #1a1a1d;
 3  padding: 20px;
 4  border-radius: 8px;
 5  font-size: 1rem;
 6  overflow: auto;
 7
 8  @media (--phone) {
 9    white-space: pre-wrap;
10    word-wrap: break-word;
11  }
12
13  code {
14    background: none !important;
15    color: #ccc;
16    padding: 0;
17    font-size: inherit;
18  }
19}

List Types

Ordered List

1. First item
2. Second item
3. Third item

Unordered List

• List item
• Another item
• And another item

Nested list

• Fruit
  • Apple
  • Orange
  • Banana
• Dairy
  • Milk
  • Cheese

Other Elements — abbr, sub, sup, kbd, mark

GIF is a bitmap image format.

H₂O

Xⁿ + Yⁿ = Zⁿ

Press CTRL+ALT+Delete to end the session.

Most salamanders are nocturnal, and hunt for insects, worms, and other small creatures.

Scientific

• CAC ← Implementation of the Concurrent Atomistic Continuum method
• CACmb ← Model builder for CAC (inspired by atomsk)

Random

• neovim configs
• PaperPicker ← Use local llms to find relevant arxiv papers
• upvoters ← Rust backend with postgres to handle anonymous upvotes on this blog