HNHacker News
TopNewBestAskShowJobs

lemonwaterlime

375 karma · joined September 16, 2023

submissionscomments
lemonwaterlime··on Ask HN: How to find intellectually challenging work?
If I want to do numerical computing (to solve a problem that needs it), which languages should I consider? Which should I not? Is any language appropriate?

Which languages do you reach for most often (whatever the reason for doing so)?

lemonwaterlime··on Ask HN: How to find intellectually challenging work?
I've seen small shops doing, for instance, deep tech work in physics. Their problem is big and their team is small.

Some questions for you:

Would you say every programming language is fungible? If so, then why are there so many? How many should there be?

lemonwaterlime··on Ask HN: How to find intellectually challenging work?
It is not implied that using Haskell is the only way to find deep problems. The other way around is that shops using a language like Haskell are likely also invested to thinking deeply about problems. So the causality is the other way around.

The recommendation to look for Haskell shops is exactly a heuristic for the thing you recommend:

> "work at a place that has problems that are deep enough to warrant deep dives."

There are many ways to find such places. Filtering by tech stack is one possible way of many to search for signal.

lemonwaterlime··on Ask HN: How to find intellectually challenging work?
Then I would not recommend starting a company with Haskell as the language.

If you do want to eventually get a role using Haskell (which are rare), it is a good strategy to pick some commercial thing and implement it in Haskell. For instance, do a CRUD app using a postgresql app like Esqueleto/Persistent, Opaleye, etc. Or make a web app with Yesod (or even Scotty or Servant).

lemonwaterlime··on Ask HN: How to find intellectually challenging work?
In my case, I am already proficient in Haskell, so I do not have to learn it. Using the technology I already know means not blowing my "novelty budget".

As for benefits, I get the following:

- strong, static typing via the Hindley-Milner type system

That means any changes to my logic and type signatures have to be addressed immediately everywhere.

- type-safe, composable everything

I want as many issues as possible to be caught at compile time. Ideally, I would have no runtime errors. It is possible to get close to this ideal with Haskell.

- terse, expressive language

Less code to read per concept expressed plus a strong type system means that maintenance and refactoring is a breeze. In fact, I can fearlessly refactor. That means once I get everything up and running, the codebase is stable even when I change things. Thus, I can actually focus more on the product and customer needs.

Combining all of the above with other stable and maintainable technology choices makes the entire app architecture easy to maintain over time as well.

You always have to consider the technology so you can properly architect your application and its dependencies.

lemonwaterlime··on Ask HN: How to find intellectually challenging work?
I was going to recommend you look for a Haskell shop and the saw that user markus_zhang mentioned the same thing in this thread.

I'm actually just starting my own company using Haskell so I can think deeply about what I want while making the product how I want.

lemonwaterlime··on Tmux – The Essentials (2019)
I'm a fan of "How to configure tmux from scratch" [1]

[1]: https://ianthehenry.com/posts/how-to-configure-tmux/

lemonwaterlime··on Vim after Bram: a core maintainer on how they've kept it going
vim is stable and consistent. I vendor what plugins I do use with git submodules and everything just works for years and years.

LSP integration works as well as a given language engine has implemented it. I’ve got an autocmd group that automatically binds keys if that language’s corresponding LSP compiler is on my system. So with something like Rust or Go, I open the file and just go (no pun intended).

When I am trying out a new language, I just add a few configuration lines to my vimrc and all the bindings work automatically.

For non-LSP langs (or those with heavy servers) I use good ol’ ctags and grep, which is my preference anyway.

vim has been rock-solid for a while now and I can count on it not to break (or to break my configs!). I think very carefully about my workflows over time and deliberately configure the editor for exactly how I actually use it.

lemonwaterlime··on TMSU: Command-line tool for applying tags and viewing virtual tagged filesystem
See also:

- "Designing better file organization around tags not hierarchies" [1]

- `tag` - a macOS version of `tmsu` that uses the system tags (xattr-based if I recall) [2]

[1] https://www.nayuki.io/page/designing-better-file-organizatio...

[2] https://github.com/jdberry/tag

lemonwaterlime··on Vim mergetool – Reimagined Git merge workflow
This is very intuitive once you've used it a couple of times. I have handled conflicts that others were hesitant to touch with this.
lemonwaterlime··on The Future of Htmx
The philosophy of a tool like htmx encourages the opposite of "avoiding learning new things". The reality is that there is not often anything that is truly novel. We waste time by failing to recognize patterns and abstractions that persist over long periods of time and in many cases that are even foundational knowledge.

