2,220 karma · joined October 30, 2018
https://blogs.oracle.com/java-platform-group/a-new-japanese-...
I feel everything else is the same for anyone outside SV. Can't meet deadlines (but that's because everything takes longer than you think it will, even when you account for hoffstadter's (sp?) law) and trying to bootstrap stuff in your spare time is next to impossible. Not impossible, but It's right up there with the most difficult things you could try and do.
Outside that, yeah. It indeed boggles the mind that the vanilla version of it could be failed by anyone who has taken elementary programming course.
You can make FizzBuzz incredibly complicated if you deviate from the vanilla FizzBuzz.
If you're a SaaS company and you're hiring a sales person, instead of the typical "sell me this pen" you can even replace it with "sell me FizzBuzz".
I'm telling you, it's bullet proof.
There are 5x more white people than black people in the US (roughly). So... it's kind of understandable that any training data set would contain more white people than black people if you didn't filter it beforehand?
I guess theoretically you would have to limit the size of the training data for all groups to the size of the set of training data you have on the smallest group, so that all groups could be represented equally in the training data, but then perhaps you get a far less accurate model overall and it results in greater negative consequences?
Just spit balling here. But it's a complex problem.
The whole 'racist AI' thing screams Conway's Law to me.
I learned kanji first before speaking. Learned to read and listen for about a year before venturing out to conversation clubs and the like. Without a shadow of a doubt reading massively, massively, massively boosted my ability in all other areas. Fastest way to learn new vocabulary.
But I gotta be honest - I used to love kanji and found joy in it. These days I think Korean really got it right with their writing system. That shit is super logical. Kanji is a giant, beautiful pain in the ass.
And figuring that out becomes a massive time suck when that's a constant across an entire code base. Statically typed stuff means I can very quickly find that out even if it's the first time i'm exploring that particular area of the code.
How on earth do you use 7 monitors for work?
I'm encouraged by your success of this model. I'm currently struggling with the 'billing system as source of truth' model.
You can be on slack or email or around the water-cooler all day long. I don't think that makes that much difference. It's not like as soon as you bring Slack into an organization all this structure emerges that helps you focus your efforts on what to do. Chat app or no chat app, people are always coordinating with each other to complete task-level work.
OKRs help you think first strategically (longer than 1 year) then tactically (between 1 month to 1 year) and then operationally (day to day, week to week). Chat apps don't do that for you.
They just aren't related.
Currently where I work we have a fixed allocation % of dev/test time for technical improvements. In practice it works really well if you approach it strategically and use it to achieve things over the long term. Things you can just chip away at that steadily improve the health of the code, architecture and product. I find if it's used on a purely operational basis where you just ad-hoc improve stuff you find then it's not super effective, but it's pretty solid when the team is onboard with leveraging it to achieve better and better DX over the long term. Otherwise "refactoring" barely ever gets done and products slowly suffer bit-rot.
I think OKRs are a perfect fit for such a scenario. We don't use them, but I kinda use them internally as part of my mental model.
Ones a chat app the other is a system of setting objectives and measuring against those objectives.
You're quite right that by default there is no hand holding by Java itself on the matter and if you have to solve it yourself it's quite a not fun problem the first time you come across it.
It bothered me in the early days, but after switching to Spring Boot the problem melted away entirely. If you use https://start.spring.io select what you want, hit download and import as a Maven (or Gradle) project and bobs your uncle. Boot automatically builds a fat jar and it just works. Friction drops to zero in that particular configuration.
I'm not a fan of Maven either. Before leaving Java land I settled on using Gradle and was much happier with that. Some people don't like that it runs a daemon and uses resources or that builds are custom with it, but I don't mind those things at all and I found it a real breath of fresh air compared to Maven.
Another point of difference between native .NET shops and native Java shops that I have found is approach towards development environments. My sample size is small here, but so far I've seen that Java shops run windows, but have development VMs that you can just download an image, drop it into your machine, pull down the repo and the image is pre-configured with all the right stuff to build and develop. Linux natives are heavily into scripting things and the devops usually works quite nice, but I find it also breaks more frequently because it tends to be _somewhat_ brittle.
In .NET shops I haven't seen that. It's mostly been they run on Windows and develop on Windows (duh) but that means you have to manually do a bunch of setup and spend a day installing stuff when you start and everyones machine is a tiny bit different.
I can't say I've found one better than the other, but if it were me I'd run .NET Core development and do it on Linux in VMs.
IMO when you see a lot of variance that's a smell. There isn't an obvious or known good way to do something or there is no convention you get a lot of entropy creeping in. I find the folder/path based stuff at least has a convention or two that keep things in roughly the same shape from project to project. I prefer that this is the case than what I see with C# projects.
Anyway, it's just my pet peeve.
(b) debug symbols could just be included in the compilation unit and optionally stripped out using a flag when you compile. There isn't a need for it to be in a separate file. A lot of fun times attaching DnSpy to something to half-ass debug it through a decompiler because there was no .pdb and you can't debug without it. Just painful. Wish they never split the debug symbols into a separate file.
(c) I guess my colleagues are forcing me to use Nuget as I can't just show up tomorrow and switch everything to Paket. I don't have to use it on my personal projects, which is nice.
Nuget's problems stem from what I'm talking about here. You need Newtonsoft.Json in various different csproj files, so you reference it in both of them. If you're not careful it easily winds up in a situation where you have multiple different versions of .NET in a single .sln file and multiple different versions of Newtonsoft.Json and the dreaded "multiple conflicting versions of a dependent assembly" warning. Etc.
Comparing it to my experience in the Java world I remember it's still possible to split the project up and open separate parts if I want, but the whole thing has one unified version of Java and a unified set of dependencies. Just never wound up with the messy tangles I see in .NET projects.
It's about my only beef with .NET stuff. Really irks me. Paket looks like a step forward though in terms of Package management, but it's not the defacto standard.
And this must be related to needing to have pdb file or being unable to debug.
I wish those two things were not the case. And nuget.
I find C# wonderful except those particular decisions give me pain on a daily basis.