You're a sick, twisted, depraved individual :P

It’s also the only functional programming language I’ve ever done. For its purpose - converting XML to XHTML, XSL-FOP, etc. - it’s insanely elegant and powerful.

XSL/x-path also lives on all over the place.

I hate XSLT with a burning passion.

Does anyone have a strong opinion on http/2?

I've been learning more about http and it seems interesting for many reasons.

HTTP2 has a lot of nice features, for sure. Adoption seems kind of middling?

There seems to be a lot of controversy on certain security implications.

I'm not sure if there is pushback on it basically being a Google spec via spdy, and if the security stuff is for real. It looks like there is a proposal out there that eliminates a major security concern.

When I asked about it to a slack channel I'm on some guy immediately bashed it for having security issues and optimizing at the wrong level. He's also a super ahole blowhard so I didnt just trust him and did my research to understand his position but it does seem like a decent gripe?

What are you going to do, ban people from developing them?

As long as there is incentive to make them (need, demand, money, fun, fame) people will do it.

I actually don't mind the . string concatenation operator at all, quite like it. Does take a minute to switch mindset though. Autohotkey uses it too. I'm much more annoyed by having to prefix all my variables with $.

I used to hate javascript, especially jquery.
I think react is amazing however.

The bitching I've heard is mostly along the lines of the fact that period allocated to designing the spec was so short that they basically had to take something that already existed (spdy)

Security wise, I dunno. It's not in the standard but due to adoption practices it'll be TLS only. I think it's missing opportunistic encryption, which some people wanted.

Optimizing at the wrong level... maybe.

I think it'll stay backwards compatible with HTTP/1.1 so I am mostly OK with it, but, they are basically doing a lot of stuff at the HTTP layer that looks more like things you'd do at the TCP layer, such as layering multiple parallel requests in one TCP channel, having the server push assets, etc.

Something that makes me a little nostalgic for the old days, vs HTTP/2, is that in the old days the protocol was so simple that you could telnet to a webserver address at port 80, type some stuff, and get a response. Like..

It was also easy to make very simple hand rolled tools that could act either as HTTP servers or clients, without making use of some rather-difficult-to-write libraries.

Like... when I was taking some class in college I wrote a webserver in bash. That's something you can do in HTTP/1 or 1.1 but probably not so easily in 2. Which is fine, as computers get more complicated, the tools probably have to get more advanced also. telnet doesn't even ship with most linux distros any more.

I fondly remember telnetting into SMTP servers to generate email with fake from addresses

My new favorite thing is reading over lots of code in lots of different files and figuring out the smallest change possible to thread the needle on a series of bugfixes.

I just pushed a PR that I think addresses several backlog bugs in prod, including one I recently found, and it's about 50 characters total.

I'm finding as I get better at programming I'm writing significantly less code.

Well maybe not less overall, but per feature/bugfix.

Bug fix: 5 lines

Opportunistic refactor: 200 lines

IMO :P

Still possible on lots of mail servers, I reckon.

Also, on your 5 line fix, you can expect 7-10 comments/objections in the PR.

On your 200 line change: LGTM

Heh I have a love hate relationship with refactoring. I enjoy doing it but I think most devs don't pick meaningful pieces to refactor.

Example, I recently saw someone spend 3 days refactoring two too big methods that do something very similar down to a separate class to contain all the logic for the sake of DRY. Meanwhile the code in the methods hasn't changed in two years, and there is no foreseeable reason it should change

I think new languages nowadays don’t really innovate and are either ego driven or a company trying to corner some market by becoming the new hotness (looking at you, Swift).

An example of a newer language that does something innovative is Java and the JVM. I’m all for new and innovative stuff but the languages coming out now don’t really seem to do anything that interesting that 400 other langs dont already do.

Compilers/langs are my pet area of study so i’m all for innovation but idk. Just some thing thats been rattling around my brain lately.

I'm not gonna lie, our backend is all Java and I don't really see a purpose in trying to learn it, but jmakin loves java and the jvm so much I may need to give this **** a try.

it's a love hate thing, what i love is that for almost any imaginable problem there is either a native library for it, or some plugin.

I like its strict typing and verbose exception class. I love its event handling capabilities, i love how you can easily redefine interfaces like compare, and i love its string processing capabilities. Also java servlets >>>>>>>>> PHP

what i really hate is how everything is an object, there are wrappers to everything, factories, Strings are immutable, verbose and confusing to read boilerplate code, and a lot of unnecessary overhead created during runtime. I could go on about a billion other tiny things I hate.

i decided to do this entire programming challenge course in Java and so far I have easily implemented everything except last week where I was supposed to load a plugin to an already compiled file, and i couldnt figure out a way to easily do that so i gave up.

The JVM is very interesting. I unfortunately had to drop a graduate level project course I wanted to take this quarter - the assignment was to implement the JVM from scratch. Lol. Even if my schedule wasn't insane I would probably fail.

It's funny to call java "newer"

Java is old enough to drink

Wat, why

Newer in the sense that some still commonly used languages have been around for almost 50 years, and in the sense that newer versions of java have so much more going on than the original, but i guess that’s true of most languages

I had to listen to some java nerd go on about how great functional programming in it was. Ugh

have you ever had this common mistake wreck absolute havoc at runtime and not understood why?

str += "foo";


this is fine for small strings. but if your string is say, the size of pride and prejudice (which happened to me recently) then it has to destroy and recreate the entire string just to append. you need to use stringbuilder to concat to a large string.

now, every java dev knows this and will avoid this mistake, but it's quite unintuitive that every method that modifies a string actually destroys the entire object and recreates it.