A foundational fact by definition does not need to be constantly scrutinized as if it were not. Rather it is something that can be relied upon stably until such a time that a change in a core assumption forces us to reevaluate the foundation if and when that scenario occurs.

lemonwaterlime··on The Future of Htmx
I am a fan of this approach. About to launch a SaaS now and htmx powers much of the interaction so far.

Tools like htmx make it easier for solo founders and small teams who don't have the bandwidth or the desire to manage all the churn. Keep the dependencies tight and ship!

lemonwaterlime··on Efficient German Language Learning: Is Anki the Answer?
This is similar to “shadowing”, where you listen to the text recorded in the native language and try to speak it as close to in sync with the audio as possible while reading.
lemonwaterlime··on Ask HN: Best dev environment for C in 2024?
Here's a couple of tooling posts about modern C development:

- https://github.com/xave/modern-c-vim-dev-env

- https://github.com/xave/modern-c-vimspector-debugger-tutoria...

Otherwise, the suggestions in this thread so far are great.

lemonwaterlime··on Programming languages that blew my mind (2023)
The big idea is that record types that have optional values (such as Maybe in Haskell) don't give you enough context on when, where, and how those values can be optional. Additionally, by placing things in buckets, the argument is that records and optional types are more brittle than the alternative, maps that can simply have missing keys for what would be optional. The imagery of a herd of sheep (map) versus compartments into which each sheep can go (records, Optional types, etc.) is brought up to illustrate a desire for more fluid engagement with information that may or may not exist or be needed, all of which is a description of a named aggregate of information we care about in context.

While I see the merit in his arguments, I believe his approach to data is "Clojure-like" or Lisp-like, in that it discourages explicit enumeration of all states and their possible configurations for the tradeoff of being able to sculpt these records. But, as a Haskell dev, I do not want to sculpt the records in the way he describes. I want to explicitly enumerate all the possibilities. This is, in my mind, a difference in cognitive preference. There is no right or wrong way and I think what he proposes is elegant. It is ultimately a matter of up front reasoning about the space compared with reaching a synthesis of the problem domain over time through wrestling with the problem itself. It is a statement about the efficacy of saying what can be known up front and to what extent, how much accuracy, and what utility.

I am about to launch a SaaS that pairs languages to these cognitive patterns as explicit understanding of such information can help bring together people who think similarly about information (team-building) while also opening up the possibility of expanding ones insights with alternative ideas and approaches (as his talk has done for me). The intent is to help hiring teams find devs that match their culture's programming and problem solving styles (whether that be reinforcing or doubling down on ways of thinking and acting).

lemonwaterlime··on A dictionary of single-letter variable names
If you’re doing any kind of scientific computing or electronics computations, “i” or “j” mean the imaginary number sqrt(-1).

Some software, such as Matlab, have those letters reserved for the common case of imaginary roots of a polynomial, and “ii” and “jj” as variables is a common coding convention. Whether “i” or “j” is your letter for imaginary numbers depends on if you’re an electrical engineer or not.

lemonwaterlime··on Research in psychology: are we learning anything?
Part of the problem is the therapists (and medical practitioners in general) are often forbidden from doing the thing they were trained to do for a variety of reasons: risk and liability, patient turnaround, standardization. These things can get in the way of doing the right thing in the times where that is known. That’s before considering the ambiguous cases.
lemonwaterlime··on Bureaucrat Mode
Historically, threads from systems theory via Jay W. Forrester (“Industrial Dynamics”) and organizational psychology via Gareth Morgan (“Images of Organization”) are good places to start. You can then trace them to more modern treatments for insights.
lemonwaterlime··on Ask HN: Niches Underserved by Programmers?
The elderly. Pets. Female-focused. These three areas tend to be underserved.
lemonwaterlime··on The log/event processing pipeline you can't have (2019)
This outlines an end-to-end logging philosophy on a worst-case setup (all embedded devices and having to accept whatever logging message format outputs they happen to get from kernels, drivers, vendors, etc.).

The idea is that the techniques that work for a worst case setup where you have the least control of log message formatting will work for most every other logging strategy (e.g. apps where the team completely controls the logs, don’t have to worry about kernel panics, etc.)

For instance one could imagine instead of writing logs to the OS kernel as the essay suggests, that one instead writes to RAM or something like Redis. In fact, writing to RAM is a strategy that many teams have found success with.

