>Turning Point USA CEO and co-founder Charlie Kirk said of gun deaths on April 5, 2023, "I think it's worth it. I think it's worth to have a cost of, unfortunately, some gun deaths every single year so that we can have the Second Amendment to protect our other God-given rights."<
The employers already had all kinds of bizarre tricks to keep tipped workers down.
My girlfriend works for a local chain restaurant. Some of the things she tells me about seem like they shouldn’t be legal (forcing everyone’s cash tips to be pooled with non tipped teenagers they don’t want to pay, for example. Pretty sure the company has had previous class actions against them. This was just a small local chain in a middle/upper middle class suburb.
I saw a post on Nextdoor the other day where another restaurant closed, laying off the workers without paying them for hours worked. The general consensus about how to get the money you worked for: you don’t. The state has no labor board and there was little option for recourse.
Not that I'm a fan of tipping culture or the "creator" economy, but it seems like tips and donations to your favorite youtuber are obviously gifts to me? From irs.gov:
> You make a gift if you give property (including money), or the use of or income from property, without expecting to receive something of at least equal value in return.
Which is obviously true for tips and donations. If it is a gift, then the giver owes taxes, and there is a $19k/year/recipient exclusion, so small gifts like this would always be exempt.
Towards what? No taxes at all? That's not desirable if you want things like public schools and rule of law.
And if you want more progressive taxation, then support more progressive taxation. Treating classes of workers differently is not a way to get to more equitable progressive taxation.
>Why aren’t capital gains taxed at a higher rate than income?
The federal capital gains rates are higher than the effective tax rates paid by a family making a median income, but I suspect you are asking why the capital gains rates are not higher than the highest marginal rates.
One issue is simply that capital gains tax rates generally don't account for inflation. If you build a business over a few decades and sell it, much of the increase in value will be simply due to inflation. Do you want to encourage long term investment, or make it so only financially illiterate people do long term investments?
I suspect much of the attacks against property taxes aren't to right any historical wrongs, but is part of the attack against public education, since property taxes are a major source of funding.
> No, you're renting the physical space -- a scarce part of the commons -- from your community.
Property law in the US and most western democracies doesn’t remotely agree with that. Land is not a communal or solely government owned resource, and the govt doesn’t ‘rent’ it out.
Stop paying your property taxes in the US and see how long it takes before the government forecloses. It is effectively rent under a different name. In exchange the government will protect your property ownership rights so that you don't go on vacation and find someone else now gets to claim your home since you weren't there to stop them.
Note: I think this is a good thing and that property taxes are vital to our local communities well-being.
Pre-iPhone 15, the Pro models used stainless steel for the frame. Not sure exactly why they ditched it, but it did have a reputation for collecting fingerprints.
The weight difference in the hand between the 14 pro in stainless and the 15 pro in titanium is considerable, I use both every day. Sometimes weight is a way to denote solid and premium like in watches, but with the size of phones and how we use them, being lightweight is really where it’s at.
We need to be able to turn it into a building material. Currently growing trees are the most efficient path to do this, but imagine being about to suck down c02, asking a ton of energy (let’s say from a nuclear source) and produce bricks.
It's probably not your intention, but I greatly dislike this argument, as it's similar ones were made to justify previous inhumane practices that were legal before the conclusion of the US Civil war.
If manual labor is required for agriculture, let the market absorb the real cost and pay the workers the correct wage instead of exploiting them.
The process can be orderly. I live in a town with a couple of commercial orchardist, and they get their apples picked by workers on temporary work visas every year for decades now. These commercial orchards are apparently economically viable, even though they are smaller than a typical commercial orchard in Washington state, for example.
As with tariffs, I can imagine this situation being less orderly or predictable now. But I've seen both theory and practice work as intended.
A countries agricultural base being dependent on undocumented migrant workers is bad and should be corrected. However simply deporting all the migrants overnight with no further action doesn't fix the underlying problem, doesn't help the industry, and doesn't help the consumers.
All things being equal, people will generally choose to follow the law. So figure out why the migrants and their employers are choosing not to follow the law and fix that.
You could do like Australia, offer a working-holiday visa with the possibility to renew it for up to 3 years on the condition that you spend a certain amount of time working on a farm/ in rural area.
Loads of people do it in Australia and it helps tremendously. It's not perfect for sure, but it's something.
Consider this vague hypothetical, because I'm not American and don't care about the specifics:
Country A, average wage X; country B, minimum wage for legal residents 2X. People from A can on average get a pay rise by working in B while undercutting legal residents of B. Citizens of B then get the stuff cheaper than they otherwise would have, but also might not be as easy to employ.
Are current employment stats accurate? As in do they tell the right picture or is this a case of "lies, damn lies, and statistics"? Lots of people say it's the later, and unfortunately I'm not qualified to explore anyone's arguments.
I suppose that's fine if that is your solution. It's easy for me to say "things should probably cost more" because I can afford it.
If I'm allowed to fret a bit for my fellow countrymen, I confess I am saddened that they will have to decide between food or rent in the coming months/years. When my single mom raised my sister and I she had to make that same choice at times.
Ah, but you see the thing is here in the land of the free, we consider this type of thinking to be "Communism" and must be purged without any further thought.
Whats [additionally] infuriating for me is all of this is funded by my tax bill. Both Hyundai taking massive federal incentives, and the subsequent arrests.
I just think of the money wasn't collected/handed out to them in the first place we wouldn't be in this situation.
There are real benefits to power staying with the people and not faceless ( or in this case, as it were, facefull ) government. I get that people discuss this in extremes, but surely there is some middle ground between NJ level craziness and, say, taxless utopia.
you fail to understand basic economics. states AND countries provide tax breaks to lure in businesses with certain agreements. In the long term, this provides jobs, training, benefits local economy, income taxes, raises property values, increases property taxes, etc.
And your tax contribution to would be %.0001. There are MANY things about the government to be infuriated at but this isn't one of them.
Lisps (like Clojure) treat code as data (lists), so you write: `(if x (y) (z))` instead of Python’s `y() if x else z()`. So the code is more concise, but does less to walk a novice through it.
This gains a huge advantage, which allows even more concision: all code is data, so its easy to transform the code.
In Clojure if you want to add support for unless, a thing like if, but evaluating the opposite way you could do this: `(defmacro unless [p a b] `(if (not ~p) ~a ~b))`. Obviously if you wanted to do the same thing in Python you would in practice do `z() if x else y()`. However, you would do it that way because Python isn't as powerful a language. To actually do the same thing in Python you would need to...
1. Add __future__ support.
2. Update the Python language grammar.
3. Add a new AST type.
4. Add a new pass stage to the compiler.
5. Add a python library to integrate with this so you could use it.
Then you could do something like:
from __future__ import macros
defmacro unless(pred, then: block, else_: block = []):
return q[
if not u(pred):
u*(then)
else:
u*(else_)
]
So in the trivial case its just hundreds of lines harder plus requires massive coordination with other people to accomplish the same feat.
This sort of, wow, it takes hundreds or thousands of lines more to accomplish the same thing outside of Lisp as it does to accomplish it within Lisp shows up quite often; consider something like chaining. People write entire libraries to handle function chaining nicely. `a.b().c().d().map(f).map(g)`. Very pretty. Hundreds of lines to enable it, maybe thousands, because it does not come by default in the language.
But in Lisp? In Clojure? Just change the languages usual rules, threading operator and now chaining is omnipresent: `(->> a b c d e (map f) (map g))`. Same code, no need to write wrapper libraries to enable it.
That doesn't look like a factor in the article though, he isn't using many if any macros that aren't part of the core language. And the one macro I do spot (defcfn) is pretty mild in context.
People like GP often repeat that talking point: "code is data so that's amazing because of macros".
In practice, by and large, with very few exceptions, macros are frowned upon in the same way that using metaprogramming in ruby is. Macros are only fun to the person writing them (and not even the author when they have to maintain it).
Macros can almost always be expressed with a simple function and remove all the unexpectedness without losing anything. Again, there are some exceptions.
> In practice, by and large, with very few exceptions, macros are frowned upon in the same way that using metaprogramming in ruby is. Macros are only fun to the person writing them (and not even the author when they have to maintain it).
I'm not sure "frowned upon" is the right expression, but I'm not a native speaker.
The way I've internalized it, is basically "Avoid macros unless there is no other way", which basically means use functions/anything else whenever you can, but if you absolutely have to use a macro for something (like you wanna read the arguments before they're parsed), then go for it.
I always looked at these features of being able to extend the language beyond some commonly accepted practices as detrimental to the language. I've spent way too much time debugging issues with operator overloading or complex templates (C++), or obscure side effects in DSLs. So, (re)defining language constructs in a project seems nightmarish to me to support in production and therefore I never even attempted anything serious in a functional programming language.
But... looks like the professional community knows this and so maybe it's time to take a deeper dive :)
> So, (re)defining language constructs in a project seems nightmarish to me to support in production and therefore I never even attempted anything serious in a functional programming language.
It can be, but also not. If you isolate them into libraries with clear interfaces, you can kind of avoid that. I think clojure.core.async is an excellent showcase in something you couldn't do in other languages, where asynchronous channels were possible to add to the core language without changing anything in the core compiler itself, and because of the small interface, you can still use it without ending up with nightmares :)
Understood. I was more referring to a case where a project would start defining its own language constructs and if each project would do that then every single project would come with a very high cognitive load.
Dunno about the Clojure communtity but for Emacs Lisp and Common Lisp there are certain broadly accepted idioms where macros are accepted:
1. "with-context", where there is a need to control resource allocation/deallocation or things in the context of code in question.
2. use-package dsl that simplify configuration in a predictable way
3. object definition helpersresource
Then, there are core language extensions and std libraries suggested for the main implementation. This is where macros are fine as they always get good documentation and plenty of additional eyeballs.
I use a few macros for creating contexts (i.e. with-texture, with-stencil, with-scissors, with-tar). Also I have macros for rendering (onscreen-render, offscreen-render). However I try not to overuse macros.
Fun fact: the big difference isn't the syntax. Lisps only go from foo(bar baz) to (foo bar baz) which is a change but not really much of one. The change is actually the immutable and high performance basic data structures. Clojure can do something that something like C can't do - cheaply create a copy of something with a small change. That leads to a completely different preferred code style in the Clojure community that is a big departure from C-like languages which make heavy use of variables. The code is doing something practically different from what a C-like language can ergonomically handle.
Clojure has a bunch of other syntactic structures not found in other lisps that makes it a lot more visually noisy. I'm very comfortable with Scheme and I can very quickly absorb Scheme code when reading it, but I have to very slowly decipher the code in the article.
> not found in other lisps that makes it a lot more visually noisy
I disagree. It only feels that way, until you learn how destructuring works in Clojure. Once you grok that, you'd understand why the vector syntax for function arguments was chosen, and not a simple list like in other Lisps. In general, Clojure is highly pragmatic - if something done certain way, most-likely it's for good reasons, and not by accident.
Also, Clojure-maps are just freaking amazing. I wish others, e.g., Elisp had them.
Clojure is extremely and nicely readable, just requires some getting used to it. At some point, I completely replaced my API-testing workflows, switching from JSON to EDN - it's almost twice more compact and much better visually, not to mention that it's incredibly nice to be able to just explore and visualize any given data through the REPL.
> It only feels that way, until you learn how destructuring works in Clojure
Well... yes. The original comment was about how Clojure code looks very foreign. The reply to that was that Lisp code is not actually that foreign because it's just taking the common foo(bar baz) and making it (foo bar baz). My comment was that Clojure is more foreign to most programmers than other Lisps, because it's not simply mapping foo(bar baz) to (foo bar baz).
Of course when you learn the things that make it unique, it becomes familiar.
That's just existing muscle memory. Nothing is wrong with you and nothing is wrong with Clojure. I had the same feeling when I started with Lisp. Give it some time, it's absolutely worth it. Interestingly, every single programmer I introduced to Clojure as their very first programming language had no issues picking it up. Later, they complained about difficulties getting used to Javascript and Python.
reply