iovrthoughtthis

this isn't individual devs fault

this is bad practice by service integrators

this is crazy

cant help but consider that fujitsu is an SI that competes with infosys and this really undermines fujitsu in the minds of british tac payers...

1. list all the people you know in each of these sorts of roles 2. ask them to either join you or if they know anyone who might be up for it or if they would help you hire someone by being your capability sense checker 3. if you can't drag together a rag tag team then you need to go out and meet more people

previous places you've worked are great sources, as are alumni networks, friends and family.

failing that, go become a part of a community like a runner club, rock climbing gym, music scene, maker space, game jam. ideally you do these thing because you enjoy the though.

be prepared to pay people. don't hire anyone you're not confident in (if you're not sure on someone because of pay then go out and find the money [yes, i am aware this is v hard])

imo we've not settled on a meta as the game is relatively new, has been changing a lot over the decades, they take a long time to play and lots of the learnings are fairly hidden in companies.

I suspect it will be used in generality haha

is this science to support back to the office?

I find this too concrete to be useful. I have a more principals / tradeoffs approach to code review:

Areas:

  - Readability - how understandable the code is
  - Maintainability - how the code enables the project to evolve
  - Risk - security, regulatory and other vulnerabilities
  - Correctness - whether the code does what you intended
  - Robustness - how well the code handles unintended circumstances
  - Performance - how resource efficient the code is

All of the above areas need to be considered within the context of the project and individual team members.

## Readability

Code is readable if it meets your expectations and surprises you only when there's something you don't yet know about the technology. We expect code to look like the code around it. To follow most, if not all of the technologies idioms. To use clear and informative names. To explain why deviance exists. To be as abstract as the concepts being abstracted are crystallised.

## Maintainability

Maintainability is the code's relationship with the wider team and time. You should be able to learn all you need to know to change, test and deploy code. You should be confident that any changes you make will not cause unintended changes elsewhere in the code. To make a change, you should have to touch as little code as the concepts being changed are crystallised. You should be able to debug an issue as easily as, the system the issue is in, is old. You should be able to track down and alter the changes that introduce a bug quickly. You should be able to learn why a change exists.

## Risk

Code is low risk if it accounts for, and where possible, mitigates the various risks to a project.

## Correctness

Correct code does as you expect and surprises you only when there something about the system you didn't yet understand. Validating correct code is as automated as the validations are frequent. Correct code is only as complicated as the concepts it models. Correct code is only as abstract as the concepts it models are crystallised.

## Robustness

Robust code handles unexpected circumstances safely, quickly and predictably. Validating robust code is as automated as the validations are frequent and as comprehensive as the failures are risky.

## Performance

Performant code is as resource efficient as the resources are expensive, but also as efficient as the development costs are cheap.

thus pattern divorces the code from the program ime

i appreciate that using an ide makes code navigation easier but i reject the notion that you should need one to navigate the code

TL;DR This is a bad example as we're mixing content construction with http service layer concepts. It should probably be more like:

    public class GreetingResource {
        @POST
        @Path("/make-greeting")
        public MakeGreetingResponse greet(final MakeGreetingRequest request) {
            return MakeGreetingResponse(Greeting(request.name, request.addendum));
        }

        public Greeting(string name, Value addendum) {
            if (addendum.isPresent()) {
                return "Hello, " + request.name + "! " + addendum.getValue();
            } else {
                return "Hello, " + request.name + "!";
            }
        }
    }

I think this is actually a little problematic. This handler is a likely location to mix http service logic with application logic and the interface exposed, via automatic parameter injection etc, implies the code in here should be application level but it's actually in the seam between then application and the http service layer.

Testing custom http service logic should involve mocking as it depends on objects and behaviours owned by the http service layer.

Code that we want to easily test for application level logic can be extracted into application level concepts.

Another social media power vacuum to fill. Who will take up the mantel?

RTO is a manager v labour issue.

100%

This is absolutely another form of layoffs. Google get the double benefit of 1) loose head count 2) only keeping dedicated* people.

They do loose people with the highest agency as they will be the first to leave.

* Those dedicated people could also just be most in need.

exactly

this is partially about wage depression

haha, it's absolutism v republicanism wearing new flesh!

whats old is new

dsl's are now little languages

the number one principal of a high performing engineering team needs to be that unblocking your peers is the most important thing you can do

if it's not, your peers will just invent work to feel useful while they wait for you to unblock them

teams that do this go fast, teams that dont go slow

you could probably use the managers salary to hire another floor employee to avoid such gaps in your particular example

but i think in general you are correct, but in reality i suspect many (but not all) managers dont actually provide any value, some even provide negative value

"Before starting the fundraising process, my first stop was to call up some VC friends of mine and ask them how to get things going."

ah, so it is

searching for a distinction between actively controlling a gui client vs passively controlling a interface-less client?

i would try not to fall prey to an entirely "rationalist" perspective here

you cannot predict the future and success is dependent at least as much on "luck" as it is on expertise

how have i never seen this!! :D

this is how everything echos through time, no joke

tea must terrify you!

powerful image!

this is not my experience. Jira is actually very opinionated about things in my experience. e.g. task hierarchies

it's just the pendulum of opinion swinging

the world needs yin and yang

we've had a good few years of self improvement being seen as good and noble. now for the return to mean

it will over swing the other way and productivity will return to the table in a different but similar form

like everything, this too shall pass

yup. we need to find a way to manage multiple owned borrows safely

a simple (not fully compliant) http 1 server from raw sockets usually gives me a good overview of the languages features and limitations

yeah, imo leadership and management are adjacent but separate things