lemonwaterlime··on Why Haskell?
Great vids by the way! I watch your channel.
lemonwaterlime··on Why Haskell?
The Brittany code fixer needs a maintainer. The previous one had to step away. It has a unique approach to code formatting that the ormolu/fourmolu formatters doesn’t. There’s lots of the philosophy and such in the docs.

I like it better than the ormolu family because it respects your placement of comments and just formats the code itself. But it isn’t maintained as of a few years ago.

https://hackage.haskell.org/package/brittany

lemonwaterlime··on Why Haskell?
> Haskell is also probably the language that lets you produce the most succinct code

It is. Haskell has the low verbosity of scripting languages like Ruby and Python while letting you manage applications that would otherwise be written in high verbosity languages like C++, Java, and Rust.

lemonwaterlime··on Why Haskell?
> why would you restrict yourself to Haskell? It's not bleeding edge any more.

I'm not using Haskell because it's bleeding edge.

I use it because it is advanced enough and practical enough. It's at a good balanced spot now to do practical things while tapping into some of the advances in programming language theory.

The compiler and the build system have gotten a lot more stable over the past several years. The libraries for most production-type activities have gotten a lot more mature.

And I get all of the above plus strong type safety and composability, which helps me maintain applications in a way that I find satisfactory. For someone who aims to be pragmatic with a hint of scholarliness, Haskell is great.

lemonwaterlime··on Ask HN: I miss the internet of the 90s/00s. What should I do?
Glad to have made you aware. Best of luck! Will be waiting for the release.
lemonwaterlime··on Ask HN: I miss the internet of the 90s/00s. What should I do?
The seminal research paper that Google founders wrote is that ad-driven search always (an axiom) leads to focusing on the advertisers to the eventual detriment of the users of the search. That prophecy came true and new offerings such as Kagi charge users as an attempt to get to another outcome.

So if you go ad-driven, yes it will be nice and minimal ads at first. And the search will be amazing. But then one day, it won't. And that's an axiom.

Maybe that's the only way. People can get their value in the now from the search engine for 15 years or so. And then another graycat can make the thing to break the market at that point.

lemonwaterlime··on PHP is the new JavaScript?
That's a personal decision.

You could use something like Yesod or even IHP (and that's batteries included). There is Servant, Spock, Scotty for lighter weight than those. There's also the newer hastl (haven't tried it). Yet if you are using htmx, you probably want to keep things simple. On the one hand, there is simplicity from having a framework already together for you. On the other hand you can get that simplicity from only having the dependencies that you actually want for your needs.

You need something to handle:

- server connection (everything is built on top of wai and warp). There's servant and scotty for lightweight layers on top of wai (which uses simple HTTP requests and responses)

- database persistence (for postgres - Persistent/Esqueleto, postgres-simple, hasql, Opaleye, etc.; for sqlite there is sqlite-simple)

- html templates (optional, but it does make writing html more convenient. blaze, lucid2)

- auth (server-session, client-session, or roll your own. Of course, stuff like Yesod gives you all of this out of the box)

- sessions (most people roll their own Session module. The reason is that it tends to be dependent on your database and other decisions you have made for routing, connections, etc.)

- routing (libs like Servant and Yesod come with routing out of the box. Of course, you could just route with strings, but why are you using Haskell if you don't want type-safe routes? There's also stuff like web-inv-routes that give you type-safe, composable routes.)

Ultimately, I think the best way to go down the bespoke path is to know what functionalities a web server/web app needs to have as far as categories like the above and then to build it up one piece at a time (maybe with side exploratory proof of concept mini-projects). If you don't have time for that, I'd just use one of the frameworks so you can ship.

lemonwaterlime··on Ask HN: I miss the internet of the 90s/00s. What should I do?
You've been working on this for a while. Google founders' statements about the end states of any ad-driven search engine remain true. Have you addressed that fundamental foundational truth?
lemonwaterlime··on PHP is the new JavaScript?
I like Haskell + htmx (HOWL stack).
lemonwaterlime··on We've Got Depression All Wrong. It's Trying to Save Us
There's always someone saying a treatment or diet or so on had no effect on them. The fact of the matter is that exercising is a thing that most people can do with their own bodies, and it has a positive effect versus depression for most people as well. It would be much better for a person to realize the exercise doesn't help their depression than to never try it and never have any path to solution.

What I did not see from any of the responses is what did you do instead? Exercising did not work. What did you do? At least the people positing exercise as an answer gave an actionable response. And it does work. Nothing works for everyone.

← PreviousPage 3 of 4Next →