Experience: 3 years full-stack fintech development; 2 years academic research; various web development; BS+MS in Computer Science
I've worked on a variety of projects in the past few years, from web app frontends and backends to an automated trading system, as well as retro assembly programming in my spare time (it's the polar opposite of Java+Spring's high-level abstraction). I'm seeking full-time employment but would also be open to short-term positions.
I would guess that two big issues for that are lack of function overloading and that macros are pretty good.
A lot of the patterns of working with variadics in c++ take advantage of function overloading. Without function overloading, those patterns can become harder.
Secondly, Rust macro system is crazily powerful especially procedural macros. That power disincentivizes developing other approaches to meta programming. In C++ macros are clunky and dangerous, and that has incentivized developing more type based meta programming techniques to get away from C macros.
One problem with the macros approach is that you get really hard to understand error messages. For example, if a user wrote a method where one of the arguments did not implement ToPolarValue, they would get the following error:
fn blah(blah: Blah)
^^^^^^^^^^^^^^^^^^^ the trait bound Method<_, _> is not satisfied
As opposed to something like this with variadic generics:
fn blah(blah: Blah)
^^^^ the trait bound ToPolarValue is not satisfied
proc macro diagnostics are a cool feature, but they would not help here. Here, macros are being used to generate implementations of a trait. If the trait bound is not satisfied, you have no way of knowing why other than that there was no implementation generated for it, hence the confusing error message. With variadic generics however, you could write something like:
Fn(..Args) -> T
which I assume would let the compiler know why the trait bound is not satisfied and output a nicer error message.
Firefox didn't remove it. They just put it behind a new flag that is default off. Apparently it was because it affects performance for those not using the feature.
I left Stony Brook University in 2017 with a Master's in Computer Science, and am currently seeking a software development position. I'm open to contract, part-time, or full-time opportunities. I care about writing code that's not just correct, but documented for the developers' sake and designed for the users' sake.
I left Stony Brook University in 2017 with a Master's in Computer Science, and am currently seeking a software development position. I'm open to contract, part-time, or full-time opportunities. I care about writing code that's not just correct, but documented for the developers' sake and designed for the users' sake.
As the paper's abstract states, "Quadratic cost uniquely makes the marginal cost proportional to votes purchased". The full paper shows their proof and the assumptions behind it, such as "an individuals’ value for votes is likely to be approximately linear in the number of votes she casts so long as her utility is driven by the impact she has on the vote total, as argued by Mueller (1973, 1977) and Laine (1977)".
If merely 100 less-wealthy voters out of the whole population couldn't coordinate to buy a few extra votes—and they wouldn't even have to explicitly communicate, it would just take 100 people who individually hear about the issue and decide to vote more—then how important can the issue really have been to them?
I believe this is what is meant by "the collective decision rapidly approximates efficiency as the number of voters increases".
That's missing the point I was making. I'm attempting to highlight the difference in effort that is required. Do you accept that the rich voter makes less effort in the hypothetical 1 vs. 100 voter situation?
I'm not sure that is correct. Assume that you have only 101 people in the voting pool. The one person who is wealthy pays $1,000 for 100 votes. To match that voting power, you'll only need a handful of the other hundred to pay $4 for more votes. What I think you are overlooking the fact the wealthy person's $1,000 is going to get distributed to everyone which gives them more voting power. Everyone gets at least $10 at the end of the vote. If a few people are willing to invest the $10 back into their vote, they can easily overcome the rich persons' vote even though a vote was purchased for each person in the system.
How balanced this is, I'm not sure. Why use the square of the number of votes rather than the cube? But it isn't immediately clear that this gives a few rich people significantly more voting power in a situation where a larger number of poor people feel strongly about an issue.
> "I'm not sure that is correct. Assume that you have only 101 people in the voting pool. The one person who is wealthy pays $1,000 for 100 votes. To match that voting power, you'll only need a handful of the other hundred to pay $4 for more votes. What I think you are overlooking the fact the wealthy person's $1,000 is going to get distributed to everyone which gives them more voting power. Everyone gets at least $10 at the end of the vote. If a few people are willing to invest the $10 back into their vote, they can easily overcome the rich persons' vote even though a vote was purchased for each person in the system."
Two points:
1. You've chosen a value that's too small for the wealthy voter. $1000 is the cost of eating out at an expensive restaurant (e.g. https://financesonline.com/10-most-expensive-meals-from-mich... ), not the amount someone with money will spend to gain influence in an election.
2. There are cheaper ways to multiply the vote. Let's assume quadratic voting was in place in the 2016 US Presidential Election, and you're a wealthy person who wants to see the Democrats win. You have $1,000,000 you're willing to spend. What's the cheapest way to maximise your influence? Reach out to other Democratic voters to give them money to multiply their votes. On your own, the $1,000,000 may only net 1000 votes, but spreading the $1,000,000 around to people who were going to vote Democrat anyway could see that number skyrocket. Let's say you give $100 to 10,000 voters, now you're looking at 100,000 votes.
Even if those without the most money win, quadratic voting stacks the odds against them.
> You've chosen a value that's too small for the wealthy voter.
Yes to make it simple to intuitively see how rich people paying more gives more voting power to everyone else IF they choose to spend it that way. If you want to think about US presidential elections, you'd need to increase the total number of people by 3,000,000. Based on my math, this would just further amplify the effect I was trying to illustrate with my numbers.
> Even if those without the most money win, quadratic voting stacks the odds against them.
As I understand the math, it doesn't necessarily do this. The goal was a voting system that takes into consideration not just how many people want a particular outcome, but how badly they want a particular outcome. Today the way that is done is by donating money to be spent on advertising to sway votes or get people to go to the polls. Quadradic voting is designed to be more fair than the current way of allowing people to magnify the strength of their preferences for a particular outcome.
My initial reaction was the same as yours. After looking at how the math actually plays out and considered how money is currently spent on influencing votes I think it is probably a lot fairer than it looks at first for the goals it is trying to achieve. (Still could be a really bad idea for other reasons.)
> "Yes to make it simple to intuitively see how rich people paying more gives more voting power to everyone else IF they choose to spend it that way. If you want to think about US presidential elections, you'd need to increase the total number of people by 3,000,000. Based on my math, this would just further amplify the effect I was trying to illustrate with my numbers."
I respect that you had good intentions, but I think the approach was flawed.
In your example, $1000 vs. $400 ($4 * 100), what does it take for the rich person to gain the lead again? They can either spend more or split the money. For example, if they split the $1000 with a family member who was voting for the same party/candidate, that's all it would take to gain the lead.
Also, consider the difference in fundraising potential between the rich and the poor. For example, in the 2016 US Presidential Election, Bernie Sanders ran what I believe to be the most successful citizen-led fundraising campaign in US political history, raising approximately $228 million:
So the most successful crowdfunded campaign in history was outspent by just 23 people.
I don't know if you were a Bernie supporter or not, but I hope you'd agree that he was a candidate that people were strongly behind. However, due to the income inequality in the US, the difference in spending power is massive. It's not a matter of the general public wanting something badly enough, $228 million is a clear message that the want was there.
The only caveat with all this is that not all the super PAC money would've been spent for a single party. However, the majority would've been spent supporting corporate-friendly candidates.
Represents a lot of effort in what way? Certainly not in terms of time to spend or earn it, both of which can be achieved in less than a day. Also consider that wealthy individuals are already spending a lot of money in elections. For example...
Only insofar as the system is there to make me spend more time watching videos; it does nothing to help categorise or identify propoganda that isn't targeted at me.
That translates fairly well into Python, with its set type and list/set/dict comprehensions.
def setrange(first, next, last):
return set(range(first, last+1, next-first))
fizz = setrange(3, 6, 100)
buzz = setrange(5, 10, 100)
fizzbuzz = fizz & buzz
fizz -= fizzbuzz
buzz -= fizzbuzz
num = setrange(1, 2, 100) - fizz - buzz - fizzbuzz
line_map = dict({n: "Fizz" for n in fizz}.items() +
{n: "Buzz" for n in buzz}.items() +
{n: "FizzBuzz" for n in fizzbuzz}.items() +
{n: n for n in num}.items())
for i in range(1, 100+1):
print(line_map[i])
Some SETL features Python lacks:
• No ellipsis notation for ranges; must use the "range" function and add one to the maximum value, or define a custom "setrange" function
• Can't concatenate dictionaries; must concatenate their "items" lists and convert back to a dictionary
• No consistent map-lookup notation; collections are indexed with brackets, but functions are called with parentheses
Remote: Yes
Willing to relocate: No
Technologies: Java, Spring, C, C++, Python, Spark, SQL, MongoDB, Angular, HTML5, CSS3, Javascript, Typescript, Git, Windows, Linux
Résumé/CV: https://www.linkedin.com/in/remyoukaour/
Email: remy.oukaour@gmail.com
Experience: 3 years full-stack fintech development; 2 years academic research; various web development; BS+MS in Computer Science
I've worked on a variety of projects in the past few years, from web app frontends and backends to an automated trading system, as well as retro assembly programming in my spare time (it's the polar opposite of Java+Spring's high-level abstraction). I'm seeking full-time employment but would also be open to short-term positions.