The other day I was listening to a clip from Jordan Peterson, and he said something that I found a bit surprising/shocking, but this articles seems to confirm it: people on the left who claim to side with the poor don't actually care about the poor, they just hate the rich.
This article is basically just hating on the rich people.
I think it's rather easy to understand what this author is puzzled by: people want to keep their money. If you've earned your money and you want to keep it, I can empathize with you. If you think you deserve to take other people's money, I can't empathize with you.
It's a bad thing, because it shows the minimum wage isn't enough and zero-hours contracts aren't keeping people out of poverty.
But people in work who do over sixteen hours per week and who are claiming eg working family tax credits are not free-loading.
This is one of the mechanisms that's designed to get people back into work. There's a benefit cap in place, and that cap is removed if you work more than 16 hours per week.
This quote is so misunderstood and so abused all the time.
The point of the statement is to not micro-optimize this and that corner of the program without having any data to guide you on what you should optimize and how.
It's not a rallying call to forgo all concerns about application performance and efficiency.
The mis-application of this quote is the root of all evil in modern software IMO.
It's why a chat program takes 500MB of RAM and why many programs take 10 seconds to load even though there's no technical reason they cannot startup instantly.
You should make it right and fast from the very start. You should not make something that "works" but is full of bugs and slow as hell. Like, that makes no sense at all. If it's full of bugs then it doesn't work. If it's slow as hell then it doesn't work.
1. Make it work correctly and efficiently (to a reasonable degree)
> 1. Make it work correctly and efficiently (to a reasonable degree)
Unfortunately, this took your team 6 months and the people that launched their app 4 months ago (having opted for "make it work") now have 90% of your market and you've all just been made redundant because the customers do not care whether your app is "more correct" and "more efficient" because they just plain damn couldn't use it.
There's a reason "worse is better" applies to software.
First market is not often the winner. Facebook came very late to the social media scene but it dominated.
Google came very late to the search engine scene, and people don't even remember this but there was a time when there were a ton of search engines and anyone at the time would probably think that the search engine market is saturated and there's no space for a new product.
All evidence actually points to better products dominating the market even if they come late.
If your competitors released their app 4 months ahead of you but it was full of bugs and always hangs up, and then you release your product which actually works and performs well, people will see your product as a breath of fresh air.
Another example is the Chrome browser, which came at a time when Firefox and IE were competing fiercely for market share, and Chrome completely dominated them on the simple basis that it was _really fast_.
For most products it doesn't even cost 6 months to make it fast. If you have that as a goal from the very start, there will never be a stage of "omg it's really slow let's try to make it a bit faster". It will always just be fast.
> Chrome completely dominated them on the simple basis that it was _really fast_.
It isn't that simple - a lot of Chrome's success came because they "made it work" in ways that Firefox (horribly wasteful of CPU, memory, battery life) and IE (shambles in every department) didn't. Also helped in large part by having an enormous web monopoly pushing it and favouring it for their properties.
But you're definitely right that it came after them.
> Yes, it performed way better than Firefox, which is exactly my point.
No, you specifically called out the speed and speed only - "on the simple basis that it was _really fast_" - nothing about it working right in other areas (which are the ones that grabbed people, not the speed.)
Somewhat off topic but I think that more and more people are learning (the hard way, unfortunately) how important static typing is, and how dynamic typing makes it very difficult to develop and maintain large projects.
I think the next generation of successful languages will all be statically typed (whether they will run natively or in a virtual machine is a different (even if related) question).
No I think what we are seeing is a lot more hybrid systems. Go is like a statically typed language with lots of dynamic features. Julia is a dynamically typed language with lots static typing features.
Paradigms are getting mixed too. Rust, Kotlin and Swift are all imperative languages with heavy functional inspiration.
Traditional statically typed OOP languages such as Java is what people want to get away from.
> No I think what we are seeing is a lot more hybrid systems.
I'm not sure why you started that sentence with "No". I actually agree with it.
There are many good ideas that have emerged separately in different languages, and are being combined in some of the new languages.
All I'm saying is, successful upcoming languages will probably be more statically typed than dynamically typed.
In other words, the dynamic typing paradigm is failing the real world test.
> Go is like a statically typed language with lots of dynamic features.
Go is statically typed.
The part that lacks static typing (no generics) is the worst part of the language that gets the most flak.
> Traditional statically typed OOP languages such as Java is what people want to get away from.
Java's problem is that it's just way too verbose.
User user = new User(....); // This is not even that verbose
// Maybe more like this:
User user = new User(new UserProfile(....), UserManagerFactory.getDefaultUserManager());
People have misdiagnosed the problem and thought it was the static typing.
It turns out to be the lack of support for functions as objects. So for many things you end up having to create dummy classes and objects just to wrap functions.
Even C supported passing function pointers around.
So in this regard, Java is less expressive than C.
I somewhat agree but I think they will be optionally typed (and for that matter, optionally borrow checked), more along the lines of Julia. Where type stable code gets the performance benefits of static typing, even if it doesn't use any static typing. And where types can be added at any point to improve type checking, performance, and polymorphism all at once.
This allows for fast prototyping, and when done correctly, easy to add type safety. For example, you can prototype the code, make sure it works, add more tests, then add type checking while cleaning it up and documenting it. That would be my ideal workflow.
Anecdotally, I've developed large projects in C++ and Java (I know, they're pretty lame static type systems -- but certainly the most popular static type systems) and also in Python and Clojure and I really haven't seen much benefit in static typing in regards to software defect rate or quality. Static typing make auto complete and refactoring tools easier, for sure, but it also slows down ease of experimentation (and writing generic code can be painful, although other static languages especially type inferred ones fare better here). I buy into Rich Hickeys view on this topic[1] and that's one reason why I like Clojure: it gets out of the way, but it provides me with the tools I need to verify or validate my data (eg on the module or application boundaries).
I've played around with languages that have fancier type systems (Haskell, various ML's, briefly ATS) and am very interested in Rust (but have yet to use it), but they haven't really provided enough benefits for the effort of describing the types.
Note that I used to be very heavily in the static typing camp and I still very much like the idea of static typing, I just don't think we have found a static type system yet that has the right balance of convenience and safety and actually catches the right kinds of errors (as described in the below talk).
I guess my point is that its not quite clear that the next generation of successful languages will all be statically typed. In fact, current trends would suggest otherwise (most of the popular languages are dynamically typed) although perhaps that depends on your definition of "successful".
> I just don't think we have found a static type system yet that has the right balance of convenience and safety and
actually catches the right kinds of errors (as described in the below talk).
> I really haven't seen much benefit in static typing in regards to software defect rate or quality
Hold it right there. I've never seen anyone argue that static type systems prevent bugs.
I mean they do prevent silly bugs that occur from mistyping variable/property names but I've never seen anyone claim that they eliminate other classes of bugs.
The biggest benefit of static type checking is you know what all the variables are.
def checkout_cart(customer, payment_methods, cart, session):
# body
What the hell is customer? What is payment methods? What fields are available on these objects? What methods can you call on them? no freaking idea.
Of course, this kind of code is confusing in Java as well, but for a different reason: Java conventions encourage a kind of obtuse programming style where everything is hidden behind layers of abstractions of factories and managers, so that even when everything is typed, you're not sure what anything is doing because all the data that matters is private and so are all the methods that actually do anything useful. All you're left with is an abstract interface that can sometimes be just as bad as an untyped variable. But this is mostly a cultural problem. (I've digressed).
> Static typing make auto complete and refactoring tools easier, for sure, but it also slows down ease of experimentation
Java slows down ease of experimentation because it requires tons of boilerplate code for even the simplest tasks.
It's not the static type checking.
If anything, static type checking helps experimentation because you can change your mind quickly and the compiler will help you catch all the stupid mistakes that can occur from mismatching types or mistyping variable names. This removes a huge cognitive tax and makes programming more enjoyable. Although I will concede this is subjective.
>Hold it right there. I've never seen anyone argue that static type systems prevent bugs.
Really? I see this every single time the subject is brought up. And, to be fair, they do catch some bugs, it's just that they do so at a cost.
>What the hell is customer? What is payment methods? What fields are available on these objects? What methods can you call on them? no freaking idea.
And, if they are all strings, how much more of an idea do you have?
Static typing does not necessarily help solve this problem - a combination of reduced scope(i.e. looser coupling), more specific variable naming and higher cohesion (e.g. having a customer object) do.
Moreover, there's a super easy way to figure out what all of those things are and figure out how you want to change it - run a behavioral test and launch a REPL when it hits that function.
At that point you can inspect customer, use autocomplete on it and even experimentally run code.
>If anything, static type checking helps experimentation because you can change your mind quickly and the compiler will help you catch all the stupid mistakes that can occur from mismatching types or mistyping variable names. This removes a huge cognitive tax and makes programming more enjoyable.
Behavioral tests perform this function equally well, if you have them.
> IMHO behavioral tests perform this function equally well.
I think a common pitfall in these discussions is to compare the worst case examples rather than reasonable quality codebases. I'd be far more interested in, say, time/cost to correct result metrics for a well-maintained Python codebase which has reasonable use of tests & linting (e.g. flake8) to an equivalently-proficient team using a statically typed language.
If we're discussing well-maintained code, then I would expect that the public interface is documented, at least in docstrings. Then I also know what the parameters are.
Agreed — I'm just wondering about how to quantify the impact of various changes. A dynamic language project with no tests, etc. is going to look like a selling point for static typing but I suspect the real-world bug counts for, say, a Python project using mypy (or even flake8 + tests + coverage) is going to be a lot closer than you might think from how heated these discussions get.
I got the impression that the bugs found were either not at all serious (e.g. throwing a typeerror on malformed input instead of some other nicer kind of error) or were in areas of the code not covered by tests.
Unfortunately the author does not rate them by severity.
My gut feeling is that dynamic typing + tests & static analysis is faster than very heavyweight languages (e.g. Java) but probably near or less than languages with more advanced typing systems like Haskell or Rust, but I'd really like to see something more comprehensive than a subjective opinion.
A behavioral test is a test that tests the behavior of a piece of software, as opposed to a test that checks types or implementation details or something else that isn't behavior.
It is perhaps not necessary to write tests like these in languages that produce code that does not have bugs. I have yet to encounter such a language.
>If declaring structs is seen as costly overhead that complicates coding, tests are when more cumbersome.
Except that static typing doesn’t help much there either (unless perhaps you’re using Frink with its units). The type doesn’t carry enough information. For example, knowing that something is an integer really doesn’t give you enough context about what that integer means or is used for. If it’s an object or strict, ok, then it helps to document, but if it’s primitive or standard collections...
Anyway, in Clojure, we now use spec to specify the shape of data that we expect, with nice descriptive namespaced keyword names. It helps in validating data entering the system, generating test data and as documentation.
> I've never seen anyone argue that static type systems prevent bugs.
It's extremely common to claim that static typing prevents entire classes of bugs (and I agree!). Here's just one instance of such a claim I found on Google:
Have to agree with you, but with a little bit of additional context.
I get why people started rejecting statically typed languages. I work with many different languages, but started with statically typed languages with various forms of static typing (Pascal was my first, but then C and C++). Dynamic languages offer flexibility that statically typed languages lack. Most of the time, the flexibility rejected by static typing ends up being a good thing as it encourages sane code that can be analyzed by the compiler and prevent runtime bugs, so I've always accepted this sacrifice of flexibility as a feature rather than a hindrance.
However, I've found myself recently writing many solutions using TypeScript[0] and I'm finding its static type system, which allows one to configure the strictness, to be incredibly powerful. It's helped, first, by fantastic support for union types, type inference and duck typing. I find that the compiler, which is little more than a transpiler with a static analyser bolted on top of it, catches errors that I make and greatly reduces runtime WTFs while still allowing me to write terse, simple code that isn't littered with unnecessary type annotations. I add typings where either the implicit type detection can't predict the type for me or where it decreases cognitive overhead while reading code and leave them out when the opposite is true. This moves the bar back a little bit toward the flexibility side -- I can do things in code that are completely illegal in C# that result in less code, yet not increase my runtime bugs or decrease readability in the process. And if there's something truly harry that has to be done, I can tell the compiler to simply ignore the violation and give me the JavaScript output that I want regardless of what you think it's going to do.
...and I find myself longing for that type system everywhere else. So while I am still a huge proponent of statically typed languages and I don't see that changing any time, precisely how the static type system works and what features it supports is becoming very important to me.
[0] Which, considering how much I hate JavaScript, was a huge surprise considering it's basically ES6 JavaScript with optional type annotations.
I am not a chatty person - crippling social anxiety sees to that - and I would much prefer this kind of informal chat to a "real" interview because it removes a lot of the pressure which then helps to alleviate the anxiety enough to show that I know what I'm talking about.
If you can't express your competency during an interview chat I don't see how you could be a good candidate (there are exceptions), nothing more damaging to a team that someone who can't communicate.
How about shy people who have a hard time talking to new people? Who only feel comfortable after a couple of days and then they become very chatty? Aren't most developers like that?
Not significantly more than among the population in general, at least not in my experience.
Being able to simulate extroversion for short periods at need is a useful life skill for any introvert - I've found it invaluable in plenty of situations beyond just job interviews.
No necessarily competent. It could be that they are well read on the subject but have no practical experience in it. So they seem able to converse in the subject's vocabulary but if they were to sit down and try to make something they would fail.
And all the code pens are also slow. Between clicking the "run" button and the actual script running there's somewhat of a 3 second gap.
Which kind of puts the opening paragraph into question:
> I’m passionate about image performance optimisation and making images load fast on the web.
Like, ok, why aren't you using a simpler blog engine to post? As a plus, if you were in control of everything on the page, you wouldn't even need to use codepen; just include the javascript directly in your page.
Sexist: relating to, involving, or fostering sexism, or attitudes and behavior toward someone based on the person's gender. [0]
The quote under discussion (bracketed comments added):
>Incidentally I regularly break some of these rules with male employees, such as remarking on haircuts ("looking good", etc.), but it's different.
This quote admits to blatently treating his female employees differently than his male employees. That seems to be a clear example of sexism. We can disagree on what the consequences of this sexism is; and even if this is good sexism or not; but I do not see how there can be disagreement that this is sexism.
> attitudes and behavior toward someone based on the person's gender
That's only relevant if you hold the unscientific belief that men and women are interchangeable and that the reproductive organ is the only thing that's different.
There are many ways where attitudes towards a person must be adjusted depending on the person's gender.
For example, women are physically weaker than men, so if a man was to hit a woman in public, he would be arrested, where as if a woman was to hit a man in public, no one would blink an eye.
> I do not see how there can be disagreement that this is sexism.
Because you are implying it's a bad thing. You can't just take away the context of the conversation and pretend that we are arguing about semantics.
Many things are true on the level of groups, but it doesn’t mean that it’s a good idea to apply them as general rules on an individual level.
Women maybe weaker than men in general. There are however many women stronger than many men.
Where possible it is therefore better to evaluate individuals based on their individual merits. This is not only more efficient, but creates a fairer and hopefully happier society.
Where did I imply that? If you go back one clause, I explicitly said that there can be disagreement on if it is a bad thing or not. [0]
I do not know how my opinion came across, but I believe this should make it clear that I am at least open to the possibility that the behavior under discussion is good behavior. [0]
>You can't just take away the context of the conversation and pretend that we are arguing about semantics.
What context? I was replying to a post describing his approach to avoid "overstepping with women" [2] and how "it's really not all that difficult". In doing so, I was pointing out how non obvious the solution was.
If a central tenet of your approach is "don't be sexist", and you proceed to make recommendations that are, on their face, sexist, it is not just a matter of semantics to point this out. It means that the standard of "don't be sexist" is seemingly useless because I cannot determine what types of technically sexist behavior don't count as actually sexist unless I have some independent test of what is acceptable. If I do have an independent test, then why bother saying don't be sexist, when you can just say to use my independent test of acceptability.
>For example, women are physically weaker than men, so if a man was to hit a woman in public, he would be arrested, where as if a woman was to hit a man in public, no one would blink an eye.
At this point, I hope I have made it clear that there exists (in my opinion) good sexism and bad sexism. I feel confident is saying that this is, unambiguously, bad sexism. [1] Women are not so week that they are incapable of committing assault; or that there is no damage done to the victim when they do so.
[0] To clarify my position somewhat, I have no idea if it is good behavior or not. In an ideal world, it would be bad behavior, and it has easy to articulate downsides. However, it has potential upsides of reducing bad sexism. I do not have the tools necessary to make a confident decision on the net effect.
[1] Or rather, the double standard you describe. Your observation itself, while potentially overstated, is simply a non sexist observation of sexist behavior. Or maybe the observation itself is biased by the sexism of the observer; again I do not have the tools to determine that.
[2] Pulled directly from from the submission title to avoid editorializing.
Just treat people nice. There's a way to compliment a woman's dress or hair without sounding like a creep. In fact, women who are friends do it all the time. It's part of how women form platonic relationships. One of the nicest compliments you can pay someone is noticing a conscious change that they've made in themselves!
Right? I'm one of the most socially awkward people I know but even I can pull off a "hey, nice new frames!", "cool T-shirt!", or "nice new haircut!" to a female co-worker without sounding like a creep. Claiming that's impossible to do "safely" – especially from someone in a managerial role, who should know how to talk to people – is just lazy CYA behavior.
EDIT: Side note – one of the clearest (subconscious) dividing lines between "creepy" and "normal" compliments is – how much time am I spending enjoying the thing I'm complimenting? If either your comment implies "I (may) have spent time staring at you to come to this conclusion", or if your focus (eyes/body position) lingers on the person you're complimenting, it will be perceived as creepy. If neither of these is true, it won't.
Examples:
"Nice new frames!" -- noncreepy. Not specific enough to have required more than a second's glance to formulate. Speaker may not even have actually formed an opinion.
"Those pants fit you well." -- creepy. You must have been looking at my butt and thighs for at least several seconds to come to this conclusion. Better: "That's such a cheery yellow blouse!" You could see and judge the color across the office in a second's time.
"I like your haircut", followed by several seconds of silence while you continue to look at me or my haircut -- creepy. You are enjoying this aspect of my body too much. Better: "I like your haircut", followed by topic change or end of conversation.
"You look good today / I like how you look" -- creepy. It's so nonspecific that I don't know what's going through your mind. Better: "I like the new look" (if the "new look" is something obvious), or be otherwise specific.
Note that all the above applies equally across or within genders. I (male) would indeed be creeped out if a male co-worker said one of the "creepy" examples above (with the possible exception of "you look good today", only because I might have more insight into what's in his head, assuming he is heterosexual). And I cannot think of one time a male co-worker has done so.
"Thank you for helping out today - it means a lot that I can always rely on you."
"I really appreciate the energy and positivity you bring to the office - you make this a way better place to work."
You get the idea.
Last comment: it's easy to assess your own comments as non-creepy, either out of bias or because you're genuinely non-creepy. Unfortunately, that assessment is worthless, because it's how others assess your comments that matters. Nor would I ever, as the "boss", want to have try and explain to anyone working for me, especially male employees, the elaborate and highly subjective set of "rules" you've laid out here. Far easier to just not go there.
I mean, if that's how you look at putting a modicum of effort into social interaction, you've got to question whether you really value relationships with co-workers of the opposite sex at all.
This article is basically just hating on the rich people.
I think it's rather easy to understand what this author is puzzled by: people want to keep their money. If you've earned your money and you want to keep it, I can empathize with you. If you think you deserve to take other people's money, I can't empathize with you.