258 karma · joined March 3, 2013
Called them and had an endless loop of
- "I think this is a manufacturing fault"
- "Cracks in the screen are ALWAYS accidental damage and not covered under warranty"
- "But I didn't have an accident with it, so ..."
- "Cracks in the screen are ALWAYS accidental damage and not covered under warranty"
... and so on and so on.
Now, after the most recent graphics board meltdown I am on an XPS13 with Ubuntu, and I can honestly say that apple are off my shopping list for good.
My mbp gave up and I was over the whole apple thing, so I went for a previous revision one just around xmas and installed Ubuntu myself (Australia doesn't get the Developer Version).
It's a great machine, and I love it, but then I got miffed when they rolled out a new revision just after I decided to buy. However, I had a feeling that Linux on the previous revision would be a lot more solid, and your post confirms that.
Like the OP I started doing with design-y tasks as an intern in a web shop. Then followed a lot of t.gif style table layouts. Then followed some flash development, and my fist scripting with ActionScript and copy-paste JS stuff. Then ASP classic and PHP.
Then followed the push towards semantic html and progressive enhancement, and the first JS libs like mootools started popping up to be eventually boiled down into jQuery.
Couple years later and it was all about MVC frameworks, databases and so on. Like the OP I did php based stuff, and it meant learning 4+ different frameworks, i.e Cake, Zend, Symfony and so on.
At the same time there was Agile and TDD coming into the mix and you had to learn a whole lot on how to do your work.
Following that I started looking into node pretty early on and that shifted my understanding of JS as a language and pushed me into the niche where I am working today, namely JS stuff be it server or client.
Looking at the current tech choices and popular stacks, or even just the browser APIs available and coming, I cannot believe how far things have gotten. On one hand things have become a lot easier for menial dev tasks, you have things like bower and grunt/gulp whatever really helping you, boilerplate generators and the likes. Deployment is often just a git push so some PaaS or some docker file and shell script. On the other hand is just SO MUCH OF IT, that it's impossible to keep on top of even one aspect of the stack properly if you need to get on with making stuff and have a life. If you just take the browser these days (audio API, Web GL and so on). In 15 years of dev work I have learnt and forgotten so much that my brain feels like a sieve. My approach to deal with that is to not desperately try and REALLY remember many things. Instead I just focus on the current stack I'm working with and remember the general concepts of that, plus some good knowledge of where to look for things. Come the next project in a different stack I basically anticipate a learning curve.
Also the great east berlin telephone line distribution node: 50 wires coming in, 100 going out ... only 50 of those were for households.
All of this can be seen in the Berlin Communications Museum.
I also have the impression that there are quite a few people with older browsers out there because of the screen reader setup, and I don't think that's a good thing, but maybe it's a matter of doing what we're doing to older browsers in general: phase out support.
Full on angular app, no native forms or form elements (because they "look ugly" apparently).
Then the ultimate end client wants to go live but forgot to mention they had a mandatory accessibility audit.
So I've spent quite a bit of time working out how to make things work for screen readers using the ARIA specs. And it really worked quite well. My takeaway from this is to make sure everything is working with the keyboard correctly, spend some time thinking about tabindex, labels etc, and where I can push back requests to get rid of native browser elements.
I'm not saying that there aren't any good ones somewhere else, but I just haven't really met any.
Why does it have to be like that? This sort of silo thinking is probably what created the disconnect in the first place.
The customer might care about how things get done, if it means the difference between getting 85% of their wish list done or 50%, all depending on one obscure feature.
Agile/SCRUM can make the potential complexity of a feature more visible because it's a team estimate. It also can make the decision process less laggy because the customer/product owner sits in on the team. Finally it can make the end goal more visible to the Devs, resulting in less of a disconnect.
My 2p
I too have worked in places that called themselves Agile but where everything but.
On the other hand I also was part of a well adjusted SCRUM team where the roles were fulfilled properly and we rolled through the project like a steam train. The key was to have a really well filled backlog and then wear most of the pain during the sprint estimation meetings, and the whole team sat in on that. This made everybody understand all the features and their potential complexity before the sprint even started, and gave full visibility of the cost of each of these to the product owner, who could de-prioritise something or swap it out in that very session. The actual sprints then were really straight forward and I really enjoyed myself there.
Prior to that I had plenty of contracts where I get "specs" from PMs, but then have to question each aspect of those, often resulting in me having to ask the product owner myself to decipher what it meant. Inevitably, nobody ever had time and I spent 50% of my day waiting for people getting back to me or work on whatever I could come up with.
I've rarely met a good one. In most agency style environments PMs are responsible for the messes that will have to be picked up by the devs, having promised the world and are unable to backtrack on any of it "because the customer has already agreed to it". I'd rather talk to someone about what they want out of their product and then let them make an informed decision where they can weigh up cost and impact of a certain feature. After all it's their money.
In this context (Restful JSON or XML from the server, JS client consuming it) Go again makes a great choice, as it's coming with great JSON and XML capabilities that make it easy to marshal/unmarshal into GO types.
Their approach is to have the whole framework compiled as an extension. Seems well documented.
Personally, after years of dealing with PHP and the regularly occurring panic when inevitably something is going wrong during deployment, I'd consider PHP's dependency on other moving parts a bit of a nono. There's just too many pain points around deployment, versioning, server conf, extensions that are compiled in etc. Admittedly this has gotten much much better since the advent of composer and tools like chef, vagrant etc, but that's another whole learning curve right there. Compare that to go, where you just compile your binary, scp that up and then launch it. Done!
So whenever I hear this question in that very particular tone, I already plan my exit strategy because I know it's going to be a train wreck.
Edit: Very interesting read liked from there ... https://groups.google.com/forum/m/#!msg/reactjs/eUespJPdyas/...