That’s what the diff
tool is for.
That’s what the diff
tool is for.
Interactive rebase? There’s no GUI that actually does that well, if at all. And it’s a massive part of my daily workflow.
The CLI is far, far more powerful and has many features that GUIs do not.
It’s also scriptable. For example, I often like to see just the commits I’ve made that diverge from master, along with the files changed in each. This can be accomplished with git log --oneline --stat --name-status origin/master..HEAD
. What’s more, since this is just a CLI command, I can very easily make a keybind in vim to execute the command and stick it’s output into a split window. This lets me use git as a navigation tool as I can then very quickly jump to files that I’ve changed in some recent commit.
This is all using a standard, uniform interface without mucking around with IDE plugin settings (if they even can do such a thing). I have many, many other examples of scripting with it, such as loading side-by-side diffs for all files in the worktree against some particular commit (defaulting to master) in vim in a tabpage-per-file, which I often use to review all of my changes before making a commit.
It can be nice when you successfully do a rebase (after resolving conflicts), but change your mind about the resolution and want to redo it.
Doesn’t come up that much, but it’s been handy once or twice, for me. It’s also just nice security: no matter how I edit commits, I can always go back if I need to.
If you do want to go the web route, I’d highly recommend avoiding SPAs and going with https://htmx.org/ instead. Much simpler, less code, entirely driven by your backend, while still giving you the ability to make nice interactive applications.
As a bonus, since you presumably have been working with Python anyway, the author of htmx has a whole book online walking you through building an app using htmx and Flask, a web framework for Python: https://hypermedia.systems/book/contents/
Why are you such a piece of shit? Or is this just bait?
Sure, perhaps it’s possible that I saw an unusually high amount of apologists, but I’m saying that it happened enough times and consistently enough that it prompted me to block them before I even knew anything about them, which I think at least says something. I won’t claim to know what the majority opinion there is, but I don’t think it’s a stretch to say that it’s an abnormal amount.
Answer me this: are they or are they not consistently in support of Russia/China? Because I’ve seen it a lot from them (and blocked the instance soon after joining Lemmy when I noticed the pattern).
Is it just some big joke that went over my head?
I dunno, I ended up blocking the instance way before I knew about their reputation (like, when I first joined Lemmy) because all of the users their kept posting the most unhinged shit.
I have definitely seen blatant apologism for China/Russia from them.
FWIW, I’m much further left than your average Democrat (I consider myself a leftist/anarchist). I personally don’t consider what I’ve seen from them to be very “left”, just authoritarian.
It’s a toss up, for me. Both managed to capture all discussion on major open source projects.
It’s speed, but it’s also flow and a continuous stream of thought. If all your editing is being done with muscle memory and minimal thought, you can continue thinking about the problem at hand rather than interrupting your thoughts process to fumble through some context menu to make a change.
I made this mistake for ages because Haskell is so popular and it’s functional and pure, but it’s not actually a requirement for functional languages to be pure. OCaml isn’t.
I didn’t say that FP languages have to necessarily be pure, just that FP languages tackle the problem of mutation by arranging programs such that most things are typically pure and side effects typically happen at the periphery (logging is probably the one exception, though). This is true even in FP languages that allow arbitrary side effects in functions, it’s just not enforced by a compiler.
I agree Rust code has a different feel to OCaml code but that’s because it makes some things easier (e.g. mutation, vectors). You still could write Rust as if it was OCaml (except for the lack of currying), it’s just that nobody does that because it sucks.
That’s the entire point, though. It’s all about what the language emphasizes and makes easy to do. If it’s unnatural to write a functional program in Rust and no one does it, then it’s not really reasonable to call it a functional language. Writing functional programs is not idiomatic Rust, and that’s okay.
Fundamentally it’s a language oriented around blocks of statements rather than composition of expressions. Additionally, it takes a different approach to the mutation problem than FP languages: where FP seeks to make most things pure and push mutation and side effects to the edges of the program, Rust uses its type system to make such mutation and side effects more sane. It’s an entirely different philosophy when it comes to programming. I don’t think either approach is necessarily better, mind you, just a different set of tradeoffs.
I’m a professional Haskell developer and am very much immersed in FP. When I read Rust code, I have to completely shift my thinking to something much more imperative. Whereas if I read, say, Ocaml, the difference is mostly syntactic. This isn’t a slight, mind you. I quite like Rust. But it’s a very different paradigm.
Obviously there’s a small handful of things that would require a reboot, but unlike Windows, the vast majority of programs in user space don’t require reboots on update.
There’s also the fact that restarting Windows to update is a much slower and more disruptive experience than restarting Linux.
It’s not a functional language at all, even if it borrows ideas from FP languages. It’s an imperative language through and through.
The manufacturer obviously also makes the app and can control the encoding.
You don’t have to take arbitrary bytes. UTF-8 encoded strings are just fine and easily handled by libraries.
At minimum you need to limit the request size to avoid DOS attacks and such. But obviously that would be a much larger limit than anyone would use for a password.
This is completely different from electron. Nix dependencies will be shared if they share the same hash. Electron just blindly copies everything over every time.
Your post only showed adding functionality over the algebra, not new types on which the algebra operates (or “sorts”, as they are otherwise known). In other words, you can’t easily extend Expr
to support Boolean logic in addition to addition itself. For a concrete example, how could you represent ternary operators like in the expression 2 + 2 == 4 ? 1 : 2
, such that it’s well typed and will never result in an exception? With GADTs, this is very simple to do:
data Expr a where
Lit :: Int -> Expr Int
Add :: Expr Int -> Expr Int -> Expr Int
Eq :: Expr Int -> Expr Int -> Expr Bool
If :: Expr Bool -> Expr Int -> Expr Int -> Expr Int
eval :: Expr a -> a
eval expr = case expr of
Lit n -> n
Add a b -> eval a + eval b
Eq a b -> eval a == eval b
If p a b -> if eval p then eval a else eval b
-- >> eval example == 1 => true
example :: Expr Int
example =
If ((Lit 2 `Add` Lit 2) `Eq` Lit 4) (Lit 1) (Lit 2)
Let’s give it a shot. I live in the suburbs of Lincoln, Nebraska, which is an average-sized college town in the US (about 300k residents):